RenderTextHarfBuzz: Implement font fallback for Win and Linux

ui/gfx/render_text_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/render_text_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
@@ skipping 19 matching lines @@
 const size_t kMaxUniscribeTextLength = 10000;
 
 // The initial guess and maximum supported number of runs; arbitrary values.
 // TODO(msw): Support more runs, determine a better initial guess, etc.
 const int kGuessRuns = 100;
 const size_t kMaxRuns = 10000;
 
 // The maximum number of glyphs per run; ScriptShape fails on larger values.
 const size_t kMaxGlyphs = 65535;
 
-// 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;
-}
-
-// Finds a fallback font to use to render the specified |text| with respect to
-// an initial |font|. Returns the resulting font via out param |result|. Returns
-// |true| if a fallback font was found.
-// Adapted from WebKit's |FontCache::GetFontDataForCharacters()|.
-// TODO(asvitkine): This should be moved to font_fallback_win.cc.
-bool ChooseFallbackFont(HDC hdc,
-                        const Font& font,
-                        const wchar_t* text,
-                        int text_length,
-                        Font* result) {
-  // 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;
-}
-
 // Changes |font| to have the specified |font_size| (or |font_height| on Windows
 // XP) and |font_style| if it is not the case already. Only considers bold and
 // italic styles, since the underlined style has no effect on glyph shaping.
 void DeriveFontIfNecessary(int font_size,
                            int font_height,
                            int font_style,
                            Font* font) {
   const int kStyleMask = (Font::BOLD | Font::ITALIC);
   const int target_style = (font_style & kStyleMask);
 
@@ skipping 939 matching lines @@
     run->width = abc.abcA + abc.abcB + abc.abcC;
     preceding_run_widths += run->width;
   }
   string_width_ = preceding_run_widths;
 }
 
 void RenderTextWin::LayoutTextRun(internal::TextRun* run) {
   const size_t run_length = run->range.length();
   const wchar_t* run_text = &(GetLayoutText()[run->range.start()]);
   Font original_font = run->font;
-  LinkedFontsIterator fonts(original_font);
+  std::vector<std::string> fonts =
+      GetFallbackFontFamilies(original_font.GetFontName());
 
   run->logical_clusters.reset(new WORD[run_length]);
 
   // Try to shape with the first font in the fallback list, which is
   // |original_font|.
-  Font current_font;
-  fonts.NextFont(&current_font);
+  Font current_font = Font(fonts[0], original_font.GetFontSize());

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

Nit: You can just do:

Font current_font(...);

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

Done.

   int missing_count = CountCharsWithMissingGlyphs(run,
       ShapeTextRunWithFont(run, current_font));
   if (missing_count == 0)
     return;
 
   // Keep track of the font that is able to display the greatest number of
   // characters for which ScriptShape() returned S_OK. This font will be used
   // in the case where no font is able to display the entire run.
   int best_partial_font_missing_char_count = missing_count;
   Font best_partial_font = current_font;
 
   // Try to shape with the cached font from previous runs, if any.
   std::map<std::string, Font>::const_iterator it =
       successful_substitute_fonts_.find(original_font.GetFontName());
   if (it != successful_substitute_fonts_.end()) {
     current_font = it->second;
     missing_count = CountCharsWithMissingGlyphs(run,
         ShapeTextRunWithFont(run, current_font));
     if (missing_count == 0)
       return;
     if (missing_count < best_partial_font_missing_char_count) {
       best_partial_font_missing_char_count = missing_count;
       best_partial_font = current_font;
     }
   }
 
   // Try finding a fallback font using a meta file.
   // TODO(msw|asvitkine): Support RenderText's font_list()?
-  if (ChooseFallbackFont(cached_hdc_, run->font, run_text, run_length,
-                         &current_font)) {
+  if (GetUniscribeFallbackFont(run->font, run_text, run_length,
+                               &current_font)) {
     missing_count = CountCharsWithMissingGlyphs(run,
         ShapeTextRunWithFont(run, current_font));
     if (missing_count == 0) {
       successful_substitute_fonts_[original_font.GetFontName()] = current_font;
       return;
     }
     if (missing_count < best_partial_font_missing_char_count) {
       best_partial_font_missing_char_count = missing_count;
       best_partial_font = current_font;
     }
   }
 
   // Try the rest of fonts in the fallback list.
-  while (fonts.NextFont(&current_font)) {
+  for (size_t i = 1; i < fonts.size(); ++i) {
     missing_count = CountCharsWithMissingGlyphs(run,
-        ShapeTextRunWithFont(run, current_font));
+        ShapeTextRunWithFont(run, Font(fonts[i], original_font.GetFontSize())));
     if (missing_count == 0) {
       successful_substitute_fonts_[original_font.GetFontName()] = current_font;
       return;
     }
     if (missing_count < best_partial_font_missing_char_count) {
       best_partial_font_missing_char_count = missing_count;
       best_partial_font = current_font;
     }
   }
 
@@ skipping 159 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateNativeInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx