Use CTFontCreateForString for RenderTextHarfbuzz on Mac

ui/gfx/render_text_harfbuzz.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 "ui/gfx/render_text_harfbuzz.h"
 
 #include <limits>
 #include <set>
 
 #include "base/command_line.h"
@@ skipping 18 matching lines @@
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_fallback.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/harfbuzz_font_skia.h"
 #include "ui/gfx/range/range_f.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/gfx/utf16_indexing.h"
 
-#if defined(OS_WIN)
-#include "ui/gfx/font_fallback_win.h"
-#endif
-
 namespace gfx {
 
 namespace {
 
 // Text length limit. Longer strings are slow and not fully tested.
 const size_t kMaxTextLength = 10000;
 
 // The maximum number of scripts a Unicode character can belong to. This value
 // is arbitrarily chosen to be a good limit because it is unlikely for a single
 // character to belong to more scripts.
@@ skipping 1448 matching lines @@
   Font best_font(primary_font);
   FontRenderParams best_render_params;
   size_t best_missing_glyphs = std::numeric_limits<size_t>::max();
 
   for (const Font& font : font_list().GetFonts()) {
     if (CompareFamily(text, font, font.GetFontRenderParams(), run, &best_font,
                       &best_render_params, &best_missing_glyphs))
       return;
   }
 
-#if defined(OS_WIN)
+  std::string preferred_fallback_family;
+
+#if defined(OS_WIN) || defined(OS_MACOSX)
   Font fallback_font(primary_font);
-  std::string fallback_family;
   const base::char16* run_text = &(text[run->range.start()]);
   if (GetFallbackFont(primary_font, run_text, run->range.length(),
                       &fallback_font)) {
-    fallback_family = fallback_font.GetFontName();
+    preferred_fallback_family = fallback_font.GetFontName();
     if (CompareFamily(text, fallback_font, fallback_font.GetFontRenderParams(),
                       run, &best_font, &best_render_params,
                       &best_missing_glyphs))
       return;
   }
 #endif
 
   std::vector<Font> fallback_font_list = GetFallbackFonts(primary_font);
 
 #if defined(OS_WIN)
-  // Append fonts in the fallback list of the fallback font.
-  if (!fallback_family.empty()) {
+  // Append fonts in the fallback list of the preferred fallback font.
+  // TODO(tapted): Investigate whether there's a case that benefits from this on
+  // Mac.
+  if (!preferred_fallback_family.empty()) {
     std::vector<Font> fallback_fonts = GetFallbackFonts(fallback_font);
     fallback_font_list.insert(fallback_font_list.end(), fallback_fonts.begin(),
                               fallback_fonts.end());
   }
 
   // Add Segoe UI and its associated linked fonts to the fallback font list to
   // ensure that the fallback list covers the basic cases.
   // http://crbug.com/467459. On some Windows configurations the default font
   // could be a raster font like System, which would not give us a reasonable
   // fallback font list.
   if (!base::LowerCaseEqualsASCII(primary_font.GetFontName(), "segoe ui") &&
-      !base::LowerCaseEqualsASCII(fallback_family, "segoe ui")) {
+      !base::LowerCaseEqualsASCII(preferred_fallback_family, "segoe ui")) {
     std::vector<Font> default_fallback_families =
         GetFallbackFonts(Font("Segoe UI", 13));
     fallback_font_list.insert(fallback_font_list.end(),
         default_fallback_families.begin(), default_fallback_families.end());
   }
 #endif
 
   // Use a set to track the fallback fonts and avoid duplicate entries.
   std::set<Font, CaseInsensitiveCompare> fallback_fonts;
 
   // Try shaping with the fallback fonts.
   for (const auto& font : fallback_font_list) {
     std::string font_name = font.GetFontName();
 
-    if (font_name == primary_font.GetFontName())
+    if (font_name == primary_font.GetFontName() ||
+        font_name == preferred_fallback_family || fallback_fonts.count(font)) {
       continue;
-#if defined(OS_WIN)
-    if (font_name == fallback_family)
-      continue;
-#endif
-    if (fallback_fonts.find(font) != fallback_fonts.end())
-      continue;
+    }
 
     fallback_fonts.insert(font);
 
     FontRenderParamsQuery query;
     query.families.push_back(font_name);
     query.pixel_size = run->font_size;
     query.style = run->italic ? Font::ITALIC : 0;
     FontRenderParams fallback_render_params = GetFontRenderParams(query, NULL);
     if (CompareFamily(text, font, fallback_render_params, run, &best_font,
                       &best_render_params, &best_missing_glyphs))
@@ skipping 153 matching lines @@
 
       attribute.strike = run.strike;
       attribute.diagonal_strike = run.diagonal_strike;
       decorated_text->attributes.push_back(attribute);
     }
   }
   return true;
 }
 
 }  // namespace gfx