win: Hack around Gill Sans Ultra Bold DirectWrite problem

content/common/dwrite_font_platform_win.cc

 // Copyright 2014 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/public/common/dwrite_font_platform_win.h"
 
 #include <dwrite.h>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 728 matching lines @@
 
 UINT32 FontCollectionLoader::GetFontMapSize() {
   return reg_fonts_.size();
 }
 
 base::string16 FontCollectionLoader::GetFontNameFromKey(UINT32 idx) {
   DCHECK(idx < reg_fonts_.size());
   return reg_fonts_[idx];
 }
 
+const wchar_t* kFontsToIgnore[] = {
+  // "Gill Sans Ultra Bold" turns into an Ultra Bold weight "Gill Sans" in
+  // DirectWrite, but most users don't have any other weights. The regular
+  // weight font is named "Gill Sans MT", but that ends up in a different
+  // family with that name. On Mac, there's a "Gill Sans" with various weights,
+  // so CSS authors use { 'font-family': 'Gill Sans', 'Gill Sans MT', ... } and
+  // because of the DirectWrite family futzing, they end up with an Ultra Bold
+  // font, when they just wanted "Gill Sans". Mozilla implemented a more
+  // complicated hack where they effectively rename the Ultra Bold font to
+  // "Gill Sans MT Ultra Bold", but because the Ultra Bold font is so ugly
+  // anyway, we simply ignore it. See
+  // http://www.microsoft.com/typography/fonts/font.aspx?FMID=978 for a picture
+  // of the font, and the file name. We also ignore "Gill Sans Ultra Bold
+  // Condensed".
+  L"gilsanub.ttf",
+  L"gillubcd.ttf",
+};
+
 bool FontCollectionLoader::LoadFontListFromRegistry() {
   const wchar_t kFontsRegistry[] =
       L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
   CHECK(reg_fonts_.empty());
   base::win::RegKey regkey;
   if (regkey.Open(HKEY_LOCAL_MACHINE, kFontsRegistry, KEY_READ) !=
       ERROR_SUCCESS) {
     return false;
   }
 
   base::FilePath system_font_path;
   PathService::Get(base::DIR_WINDOWS_FONTS, &system_font_path);
 
   base::string16 name;
   base::string16 value;
   for (DWORD idx = 0; idx < regkey.GetValueCount(); idx++) {
     if (regkey.GetValueNameAt(idx, &name) == ERROR_SUCCESS &&
         regkey.ReadValue(name.c_str(), &value) == ERROR_SUCCESS) {
       base::FilePath path(value.c_str());
       // We need to check if file name is the only component that exists,
       // we will ignore all other registry entries.
       std::vector<base::FilePath::StringType> components;
       path.GetComponents(&components);
       if ((components.size() == 1 &&
            value.size() < kMaxFontFileNameLength - 1) ||
           base::FilePath::CompareEqualIgnoreCase(system_font_path.value(),
                                                  path.DirName().value())) {
-        reg_fonts_.push_back(value.c_str());
+        bool should_ignore = false;
+        for (const auto& ignore : kFontsToIgnore) {
+          if (base::FilePath::CompareEqualIgnoreCase(path.value(), ignore)) {
+            should_ignore = true;
+            break;
+          }
+        }
+        if (!should_ignore)
+          reg_fonts_.push_back(value.c_str());
       }
     }
   }
   UMA_HISTOGRAM_COUNTS("DirectWrite.Fonts.Loaded", reg_fonts_.size());
   UMA_HISTOGRAM_COUNTS("DirectWrite.Fonts.Ignored",
                        regkey.GetValueCount() - reg_fonts_.size());
   return true;
 }
 
 // This list is mainly based on prefs/prefs_tab_helper.cc kFontDefaults.
@@ skipping 390 matching lines @@
   g_shared_font_cache.Set(mapping);
 
   return true;
 }
 
 bool BuildFontCache(const base::FilePath& file) {
   return BuildFontCacheInternal(file.value().c_str());
 }
 
 }  // namespace content