RenderTextHarfBuzz: Implement font fallback for Win and Linux

ui/gfx/font_fallback_win.cc

 // Copyright (c) 2012 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 "ui/gfx/font_fallback_win.h"
 
+#include <usp10.h>
+
 #include <map>
 
 #include "base/memory/singleton.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.h"
 
 namespace gfx {
 
 namespace {
 
 // Queries the registry to get a mapping from font filenames to font names.
 void QueryFontsFromRegistry(std::map<std::string, std::string>* map) {
   const wchar_t* kFonts =
       L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
 
@@ skipping 117 matching lines @@
   QueryLinkedFontsFromRegistry(font, &cached_system_fonts_, linked_fonts);
   return linked_fonts;
 }
 
 CachedFontLinkSettings::CachedFontLinkSettings() {
 }
 
 CachedFontLinkSettings::~CachedFontLinkSettings() {
 }
 
+// Callback to |EnumEnhMetaFile()| to intercept font creation.
+int CALLBACK MetaFileEnumProc(HDC hdc,
+                              HANDLETABLE* table,
+                              CONST ENHMETARECORD* record,
+                              int table_entries,
+                              LPARAM log_font) {
+  if (record->iType == EMR_EXTCREATEFONTINDIRECTW) {
+    const EMREXTCREATEFONTINDIRECTW* create_font_record =
+        reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
+    *reinterpret_cast<LOGFONT*>(log_font) = create_font_record->elfw.elfLogFont;
+  }
+  return 1;
+}
+
 }  // namespace
 
 namespace internal {
 
 void ParseFontLinkEntry(const std::string& entry,
                         std::string* filename,
                         std::string* font_name) {
   std::vector<std::string> parts;
   base::SplitString(entry, ',', &parts);
   filename->clear();
@@ skipping 17 matching lines @@
   if (!font_names->empty()) {
     const size_t index = font_names->back().find('(');
     if (index != std::string::npos) {
       font_names->back().resize(index);
       base::TrimWhitespace(font_names->back(), base::TRIM_TRAILING,
                            &font_names->back());
     }
   }
 }
 
-}  // namespace internal
-
 LinkedFontsIterator::LinkedFontsIterator(Font font)
     : original_font_(font),
       next_font_set_(false),
       linked_fonts_(NULL),
       linked_font_index_(0) {
   SetNextFont(original_font_);
 }
 
 LinkedFontsIterator::~LinkedFontsIterator() {
 }
@@ skipping 35 matching lines @@
   //
   // Note: One possibility would be to always merge both lists of fonts,
   //       but it is not clear whether there are any real world scenarios
   //       where this would actually help.
   if (fonts->empty())
     fonts = font_link->GetLinkedFonts(current_font_);
 
   return fonts;
 }
 
+}  // namespace internal
+
+std::vector<std::string> GetFallbackFontFamilies(
+    const std::string& font_family) {
+  internal::LinkedFontsIterator linked_fonts(Font(font_family, 10));

[Alexei Svitkine (slow), 2014/07/17 21:22:00]

Please add a comment about the hard-coded 10.

[ckocagil, 2014/07/17 23:12:00]

Done.

+  std::vector<std::string> fallback_fonts;
+  Font current;
+  while (linked_fonts.NextFont(&current))
+    fallback_fonts.push_back(current.GetFontName());
+  return fallback_fonts;
+}
+
+// Adapted from WebKit's |FontCache::GetFontDataForCharacters()|.
+// Uniscribe doesn't expose a method to query fallback fonts, so this works by
+// drawing the text to an EMF object with Uniscribe's ScriptStringOut and then
+// inspecting the EMF object to figure out which font Uniscribe used.
+//
+// DirectWrite in Windows 8.1 provides a cleaner alternative:
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dn280480.aspx

[Alexei Svitkine (slow), 2014/07/17 21:22:00]

This comment should either be in the header or within the body of the function
now that the function is exported.

[ckocagil, 2014/07/17 23:12:00]

Done, moved into the body.

+bool GetUniscribeFallbackFont(const Font& font,
+                              const wchar_t* text,
+                              int text_length,
+                              Font* result) {
+  static HDC hdc = NULL;
+  if (hdc == NULL) {
+    hdc = CreateCompatibleDC(NULL);

[msw, 2014/07/17 00:08:04]

nit: can you inline this with the static decl?

[ckocagil, 2014/07/17 00:10:49]

Wouldn't that cause a static initializer to be added?

[msw, 2014/07/17 00:15:35]

I thought this was okay for function-scoped statics.
Maybe just ignore my comment and land this as-is.
(I'm hoping we can enable harfbuzz by default asap)

[Daniel Erat, 2014/07/17 02:22:24]

function-scoped static initializers are fine, per my reading of
https://groups.google.com/a/chromium.org/forum/#!searchin/chromium-dev/%22eli...

[ckocagil, 2014/07/17 23:12:00]

Oh, now I read the thread and came to the same conclusion. Done!

+    DCHECK(hdc) << GetLastError();
+  }
+
+  // Use a meta file to intercept the fallback font chosen by Uniscribe.
+  HDC meta_file_dc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
+  if (!meta_file_dc)
+    return false;
+
+  SelectObject(meta_file_dc, font.GetNativeFont());
+
+  SCRIPT_STRING_ANALYSIS script_analysis;
+  HRESULT hresult =
+      ScriptStringAnalyse(meta_file_dc, text, text_length, 0, -1,
+                          SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
+                          0, NULL, NULL, NULL, NULL, NULL, &script_analysis);
+
+  if (SUCCEEDED(hresult)) {
+    hresult = ScriptStringOut(script_analysis, 0, 0, 0, NULL, 0, 0, FALSE);
+    ScriptStringFree(&script_analysis);
+  }
+
+  bool found_fallback = false;
+  HENHMETAFILE meta_file = CloseEnhMetaFile(meta_file_dc);
+  if (SUCCEEDED(hresult)) {
+    LOGFONT log_font;
+    log_font.lfFaceName[0] = 0;
+    EnumEnhMetaFile(0, meta_file, MetaFileEnumProc, &log_font, NULL);
+    if (log_font.lfFaceName[0]) {
+      *result = Font(base::UTF16ToUTF8(log_font.lfFaceName),
+                     font.GetFontSize());
+      found_fallback = true;
+    }
+  }
+  DeleteEnhMetaFile(meta_file);
+
+  return found_fallback;
+}
+
 }  // namespace gfx