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"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "third_party/icu/source/common/unicode/uchar.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/font_fallback_win.h"
+#include "ui/gfx/font_fallback.h"
 #include "ui/gfx/font_smoothing_win.h"
 #include "ui/gfx/platform_font_win.h"
 #include "ui/gfx/utf16_indexing.h"
 
 namespace gfx {
 
 namespace {
 
 // The maximum length of text supported for Uniscribe layout and display.
 // This empirically chosen value should prevent major performance degradations.
@@ skipping 1024 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> fallback_fonts =
+      GetFallbackFontFamilies(original_font.GetFontName());
   bool tried_cached_font = false;
   bool tried_fallback = false;
   // 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 = INT_MAX;
   Font best_partial_font = original_font;
-  Font current_font;
 
   run->logical_clusters.reset(new WORD[run_length]);
-  while (fonts.NextFont(&current_font)) {
-    HRESULT hr = ShapeTextRunWithFont(run, current_font);
+  Font current_font;
+  bool next_font_set = false;
+  for (size_t i = 0; i < fallback_fonts.size();) {
+    HRESULT hr = ShapeTextRunWithFont(run, next_font_set ?
+        current_font : Font(fallback_fonts[i++], original_font.GetFontSize()));
+    next_font_set = false;
 
     bool glyphs_missing = false;
     if (hr == USP_E_SCRIPT_NOT_IN_FONT) {
       glyphs_missing = true;
     } else if (hr == S_OK) {
       // If |hr| is S_OK, there could still be missing glyphs in the output.
       // http://msdn.microsoft.com/en-us/library/windows/desktop/dd368564.aspx
       const int missing_count = CountCharsWithMissingGlyphs(run);
       // Track the font that produced the least missing glyphs.
       if (missing_count < best_partial_font_missing_char_count) {
@@ skipping 13 matching lines @@
       return;
     }
 
     // First, try the cached font from previous runs, if any.
     if (!tried_cached_font) {
       tried_cached_font = true;
 
       std::map<std::string, Font>::const_iterator it =
           successful_substitute_fonts_.find(original_font.GetFontName());
       if (it != successful_substitute_fonts_.end()) {
-        fonts.SetNextFont(it->second);
+        current_font = it->second;
+        next_font_set = true;
         continue;
       }
     }
 
     // If there are missing glyphs, first try finding a fallback font using a
     // meta file, if it hasn't yet been attempted for this run.
     // TODO(msw|asvitkine): Support RenderText's font_list()?
     if (!tried_fallback) {
       tried_fallback = true;
 
       Font fallback_font;
       if (ChooseFallbackFont(cached_hdc_, run->font, run_text, run_length,
                              &fallback_font)) {
-        fonts.SetNextFont(fallback_font);
+        current_font = fallback_font;
+        next_font_set = true;
         continue;
       }
     }
   }
 
   // If a font was able to partially display the run, use that now.
   if (best_partial_font_missing_char_count < static_cast<int>(run_length)) {
     // Re-shape the run only if |best_partial_font| differs from the last font.
     if (best_partial_font.GetNativeFont() != run->font.GetNativeFont())
       ShapeTextRunWithFont(run, best_partial_font);
@@ skipping 146 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