ui/gfx: Allow for font-specific rendering settings.

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";
 
-// Returns the available font family that best (in FontConfig's eyes) matches
-// the supplied list of family names.
-std::string FindBestMatchFontFamilyName(
-    const std::vector<std::string>& family_names) {
-  FcPattern* pattern = FcPatternCreate();
-  for (std::vector<std::string>::const_iterator it = family_names.begin();
-       it != family_names.end(); ++it) {
-    FcValue fcvalue;
-    fcvalue.type = FcTypeString;
-    fcvalue.u.s = reinterpret_cast<const FcChar8*>(it->c_str());
-    FcPatternAdd(pattern, FC_FAMILY, fcvalue, FcTrue /* append */);
-  }
-
-  FcConfigSubstitute(0, pattern, FcMatchPattern);
-  FcDefaultSubstitute(pattern);
-  FcResult result;
-  FcPattern* match = FcFontMatch(0, pattern, &result);
-  DCHECK(match) << "Could not find font";
-  FcChar8* match_family = NULL;
-  FcPatternGetString(match, FC_FAMILY, 0, &match_family);
-  std::string font_family(reinterpret_cast<char*>(match_family));
-  FcPatternDestroy(pattern);
-  FcPatternDestroy(match);
-  return font_family;
-}
-
 }  // namespace
 
 namespace gfx {
 
 // static
 Font* PlatformFontPango::default_font_ = NULL;
 
 #if defined(OS_CHROMEOS)
 // static
 std::string* PlatformFontPango::default_font_description_ = NULL;
@@ skipping 17 matching lines @@
     ScopedPangoFontDescription desc(
         pango_font_description_from_string(desc_string.c_str()));
     default_font_ = new Font(desc.get());
   }
 
   InitFromPlatformFont(
       static_cast<PlatformFontPango*>(default_font_->platform_font()));
 }
 
 PlatformFontPango::PlatformFontPango(NativeFont native_font) {
+  const int pango_size =
+      pango_font_description_get_size(native_font) / PANGO_SCALE;
+  const bool pango_using_pixels =
+      pango_font_description_get_size_is_absolute(native_font);
+
+  std::string font_family;
   std::vector<std::string> family_names;
   base::SplitString(pango_font_description_get_family(native_font), ',',
                     &family_names);
-  std::string font_family = FindBestMatchFontFamilyName(family_names);
+  const FontRenderParams params = GetCustomFontRenderParams(
+      false, &family_names,
+      pango_using_pixels ? &pango_size : NULL /* pixel_size */,
+      !pango_using_pixels ? &pango_size : NULL /* point_size */,
+      &font_family);
 
   int style = 0;
   // TODO(davemoore) What should we do about other weights? We currently only
   // support BOLD.
   if (pango_font_description_get_weight(native_font) == PANGO_WEIGHT_BOLD)
     style |= gfx::Font::BOLD;
   // TODO(davemoore) What about PANGO_STYLE_OBLIQUE?
   if (pango_font_description_get_style(native_font) == PANGO_STYLE_ITALIC)
     style |= gfx::Font::ITALIC;
 
   InitFromDetails(skia::RefPtr<SkTypeface>(), font_family,
-                  gfx::GetPangoFontSizeInPixels(native_font), style);
+                  gfx::GetPangoFontSizeInPixels(native_font), style, params);
 }
 
 PlatformFontPango::PlatformFontPango(const std::string& font_name,
-                                     int font_size) {
-  InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size,
-                  SkTypeface::kNormal);
+                                     int font_size_pixels) {
+  const std::vector<std::string> font_list(1, font_name);
+  const FontRenderParams params = GetCustomFontRenderParams(
+      false, &font_list, &font_size_pixels, NULL, NULL);
+  InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size_pixels,
+                  SkTypeface::kNormal, params);
 }
 
 double PlatformFontPango::underline_position() const {
   const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
   return underline_position_pixels_;
 }
 
 double PlatformFontPango::underline_thickness() const {
   const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
   return underline_thickness_pixels_;
@@ skipping 12 matching lines @@
 // static
 void PlatformFontPango::SetDefaultFontDescription(
     const std::string& font_description) {
   delete default_font_description_;
   default_font_description_ = new std::string(font_description);
 }
 
 #endif
 
 Font PlatformFontPango::DeriveFont(int size_delta, int style) const {
-  // If the delta is negative, if must not push the size below 1
-  if (size_delta < 0)
-    DCHECK_LT(-size_delta, font_size_pixels_);
+  const int new_size = font_size_pixels_ + size_delta;
+  DCHECK_GT(new_size, 0);
 
-  if (style == style_) {
-    // Fast path, we just use the same typeface at a different size
-    return Font(new PlatformFontPango(typeface_,
-                                      font_family_,
-                                      font_size_pixels_ + size_delta,
-                                      style_));
+  // 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)));
   }
 
-  // If the style has changed we may need to load a new face
-  int skstyle = SkTypeface::kNormal;
-  if (gfx::Font::BOLD & style)
-    skstyle |= SkTypeface::kBold;
-  if (gfx::Font::ITALIC & style)
-    skstyle |= SkTypeface::kItalic;
-
-  skia::RefPtr<SkTypeface> typeface = skia::AdoptRef(
-      SkTypeface::CreateFromName(
-          font_family_.c_str(),
-          static_cast<SkTypeface::Style>(skstyle)));
+  // If the size 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_);
+    render_params = GetCustomFontRenderParams(
+        false, &family_list, &new_size, NULL, NULL);
+  }
 
   return Font(new PlatformFontPango(typeface,
                                     font_family_,
-                                    font_size_pixels_ + size_delta,
-                                    style));
+                                    new_size,
+                                    style,
+                                    render_params));
 }
 
 int PlatformFontPango::GetHeight() const {
   return height_pixels_;
 }
 
 int PlatformFontPango::GetBaseline() const {
   return ascent_pixels_;
 }
 
@@ skipping 17 matching lines @@
 std::string PlatformFontPango::GetActualFontNameForTesting() const {
   SkString family_name;
   typeface_->getFamilyName(&family_name);
   return family_name.c_str();
 }
 
 int PlatformFontPango::GetFontSize() const {
   return font_size_pixels_;
 }
 
+const FontRenderParams& PlatformFontPango::GetFontRenderParams() const {
+  return font_render_params_;
+}
+
 NativeFont PlatformFontPango::GetNativeFont() const {
   PangoFontDescription* pfd = pango_font_description_new();
   pango_font_description_set_family(pfd, GetFontName().c_str());
   // Set the absolute size to avoid overflowing UI elements.
   // pango_font_description_set_absolute_size() takes a size in Pango units.
   // There are PANGO_SCALE Pango units in one device unit.  Screen output
   // devices use pixels as their device units.
   pango_font_description_set_absolute_size(
       pfd, font_size_pixels_ * PANGO_SCALE);
 
@@ skipping 14 matching lines @@
   }
 
   return pfd;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontPango, private:
 
 PlatformFontPango::PlatformFontPango(const skia::RefPtr<SkTypeface>& typeface,
                                      const std::string& name,
-                                     int size,
-                                     int style) {
-  InitFromDetails(typeface, name, size, style);
+                                     int size_pixels,
+                                     int style,
+                                     const FontRenderParams& render_params) {
+  InitFromDetails(typeface, name, size_pixels, style, render_params);
 }
 
 PlatformFontPango::~PlatformFontPango() {}
 
 void PlatformFontPango::InitFromDetails(
     const skia::RefPtr<SkTypeface>& typeface,
     const std::string& font_family,
-    int font_size,
-    int style) {
-  DCHECK_GT(font_size, 0);
+    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;
     }
   }
 
-  font_size_pixels_ = font_size;
+  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);
   height_pixels_ = ascent_pixels_ + SkScalarCeilToInt(metrics.fDescent);
   cap_height_pixels_ = SkScalarCeilToInt(metrics.fCapHeight);
 
   pango_metrics_inited_ = false;
   average_width_pixels_ = 0.0f;
   underline_position_pixels_ = 0.0f;
   underline_thickness_pixels_ = 0.0f;
 }
 
 void PlatformFontPango::InitFromPlatformFont(const PlatformFontPango* other) {
   typeface_ = other->typeface_;
   font_family_ = other->font_family_;
   font_size_pixels_ = other->font_size_pixels_;
   style_ = other->style_;
+  font_render_params_ = other->font_render_params_;
   ascent_pixels_ = other->ascent_pixels_;
   height_pixels_ = other->height_pixels_;
   cap_height_pixels_ = other->cap_height_pixels_;
   pango_metrics_inited_ = other->pango_metrics_inited_;
   average_width_pixels_ = other->average_width_pixels_;
   underline_position_pixels_ = other->underline_position_pixels_;
   underline_thickness_pixels_ = other->underline_thickness_pixels_;
 }
 
 void PlatformFontPango::PaintSetup(SkPaint* paint) const {
@@ skipping 59 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