content/child/dwrite_font_proxy/dwrite_font_proxy_win_unittest.cc - chromium/src - Git at Google

 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "content/child/dwrite_font_proxy/dwrite_font_proxy_win.h"

 #include <dwrite.h>
 #include <shlobj.h>
 #include <wrl.h>

 #include <memory>

 #include "base/memory/ref_counted.h"
 #include "base/test/scoped_task_environment.h"
 #include "content/test/dwrite_font_fake_sender_win.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace mswr = Microsoft::WRL;

 namespace content {

 namespace {

 class DWriteFontProxyUnitTest : public testing::Test {
  public:
   DWriteFontProxyUnitTest() {
     fake_collection_ = std::make_unique<FakeFontCollection>();
     SetupFonts(fake_collection_.get());
     DWriteFontCollectionProxy::Create(&collection_, factory.Get(),
                                       fake_collection_->CreatePtr());
     EXPECT_TRUE(collection_.Get());
   }

   ~DWriteFontProxyUnitTest() override {
     if (collection_)
       collection_->Unregister();
   }

   static void SetupFonts(FakeFontCollection* fonts) {
     fonts->AddFont(L"Aardvark")
         .AddFamilyName(L"en-us", L"Aardvark")
         .AddFamilyName(L"de-de", L"Erdferkel")
         .AddFilePath(base::FilePath(L"X:\\Nonexistent\\Folder\\Aardvark.ttf"));
     FakeFont& arial =
         fonts->AddFont(L"Arial").AddFamilyName(L"en-us", L"Arial");
     for (auto& path : arial_font_files)
       arial.AddFilePath(base::FilePath(path));
     fonts->AddFont(L"Times New Roman")
         .AddFamilyName(L"en-us", L"Times New Roman")
         .AddFilePath(base::FilePath(L"X:\\Nonexistent\\Folder\\Times.ttf"));
   }

   static void SetUpTestCase() {
     DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
                         &factory);

     std::vector<base::char16> font_path;
     font_path.resize(MAX_PATH);
     SHGetSpecialFolderPath(nullptr /* hwndOwner - reserved */, font_path.data(),
                            CSIDL_FONTS, FALSE /* fCreate*/);
     base::string16 arial;
     arial.append(font_path.data()).append(L"\\arial.ttf");
     base::string16 arialbd;
     arialbd.append(font_path.data()).append(L"\\arialbd.ttf");
     arial_font_files.push_back(arial);
     arial_font_files.push_back(arialbd);
   }

  protected:
   base::test::ScopedTaskEnvironment task_environment;
   std::unique_ptr<FakeFontCollection> fake_collection_;
   mswr::ComPtr<DWriteFontCollectionProxy> collection_;

   static std::vector<base::string16> arial_font_files;
   static mswr::ComPtr<IDWriteFactory> factory;
 };
 std::vector<base::string16> DWriteFontProxyUnitTest::arial_font_files;
 mswr::ComPtr<IDWriteFactory> DWriteFontProxyUnitTest::factory;

 TEST_F(DWriteFontProxyUnitTest, GetFontFamilyCount) {
   UINT32 family_count = collection_->GetFontFamilyCount();

   EXPECT_EQ(3u, family_count);
   ASSERT_EQ(1u, fake_collection_->MessageCount());
   EXPECT_EQ(FakeFontCollection::MessageType::kGetFamilyCount,
             fake_collection_->GetMessageType(0));

   // Calling again should not cause another message to be sent.
   family_count = collection_->GetFontFamilyCount();
   EXPECT_EQ(3u, family_count);
   ASSERT_EQ(1u, fake_collection_->MessageCount());
 }

 TEST_F(DWriteFontProxyUnitTest, FindFamilyNameShouldFindFamily) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Arial", &index, &exists);

   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(1u, index);
   EXPECT_TRUE(exists);
   ASSERT_EQ(2u, fake_collection_->MessageCount());
   EXPECT_EQ(FakeFontCollection::MessageType::kFindFamily,
             fake_collection_->GetMessageType(0));
   EXPECT_EQ(FakeFontCollection::MessageType::kGetFamilyCount,
             fake_collection_->GetMessageType(1));
 }

 TEST_F(DWriteFontProxyUnitTest, FindFamilyNameShouldReturnUINTMAXWhenNotFound) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Not a font", &index, &exists);

   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(UINT32_MAX, index);
   EXPECT_FALSE(exists);
   ASSERT_EQ(1u, fake_collection_->MessageCount());
   EXPECT_EQ(FakeFontCollection::MessageType::kFindFamily,
             fake_collection_->GetMessageType(0));
 }

 TEST_F(DWriteFontProxyUnitTest, FindFamilyNameShouldNotSendDuplicateIPC) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Arial", &index, &exists);
   ASSERT_EQ(S_OK, hr);
   ASSERT_EQ(2u, fake_collection_->MessageCount());

   hr = collection_->FindFamilyName(L"Arial", &index, &exists);

   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(2u, fake_collection_->MessageCount());
 }

 TEST_F(DWriteFontProxyUnitTest, GetFontFamilyShouldCreateFamily) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Arial", &index, &exists);
   ASSERT_EQ(2u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteFontFamily> family;
   hr = collection_->GetFontFamily(2, &family);

   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(2u, fake_collection_->MessageCount());
   EXPECT_NE(nullptr, family.Get());
 }

 void CheckLocale(const base::string16& locale_name,
                  const base::string16& expected_value,
                  IDWriteLocalizedStrings* strings) {
   UINT32 locale_index = 0;
   BOOL locale_exists = FALSE;
   strings->FindLocaleName(locale_name.data(), &locale_index, &locale_exists);
   EXPECT_TRUE(locale_exists);

   UINT32 name_length = 0;
   strings->GetLocaleNameLength(locale_index, &name_length);
   EXPECT_EQ(locale_name.size(), name_length);
   base::string16 actual_name;
   name_length++;
   actual_name.resize(name_length);
   strings->GetLocaleName(locale_index, const_cast<WCHAR*>(actual_name.data()),
                          name_length);
   EXPECT_STREQ(locale_name.c_str(), actual_name.c_str());

   UINT32 string_length = 0;
   strings->GetStringLength(locale_index, &string_length);
   EXPECT_EQ(expected_value.size(), string_length);
   base::string16 actual_value;
   string_length++;
   actual_value.resize(string_length);
   strings->GetString(locale_index, const_cast<WCHAR*>(actual_value.data()),
                      string_length);
   EXPECT_STREQ(expected_value.c_str(), actual_value.c_str());
 }

 TEST_F(DWriteFontProxyUnitTest, GetFamilyNames) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Aardvark", &index, &exists);
   ASSERT_EQ(2u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteFontFamily> family;
   hr = collection_->GetFontFamily(index, &family);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(2u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteLocalizedStrings> names;
   hr = family->GetFamilyNames(&names);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(3u, fake_collection_->MessageCount());
   EXPECT_EQ(FakeFontCollection::MessageType::kGetFamilyNames,
             fake_collection_->GetMessageType(2));

   EXPECT_EQ(2u, names->GetCount());
   UINT32 locale_index = 0;
   BOOL locale_exists = FALSE;
   hr = names->FindLocaleName(L"fr-fr", &locale_index, &locale_exists);
   EXPECT_EQ(S_OK, hr);
   EXPECT_FALSE(locale_exists);

   CheckLocale(L"en-us", L"Aardvark", names.Get());
   CheckLocale(L"de-de", L"Erdferkel", names.Get());

   base::string16 unused;
   unused.resize(25);
   hr = names->GetLocaleName(15234, const_cast<WCHAR*>(unused.data()),
                             unused.size() - 1);
   EXPECT_FALSE(SUCCEEDED(hr));
 }

 TEST_F(DWriteFontProxyUnitTest, GetFontCollection) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Arial", &index, &exists);
   ASSERT_EQ(2u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteFontFamily> family;
   hr = collection_->GetFontFamily(2, &family);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(2u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteFontCollection> returned_collection;
   hr = family->GetFontCollection(&returned_collection);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(2u, fake_collection_->MessageCount());
   EXPECT_EQ(collection_.Get(), returned_collection.Get());
 }

 TEST_F(DWriteFontProxyUnitTest, GetFamilyNamesShouldNotIPCAfterLoadingFamily) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   collection_->FindFamilyName(L"Arial", &index, &exists);
   mswr::ComPtr<IDWriteFontFamily> family;
   collection_->GetFontFamily(index, &family);
   family->GetFontCount();
   EXPECT_EQ(3u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteLocalizedStrings> names;
   hr = family->GetFamilyNames(&names);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(3u, fake_collection_->MessageCount());
 }

 TEST_F(DWriteFontProxyUnitTest,
        GetFontFamilyShouldNotCreateFamilyWhenIndexIsInvalid) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   hr = collection_->FindFamilyName(L"Arial", &index, &exists);
   ASSERT_EQ(2u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteFontFamily> family;
   hr = collection_->GetFontFamily(1654, &family);

   EXPECT_FALSE(SUCCEEDED(hr));
   EXPECT_EQ(2u, fake_collection_->MessageCount());
 }

 TEST_F(DWriteFontProxyUnitTest, LoadingFontFamily) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   collection_->FindFamilyName(L"Arial", &index, &exists);
   mswr::ComPtr<IDWriteFontFamily> family;
   collection_->GetFontFamily(index, &family);
   ASSERT_EQ(2u, fake_collection_->MessageCount());

   UINT32 font_count = family->GetFontCount();
   EXPECT_LT(0u, font_count);
   EXPECT_EQ(3u, fake_collection_->MessageCount());
   EXPECT_EQ(FakeFontCollection::MessageType::kGetFontFiles,
             fake_collection_->GetMessageType(2));
   mswr::ComPtr<IDWriteFont> font;
   hr = family->GetFirstMatchingFont(DWRITE_FONT_WEIGHT_NORMAL,
                                     DWRITE_FONT_STRETCH_NORMAL,
                                     DWRITE_FONT_STYLE_NORMAL, &font);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(3u, fake_collection_->MessageCount());
   mswr::ComPtr<IDWriteFont> font2;
   hr = family->GetFont(0, &font2);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(3u, fake_collection_->MessageCount());
   mswr::ComPtr<IDWriteFontList> matching_fonts;
   hr = family->GetMatchingFonts(DWRITE_FONT_WEIGHT_NORMAL,
                                 DWRITE_FONT_STRETCH_NORMAL,
                                 DWRITE_FONT_STYLE_NORMAL, &matching_fonts);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(3u, fake_collection_->MessageCount());
   EXPECT_NE(nullptr, matching_fonts.Get());
 }

 TEST_F(DWriteFontProxyUnitTest, GetFontFromFontFaceShouldFindFont) {
   HRESULT hr;

   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   collection_->FindFamilyName(L"Arial", &index, &exists);
   mswr::ComPtr<IDWriteFontFamily> family;
   collection_->GetFontFamily(index, &family);

   mswr::ComPtr<IDWriteFont> font;
   family->GetFirstMatchingFont(DWRITE_FONT_WEIGHT_NORMAL,
                                DWRITE_FONT_STRETCH_NORMAL,
                                DWRITE_FONT_STYLE_NORMAL, &font);

   mswr::ComPtr<IDWriteFontFace> font_face;
   hr = font->CreateFontFace(&font_face);
   ASSERT_TRUE(SUCCEEDED(hr));
   ASSERT_EQ(3u, fake_collection_->MessageCount());

   mswr::ComPtr<IDWriteFont> found_font;
   collection_->GetFontFromFontFace(font_face.Get(), &found_font);
   EXPECT_NE(nullptr, found_font.Get());
   EXPECT_EQ(3u, fake_collection_->MessageCount());
 }

 TEST_F(DWriteFontProxyUnitTest, TestCustomFontFiles) {
   FakeFontCollection fonts;
   FakeFont& arial = fonts.AddFont(L"Arial").AddFamilyName(L"en-us", L"Arial");
   for (auto& path : arial_font_files) {
     base::File file(base::FilePath(path), base::File::FLAG_OPEN |
                                               base::File::FLAG_READ |
                                               base::File::FLAG_EXCLUSIVE_WRITE);
     arial.AddFileHandle(std::move(file));
   }
   mswr::ComPtr<DWriteFontCollectionProxy> collection;
   DWriteFontCollectionProxy::Create(&collection, factory.Get(),
                                     fonts.CreatePtr());

   // Check that we can get the font family and match a font.
   UINT32 index = UINT_MAX;
   BOOL exists = FALSE;
   collection->FindFamilyName(L"Arial", &index, &exists);
   mswr::ComPtr<IDWriteFontFamily> family;
   collection->GetFontFamily(index, &family);

   mswr::ComPtr<IDWriteFont> font;
   HRESULT hr = family->GetFirstMatchingFont(DWRITE_FONT_WEIGHT_NORMAL,
                                             DWRITE_FONT_STRETCH_NORMAL,
                                             DWRITE_FONT_STYLE_NORMAL, &font);

   EXPECT_TRUE(SUCCEEDED(hr));
   EXPECT_NE(nullptr, font.Get());

   mswr::ComPtr<IDWriteFontFace> font_face;
   hr = font->CreateFontFace(&font_face);
   EXPECT_TRUE(SUCCEEDED(hr));
 }

 }  // namespace

 }  // namespace content
	// Copyright (c) 2015 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "content/child/dwrite_font_proxy/dwrite_font_proxy_win.h"

	#include <dwrite.h>
	#include <shlobj.h>
	#include <wrl.h>

	#include <memory>

	#include "base/memory/ref_counted.h"
	#include "base/test/scoped_task_environment.h"
	#include "content/test/dwrite_font_fake_sender_win.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace mswr = Microsoft::WRL;

	namespace content {

	namespace {

	class DWriteFontProxyUnitTest : public testing::Test {
	public:
	DWriteFontProxyUnitTest() {
	fake_collection_ = std::make_unique<FakeFontCollection>();
	SetupFonts(fake_collection_.get());
	DWriteFontCollectionProxy::Create(&collection_, factory.Get(),
	fake_collection_->CreatePtr());
	EXPECT_TRUE(collection_.Get());
	}

	~DWriteFontProxyUnitTest() override {
	if (collection_)
	collection_->Unregister();
	}

	static void SetupFonts(FakeFontCollection* fonts) {
	fonts->AddFont(L"Aardvark")
	.AddFamilyName(L"en-us", L"Aardvark")
	.AddFamilyName(L"de-de", L"Erdferkel")
	.AddFilePath(base::FilePath(L"X:\\Nonexistent\\Folder\\Aardvark.ttf"));
	FakeFont& arial =
	fonts->AddFont(L"Arial").AddFamilyName(L"en-us", L"Arial");
	for (auto& path : arial_font_files)
	arial.AddFilePath(base::FilePath(path));
	fonts->AddFont(L"Times New Roman")
	.AddFamilyName(L"en-us", L"Times New Roman")
	.AddFilePath(base::FilePath(L"X:\\Nonexistent\\Folder\\Times.ttf"));
	}

	static void SetUpTestCase() {
	DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
	&factory);

	std::vector<base::char16> font_path;
	font_path.resize(MAX_PATH);
	SHGetSpecialFolderPath(nullptr /* hwndOwner - reserved */, font_path.data(),
	CSIDL_FONTS, FALSE /* fCreate*/);
	base::string16 arial;
	arial.append(font_path.data()).append(L"\\arial.ttf");
	base::string16 arialbd;
	arialbd.append(font_path.data()).append(L"\\arialbd.ttf");
	arial_font_files.push_back(arial);
	arial_font_files.push_back(arialbd);
	}

	protected:
	base::test::ScopedTaskEnvironment task_environment;
	std::unique_ptr<FakeFontCollection> fake_collection_;
	mswr::ComPtr<DWriteFontCollectionProxy> collection_;

	static std::vector<base::string16> arial_font_files;
	static mswr::ComPtr<IDWriteFactory> factory;
	};
	std::vector<base::string16> DWriteFontProxyUnitTest::arial_font_files;
	mswr::ComPtr<IDWriteFactory> DWriteFontProxyUnitTest::factory;

	TEST_F(DWriteFontProxyUnitTest, GetFontFamilyCount) {
	UINT32 family_count = collection_->GetFontFamilyCount();

	EXPECT_EQ(3u, family_count);
	ASSERT_EQ(1u, fake_collection_->MessageCount());
	EXPECT_EQ(FakeFontCollection::MessageType::kGetFamilyCount,
	fake_collection_->GetMessageType(0));

	// Calling again should not cause another message to be sent.
	family_count = collection_->GetFontFamilyCount();
	EXPECT_EQ(3u, family_count);
	ASSERT_EQ(1u, fake_collection_->MessageCount());
	}

	TEST_F(DWriteFontProxyUnitTest, FindFamilyNameShouldFindFamily) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Arial", &index, &exists);

	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(1u, index);
	EXPECT_TRUE(exists);
	ASSERT_EQ(2u, fake_collection_->MessageCount());
	EXPECT_EQ(FakeFontCollection::MessageType::kFindFamily,
	fake_collection_->GetMessageType(0));
	EXPECT_EQ(FakeFontCollection::MessageType::kGetFamilyCount,
	fake_collection_->GetMessageType(1));
	}

	TEST_F(DWriteFontProxyUnitTest, FindFamilyNameShouldReturnUINTMAXWhenNotFound) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Not a font", &index, &exists);

	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(UINT32_MAX, index);
	EXPECT_FALSE(exists);
	ASSERT_EQ(1u, fake_collection_->MessageCount());
	EXPECT_EQ(FakeFontCollection::MessageType::kFindFamily,
	fake_collection_->GetMessageType(0));
	}

	TEST_F(DWriteFontProxyUnitTest, FindFamilyNameShouldNotSendDuplicateIPC) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Arial", &index, &exists);
	ASSERT_EQ(S_OK, hr);
	ASSERT_EQ(2u, fake_collection_->MessageCount());

	hr = collection_->FindFamilyName(L"Arial", &index, &exists);

	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(2u, fake_collection_->MessageCount());
	}

	TEST_F(DWriteFontProxyUnitTest, GetFontFamilyShouldCreateFamily) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Arial", &index, &exists);
	ASSERT_EQ(2u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteFontFamily> family;
	hr = collection_->GetFontFamily(2, &family);

	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(2u, fake_collection_->MessageCount());
	EXPECT_NE(nullptr, family.Get());
	}

	void CheckLocale(const base::string16& locale_name,
	const base::string16& expected_value,
	IDWriteLocalizedStrings* strings) {
	UINT32 locale_index = 0;
	BOOL locale_exists = FALSE;
	strings->FindLocaleName(locale_name.data(), &locale_index, &locale_exists);
	EXPECT_TRUE(locale_exists);

	UINT32 name_length = 0;
	strings->GetLocaleNameLength(locale_index, &name_length);
	EXPECT_EQ(locale_name.size(), name_length);
	base::string16 actual_name;
	name_length++;
	actual_name.resize(name_length);
	strings->GetLocaleName(locale_index, const_cast<WCHAR*>(actual_name.data()),
	name_length);
	EXPECT_STREQ(locale_name.c_str(), actual_name.c_str());

	UINT32 string_length = 0;
	strings->GetStringLength(locale_index, &string_length);
	EXPECT_EQ(expected_value.size(), string_length);
	base::string16 actual_value;
	string_length++;
	actual_value.resize(string_length);
	strings->GetString(locale_index, const_cast<WCHAR*>(actual_value.data()),
	string_length);
	EXPECT_STREQ(expected_value.c_str(), actual_value.c_str());
	}

	TEST_F(DWriteFontProxyUnitTest, GetFamilyNames) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Aardvark", &index, &exists);
	ASSERT_EQ(2u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteFontFamily> family;
	hr = collection_->GetFontFamily(index, &family);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(2u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteLocalizedStrings> names;
	hr = family->GetFamilyNames(&names);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	EXPECT_EQ(FakeFontCollection::MessageType::kGetFamilyNames,
	fake_collection_->GetMessageType(2));

	EXPECT_EQ(2u, names->GetCount());
	UINT32 locale_index = 0;
	BOOL locale_exists = FALSE;
	hr = names->FindLocaleName(L"fr-fr", &locale_index, &locale_exists);
	EXPECT_EQ(S_OK, hr);
	EXPECT_FALSE(locale_exists);

	CheckLocale(L"en-us", L"Aardvark", names.Get());
	CheckLocale(L"de-de", L"Erdferkel", names.Get());

	base::string16 unused;
	unused.resize(25);
	hr = names->GetLocaleName(15234, const_cast<WCHAR*>(unused.data()),
	unused.size() - 1);
	EXPECT_FALSE(SUCCEEDED(hr));
	}

	TEST_F(DWriteFontProxyUnitTest, GetFontCollection) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Arial", &index, &exists);
	ASSERT_EQ(2u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteFontFamily> family;
	hr = collection_->GetFontFamily(2, &family);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(2u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteFontCollection> returned_collection;
	hr = family->GetFontCollection(&returned_collection);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(2u, fake_collection_->MessageCount());
	EXPECT_EQ(collection_.Get(), returned_collection.Get());
	}

	TEST_F(DWriteFontProxyUnitTest, GetFamilyNamesShouldNotIPCAfterLoadingFamily) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	collection_->FindFamilyName(L"Arial", &index, &exists);
	mswr::ComPtr<IDWriteFontFamily> family;
	collection_->GetFontFamily(index, &family);
	family->GetFontCount();
	EXPECT_EQ(3u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteLocalizedStrings> names;
	hr = family->GetFamilyNames(&names);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	}

	TEST_F(DWriteFontProxyUnitTest,
	GetFontFamilyShouldNotCreateFamilyWhenIndexIsInvalid) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	hr = collection_->FindFamilyName(L"Arial", &index, &exists);
	ASSERT_EQ(2u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteFontFamily> family;
	hr = collection_->GetFontFamily(1654, &family);

	EXPECT_FALSE(SUCCEEDED(hr));
	EXPECT_EQ(2u, fake_collection_->MessageCount());
	}

	TEST_F(DWriteFontProxyUnitTest, LoadingFontFamily) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	collection_->FindFamilyName(L"Arial", &index, &exists);
	mswr::ComPtr<IDWriteFontFamily> family;
	collection_->GetFontFamily(index, &family);
	ASSERT_EQ(2u, fake_collection_->MessageCount());

	UINT32 font_count = family->GetFontCount();
	EXPECT_LT(0u, font_count);
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	EXPECT_EQ(FakeFontCollection::MessageType::kGetFontFiles,
	fake_collection_->GetMessageType(2));
	mswr::ComPtr<IDWriteFont> font;
	hr = family->GetFirstMatchingFont(DWRITE_FONT_WEIGHT_NORMAL,
	DWRITE_FONT_STRETCH_NORMAL,
	DWRITE_FONT_STYLE_NORMAL, &font);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	mswr::ComPtr<IDWriteFont> font2;
	hr = family->GetFont(0, &font2);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	mswr::ComPtr<IDWriteFontList> matching_fonts;
	hr = family->GetMatchingFonts(DWRITE_FONT_WEIGHT_NORMAL,
	DWRITE_FONT_STRETCH_NORMAL,
	DWRITE_FONT_STYLE_NORMAL, &matching_fonts);
	EXPECT_EQ(S_OK, hr);
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	EXPECT_NE(nullptr, matching_fonts.Get());
	}

	TEST_F(DWriteFontProxyUnitTest, GetFontFromFontFaceShouldFindFont) {
	HRESULT hr;

	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	collection_->FindFamilyName(L"Arial", &index, &exists);
	mswr::ComPtr<IDWriteFontFamily> family;
	collection_->GetFontFamily(index, &family);

	mswr::ComPtr<IDWriteFont> font;
	family->GetFirstMatchingFont(DWRITE_FONT_WEIGHT_NORMAL,
	DWRITE_FONT_STRETCH_NORMAL,
	DWRITE_FONT_STYLE_NORMAL, &font);

	mswr::ComPtr<IDWriteFontFace> font_face;
	hr = font->CreateFontFace(&font_face);
	ASSERT_TRUE(SUCCEEDED(hr));
	ASSERT_EQ(3u, fake_collection_->MessageCount());

	mswr::ComPtr<IDWriteFont> found_font;
	collection_->GetFontFromFontFace(font_face.Get(), &found_font);
	EXPECT_NE(nullptr, found_font.Get());
	EXPECT_EQ(3u, fake_collection_->MessageCount());
	}

	TEST_F(DWriteFontProxyUnitTest, TestCustomFontFiles) {
	FakeFontCollection fonts;
	FakeFont& arial = fonts.AddFont(L"Arial").AddFamilyName(L"en-us", L"Arial");
	for (auto& path : arial_font_files) {
	base::File file(base::FilePath(path), base::File::FLAG_OPEN \|
	base::File::FLAG_READ \|
	base::File::FLAG_EXCLUSIVE_WRITE);
	arial.AddFileHandle(std::move(file));
	}
	mswr::ComPtr<DWriteFontCollectionProxy> collection;
	DWriteFontCollectionProxy::Create(&collection, factory.Get(),
	fonts.CreatePtr());

	// Check that we can get the font family and match a font.
	UINT32 index = UINT_MAX;
	BOOL exists = FALSE;
	collection->FindFamilyName(L"Arial", &index, &exists);
	mswr::ComPtr<IDWriteFontFamily> family;
	collection->GetFontFamily(index, &family);

	mswr::ComPtr<IDWriteFont> font;
	HRESULT hr = family->GetFirstMatchingFont(DWRITE_FONT_WEIGHT_NORMAL,
	DWRITE_FONT_STRETCH_NORMAL,
	DWRITE_FONT_STYLE_NORMAL, &font);

	EXPECT_TRUE(SUCCEEDED(hr));
	EXPECT_NE(nullptr, font.Get());

	mswr::ComPtr<IDWriteFontFace> font_face;
	hr = font->CreateFontFace(&font_face);
	EXPECT_TRUE(SUCCEEDED(hr));
	}

	} // namespace

	} // namespace content