PlatformFontMac: Use a default NSFont when an invalid font is passed.

ui/gfx/platform_font_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/platform_font_mac.h"
 
 #include <cmath>
 
 #include <Cocoa/Cocoa.h>
 
@@ skipping 69 matching lines @@
 int GetFontStyleFromNSFont(NSFont* font) {
   int font_style = Font::NORMAL;
   NSFontSymbolicTraits traits = [[font fontDescriptor] symbolicTraits];
   if (traits & NSFontItalicTrait)
     font_style |= Font::ITALIC;
   return font_style;
 }
 
 // Returns the Font weight for |font|.
 Font::Weight GetFontWeightFromNSFont(NSFont* font) {
-  if (!font)
-    return Font::Weight::INVALID;
+  DCHECK(font);
 
   // Map CoreText weights in a manner similar to ct_weight_to_fontstyle() from
   // SkFontHost_mac.cpp, but adjust for MEDIUM so that the San Francisco's
   // custom MEDIUM weight can be picked out. San Francisco has weights:
   // [0.23, 0.23, 0.3, 0.4, 0.56, 0.62, 0.62, ...] (no thin weights).
   // See PlatformFontMacTest.FontWeightAPIConsistency for details.
   // Note that the table Skia uses is also determined by experiment.
   constexpr struct {
     CGFloat ct_weight;
     Font::Weight gfx_weight;
@@ skipping 65 matching lines @@
   // Make one fallback attempt by looking up via font name rather than font
   // family name.
   attrs = @{
     NSFontNameAttribute : base::SysUTF8ToNSString(font_name),
     NSFontTraitsAttribute : traits
   };
   descriptor = [NSFontDescriptor fontDescriptorWithFontAttributes:attrs];
   return [NSFont fontWithDescriptor:descriptor size:font_size];
 }
 
+// Returns |font| or a default font if |font| is nil.
+NSFont* ValidateFont(NSFont* font) {
+  return font ? font : [NSFont systemFontOfSize:[NSFont systemFontSize]];
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontMac, public:
 
 PlatformFontMac::PlatformFontMac()
     : PlatformFontMac([NSFont systemFontOfSize:[NSFont systemFontSize]]) {
 }
 
 PlatformFontMac::PlatformFontMac(NativeFont native_font)
     : PlatformFontMac(native_font,
                       base::SysNSStringToUTF8([native_font familyName]),
                       [native_font pointSize],
                       GetFontStyleFromNSFont(native_font),
-                      GetFontWeightFromNSFont(native_font)) {}
+                      GetFontWeightFromNSFont(native_font)) {
+  DCHECK(native_font);  // Null should not be passed to this constructor.
+}
 
 PlatformFontMac::PlatformFontMac(const std::string& font_name, int font_size)
     : PlatformFontMac(font_name,
                       font_size,
                       Font::NORMAL,
                       Font::Weight::NORMAL) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontMac, PlatformFont implementation:
 
@@ skipping 47 matching lines @@
 
 int PlatformFontMac::GetBaseline() {
   return ascent_;
 }
 
 int PlatformFontMac::GetCapHeight() {
   return cap_height_;
 }
 
 int PlatformFontMac::GetExpectedTextWidth(int length) {
-  if (!average_width_ && native_font_) {
+  if (!average_width_) {
     // -[NSFont boundingRectForGlyph:] seems to always return the largest
     // bounding rect that could be needed, which produces very wide expected
     // widths for strings. Instead, compute the actual width of a string
     // containing all the lowercase characters to find a reasonable guess at the
     // average.
     base::scoped_nsobject<NSAttributedString> attr_string(
         [[NSAttributedString alloc]
             initWithString:@"abcdefghijklmnopqrstuvwxyz"
                 attributes:@{NSFontAttributeName : native_font_.get()}]);
     average_width_ = [attr_string size].width / [attr_string length];
@@ skipping 42 matching lines @@
           font_name,
           font_size,
           font_style,
           font_weight) {}
 
 PlatformFontMac::PlatformFontMac(NativeFont font,
                                  const std::string& font_name,
                                  int font_size,
                                  int font_style,
                                  Font::Weight font_weight)
-    : native_font_([font retain]),
+    : native_font_([ValidateFont(font) retain]),
       font_name_(font_name),
       font_size_(font_size),
       font_style_(font_style),
       font_weight_(font_weight) {
   CalculateMetricsAndInitRenderParams();
 }
 
 PlatformFontMac::~PlatformFontMac() {
 }
 
 void PlatformFontMac::CalculateMetricsAndInitRenderParams() {
   NSFont* font = native_font_.get();
-  if (!font) {
-    // This object was constructed from a font name that doesn't correspond to
-    // an actual font. Don't waste time working out metrics.
-    height_ = 0;
-    ascent_ = 0;
-    cap_height_ = 0;
-    return;
-  }
-
+  DCHECK(font);
   ascent_ = ceil([font ascender]);
   cap_height_ = ceil([font capHeight]);
 
   // PlatformFontMac once used -[NSLayoutManager defaultLineHeightForFont:] to
   // initialize |height_|. However, it has a silly rounding bug. Essentially, it
   // gives round(ascent) + round(descent). E.g. Helvetica Neue at size 16 gives
   // ascent=15.4634, descent=3.38208 -> 15 + 3 = 18. When the height should be
   // at least 19. According to the OpenType specification, these values should
   // simply be added, so do that. Note this uses the already-rounded |ascent_|
   // to ensure GetBaseline() + descender fits within GetHeight() during layout.
@@ skipping 10 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFont, public:
 
 // static
 PlatformFont* PlatformFont::CreateDefault() {
   return new PlatformFontMac;
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
-  return new PlatformFontMac(native_font);
+  return new PlatformFontMac(ValidateFont(native_font));
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontMac(font_name, font_size);
 }
 
 }  // namespace gfx