RenderText: Don't default-construct gfx::Fonts unnecessarily

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/i18n/bidi_line_iterator.h"
@@ skipping 559 matching lines @@
 #if !defined(OS_MACOSX)
 sk_sp<SkTypeface> CreateSkiaTypeface(const gfx::Font& font, int style) {
   int skia_style = SkTypeface::kNormal;
   skia_style |= (style & Font::BOLD) ? SkTypeface::kBold : 0;
   skia_style |= (style & Font::ITALIC) ? SkTypeface::kItalic : 0;
   return sk_sp<SkTypeface>(SkTypeface::CreateFromName(
       font.GetFontName().c_str(), static_cast<SkTypeface::Style>(skia_style)));
 }
 #endif
 
-TextRunHarfBuzz::TextRunHarfBuzz()
+TextRunHarfBuzz::TextRunHarfBuzz(const gfx::Font& template_font)
     : width(0.0f),
       preceding_run_widths(0.0f),
       is_rtl(false),
       level(0),
       script(USCRIPT_INVALID_CODE),
       glyph_count(static_cast<size_t>(-1)),
+      font(template_font),
       font_size(0),
       baseline_offset(0),
       baseline_type(0),
       font_style(0),
       strike(false),
       diagonal_strike(false),
-      underline(false) {
-}
+      underline(false) {}
 
 TextRunHarfBuzz::~TextRunHarfBuzz() {}
 
 Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const {
   DCHECK(range.Contains(char_range));
   DCHECK(!char_range.is_reversed());
   DCHECK(!char_range.is_empty());
 
   Range start_glyphs;
   Range end_glyphs;
@@ skipping 643 matching lines @@
 void RenderTextHarfBuzz::ItemizeTextToRuns(
     const base::string16& text,
     internal::TextRunList* run_list_out) {
   DCHECK_NE(0U, text.length());
 
   // If ICU fails to itemize the text, we create a run that spans the entire
   // text. This is needed because leaving the runs set empty causes some clients
   // to misbehave since they expect non-zero text metrics from a non-empty text.
   base::i18n::BiDiLineIterator bidi_iterator;
   if (!bidi_iterator.Open(text, GetTextDirection(text))) {
-    internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz;
+    internal::TextRunHarfBuzz* run =
+        new internal::TextRunHarfBuzz(font_list().GetPrimaryFont());
     run->range = Range(0, text.length());
     run_list_out->add(run);
     run_list_out->InitIndexMap();
     return;
   }
 
   // Temporarily apply composition underlines and selection colors.
   ApplyCompositionAndSelectionStyles();
 
   // Build the run list from the script items and ranged styles and baselines.
   // Use an empty color BreakList to avoid breaking runs at color boundaries.
   BreakList<SkColor> empty_colors;
   empty_colors.SetMax(text.length());
   DCHECK_LE(text.size(), baselines().max());
   for (const BreakList<bool>& style : styles())
     DCHECK_LE(text.size(), style.max());
   internal::StyleIterator style(empty_colors, baselines(), styles());
 
   for (size_t run_break = 0; run_break < text.length();) {
-    internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz;
+    internal::TextRunHarfBuzz* run =
+        new internal::TextRunHarfBuzz(font_list().GetPrimaryFont());
     run->range.set_start(run_break);
     run->font_style = (style.style(BOLD) ? Font::BOLD : 0) |
                       (style.style(ITALIC) ? Font::ITALIC : 0);
     run->baseline_type = style.baseline();
     run->strike = style.style(STRIKE);
     run->diagonal_strike = style.style(DIAGONAL_STRIKE);
     run->underline = style.style(UNDERLINE);
     int32_t script_item_break = 0;
     bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level);
     CHECK_GT(static_cast<size_t>(script_item_break), run_break);
@@ skipping 82 matching lines @@
       case SUBSCRIPT:
         run->baseline_offset =
             primary_font.GetHeight() - primary_font.GetBaseline();
         break;
       case INFERIOR:  // Fall through.
       default:
         break;
     }
   }
 
-  Font best_font;
+  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)
-  Font uniscribe_font;
+  Font uniscribe_font(primary_font);
   std::string uniscribe_family;
   const base::char16* run_text = &(text[run->range.start()]);
   if (GetUniscribeFallbackFont(primary_font, run_text, run->range.length(),
                                &uniscribe_font)) {
     uniscribe_family = uniscribe_font.GetFontName();
     if (CompareFamily(text, uniscribe_font,
                       uniscribe_font.GetFontRenderParams(), run,
                       &best_font, &best_render_params, &best_missing_glyphs))
       return;
   }
@@ skipping 177 matching lines @@
   DCHECK(!update_layout_run_list_);
   DCHECK(!update_display_run_list_);
   return text_elided() ? display_run_list_.get() : &layout_run_list_;
 }
 
 const internal::TextRunList* RenderTextHarfBuzz::GetRunList() const {
   return const_cast<RenderTextHarfBuzz*>(this)->GetRunList();
 }
 
 }  // namespace gfx