Use fallback font in PlatformFontPango::DeriveFont().

ui/gfx/platform_font_pango.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/platform_font_pango.h"
 
 #include <fontconfig/fontconfig.h>
 #include <pango/pango.h>
 
 #include <algorithm>
@@ skipping 13 matching lines @@
 #include "ui/gfx/pango_util.h"
 #include "ui/gfx/text_utils.h"
 
 namespace {
 
 // The font family name which is used when a user's application font for
 // GNOME/KDE is a non-scalable one. The name should be listed in the
 // IsFallbackFontAllowed function in skia/ext/SkFontHost_fontconfig_direct.cpp.
 const char* kFallbackFontFamilyName = "sans";
 
+// Creates a SkTypeface for the passed-in Font::FontStyle and family. If a
+// fallback typeface is used instead of the requested family, |family| will be
+// updated to contain the fallback's family name.
+skia::RefPtr<SkTypeface> CreateSkTypeface(int style, std::string* family) {
+  DCHECK(family);
+
+  int skia_style = SkTypeface::kNormal;
+  if (gfx::Font::BOLD & style)
+    skia_style |= SkTypeface::kBold;
+  if (gfx::Font::ITALIC & style)
+    skia_style |= SkTypeface::kItalic;
+
+  skia::RefPtr<SkTypeface> typeface = skia::AdoptRef(SkTypeface::CreateFromName(
+      family->c_str(), static_cast<SkTypeface::Style>(skia_style)));
+  if (!typeface) {
+    // A non-scalable font such as .pcf is specified. Fall back to a default
+    // scalable font.
+    typeface = skia::AdoptRef(SkTypeface::CreateFromName(
+        kFallbackFontFamilyName, static_cast<SkTypeface::Style>(skia_style)));
+    CHECK(typeface) << "Could not find any font: " << family << ", "
+                    << kFallbackFontFamilyName;
+    *family = kFallbackFontFamilyName;
+  }
+  return typeface;
+}
+
 }  // namespace
 
 namespace gfx {
 
 // static
 Font* PlatformFontPango::default_font_ = NULL;
 
 #if defined(OS_CHROMEOS)
 // static
 std::string* PlatformFontPango::default_font_description_ = NULL;
@@ skipping 88 matching lines @@
   default_font_description_ = new std::string(font_description);
 }
 
 #endif
 
 Font PlatformFontPango::DeriveFont(int size_delta, int style) const {
   const int new_size = font_size_pixels_ + size_delta;
   DCHECK_GT(new_size, 0);
 
   // If the style changed, we may need to load a new face.
-  skia::RefPtr<SkTypeface> typeface = typeface_;
-  if (style != style_) {
-    int skstyle = SkTypeface::kNormal;
-    if (gfx::Font::BOLD & style)
-      skstyle |= SkTypeface::kBold;
-    if (gfx::Font::ITALIC & style)
-      skstyle |= SkTypeface::kItalic;
-    typeface = skia::AdoptRef(SkTypeface::CreateFromName(
-        font_family_.c_str(), static_cast<SkTypeface::Style>(skstyle)));
-  }
+  std::string new_family = font_family_;
+  skia::RefPtr<SkTypeface> typeface =
+      (style == style_) ? typeface_ : CreateSkTypeface(style, &new_family);
 
-  // If the size changed, get updated rendering settings.
+  // If the size or family changed, get updated rendering settings.
   FontRenderParams render_params = font_render_params_;
-  if (size_delta != 0) {
-    const std::vector<std::string> family_list(1, font_family_);
+  if (size_delta != 0 || new_family != font_family_) {
+    const std::vector<std::string> family_list(1, new_family);
     render_params = GetCustomFontRenderParams(
         false, &family_list, &new_size, NULL, NULL);
   }
 
   return Font(new PlatformFontPango(typeface,
-                                    font_family_,
+                                    new_family,
                                     new_size,
                                     style,
                                     render_params));
 }
 
 int PlatformFontPango::GetHeight() const {
   return height_pixels_;
 }
 
 int PlatformFontPango::GetBaseline() const {
@@ skipping 74 matching lines @@
 PlatformFontPango::~PlatformFontPango() {}
 
 void PlatformFontPango::InitFromDetails(
     const skia::RefPtr<SkTypeface>& typeface,
     const std::string& font_family,
     int font_size_pixels,
     int style,
     const FontRenderParams& render_params) {
   DCHECK_GT(font_size_pixels, 0);
 
-  typeface_ = typeface;
   font_family_ = font_family;
-  if (!typeface_) {
-    typeface_ = skia::AdoptRef(
-        SkTypeface::CreateFromName(font_family.c_str(), SkTypeface::kNormal));
-    if (!typeface_) {
-      // A non-scalable font such as .pcf is specified. Fall back to a default
-      // scalable font.
-      typeface_ = skia::AdoptRef(SkTypeface::CreateFromName(
-          kFallbackFontFamilyName, SkTypeface::kNormal));
-      CHECK(typeface_) << "Could not find any font: " << font_family << ", "
-                       << kFallbackFontFamilyName;
-      font_family_ = kFallbackFontFamilyName;
-    }
-  }
+  typeface_ = typeface ? typeface : CreateSkTypeface(style, &font_family_);
 
   font_size_pixels_ = font_size_pixels;
   style_ = style;
   font_render_params_ = render_params;
 
   SkPaint paint;
   SkPaint::FontMetrics metrics;
   PaintSetup(&paint);
   paint.getFontMetrics(&metrics);
   ascent_pixels_ = SkScalarCeilToInt(-metrics.fAscent);
@@ skipping 84 matching lines @@
   return new PlatformFontPango(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontPango(font_name, font_size);
 }
 
 }  // namespace gfx