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

ui/gfx/render_text_mac.mm

 // 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_mac.h"
 
 #import <AppKit/AppKit.h>
 #include <ApplicationServices/ApplicationServices.h>
 #include <CoreText/CoreText.h>
 
@@ skipping 100 matching lines @@
 
 std::vector<RenderText::FontSpan> RenderTextMac::GetFontSpansForTesting() {
   EnsureLayout();
   if (!runs_valid_)
     ComputeRuns();
 
   std::vector<RenderText::FontSpan> spans;
   for (size_t i = 0; i < runs_.size(); ++i) {
     const CFRange cf_range = CTRunGetStringRange(runs_[i].ct_run);
     const Range range(cf_range.location, cf_range.location + cf_range.length);
-    spans.push_back(RenderText::FontSpan(runs_[i].font, range));
+    spans.push_back(RenderText::FontSpan(
+        gfx::Font(base::mac::CFToNSCast(runs_[i].ct_font.get())), range));
   }
 
   return spans;
 }
 
 int RenderTextMac::GetDisplayTextBaseline() {
   EnsureLayout();
   return common_baseline_;
 }
 
@@ skipping 71 matching lines @@
   DCHECK(line_);
   if (!runs_valid_)
     ComputeRuns();
 
   ApplyFadeEffects(renderer);
   ApplyTextShadows(renderer);
 
   for (size_t i = 0; i < runs_.size(); ++i) {
     const TextRun& run = runs_[i];
     renderer->SetForegroundColor(run.foreground);
-
-    CTFontRef ct_font = static_cast<CTFontRef>(run.font.GetNativeFont());
-    renderer->SetTextSize(CTFontGetSize(ct_font));
+    renderer->SetTextSize(CTFontGetSize(run.ct_font));
 
     // The painter adds its own ref. So don't |release()| it from the ref ptr in
     // TextRun.
     renderer->SetTypeface(run.typeface.get());
 
     renderer->DrawPosText(&run.glyph_positions[0], &run.glyphs[0],
                           run.glyphs.size());
     renderer->DrawDecorations(run.origin.x(), run.origin.y(), run.width,
                               run.underline, run.strike, run.diagonal_strike);
   }
 
   renderer->EndDiagonalStrike();
 }
 
 RenderTextMac::TextRun::TextRun()
     : ct_run(NULL),
       origin(SkPoint::Make(0, 0)),
       width(0),
       foreground(SK_ColorBLACK),
       underline(false),
       strike(false),
       diagonal_strike(false) {}
 
-RenderTextMac::TextRun::TextRun(const TextRun& other) = default;
+RenderTextMac::TextRun::TextRun(TextRun&& other) = default;
 
 RenderTextMac::TextRun::~TextRun() {}
 
 float RenderTextMac::GetLayoutTextWidth() {
   base::ScopedCFTypeRef<CFMutableArrayRef> attributes_owner;
   base::ScopedCFTypeRef<CTLineRef> line(
       EnsureLayoutInternal(layout_text(), &attributes_owner));
   SkScalar baseline;
   return GetCTLineSize(line.get(), &baseline).width();
 }
@@ skipping 122 matching lines @@
     CTRunRef ct_run =
         base::mac::CFCast<CTRunRef>(CFArrayGetValueAtIndex(ct_runs, i));
     const size_t glyph_count = CTRunGetGlyphCount(ct_run);
     const double run_width =
         CTRunGetTypographicBounds(ct_run, empty_cf_range, NULL, NULL, NULL);
     if (glyph_count == 0) {
       run_origin.offset(run_width, 0);
       continue;
     }
 
-    runs_.push_back(TextRun());
+    runs_.emplace_back();
     TextRun* run = &runs_.back();
     run->ct_run = ct_run;
     run->origin = run_origin;
     run->width = run_width;
     run->glyphs.resize(glyph_count);
     CTRunGetGlyphs(ct_run, empty_cf_range, &run->glyphs[0]);
     // CTRunGetGlyphs() sometimes returns glyphs with value 65535 and zero
     // width (this has been observed at the beginning of a string containing
     // Arabic content). Passing these to Skia will trigger an assertion;
     // instead set their values to 0.
@@ skipping 14 matching lines @@
       SkPoint* point = &run->glyph_positions[glyph];
       point->set(x + SkDoubleToScalar(positions_ptr[glyph].x),
                  y + SkDoubleToScalar(positions_ptr[glyph].y));
     }
 
     // TODO(asvitkine): Style boundaries are not necessarily per-run. Handle
     //                  this better. Also, support strike and diagonal_strike.
     CFDictionaryRef attributes = CTRunGetAttributes(ct_run);
     CTFontRef ct_font = base::mac::GetValueFromDictionary<CTFontRef>(
         attributes, kCTFontAttributeName);
-    run->font = Font(static_cast<NSFont*>(ct_font));
+    run->ct_font.reset(ct_font, base::scoped_policy::RETAIN);
     run->typeface.reset(SkCreateTypefaceFromCTFont(ct_font));
 
     const CGColorRef foreground = base::mac::GetValueFromDictionary<CGColorRef>(
         attributes, kCTForegroundColorAttributeName);
     if (foreground)
       run->foreground = skia::CGColorRefToSkColor(foreground);
 
     const CFNumberRef underline =
         base::mac::GetValueFromDictionary<CFNumberRef>(
             attributes, kCTUnderlineStyleAttributeName);
     CTUnderlineStyle value = kCTUnderlineStyleNone;
     if (underline && CFNumberGetValue(underline, kCFNumberSInt32Type, &value))
       run->underline = (value == kCTUnderlineStyleSingle);
 
     run_origin.offset(run_width, 0);
   }
   runs_valid_ = true;
 }
 
 void RenderTextMac::InvalidateStyle() {
   line_.reset();
   attributes_.reset();
   runs_.clear();
   runs_valid_ = false;
 }
 
 }  // namespace gfx