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;

[msw, 2014/07/12 00:27:33]

Hmm, can you consolidate this with pango_util's GetPangoFontSizeInPixels?
(perhaps only send/accept pixel sizes in GetCustomFontRenderParams?)

[Daniel Erat, 2014/07/12 01:55:33]

i don't think so. i was hoping to go this route at first, but fontconfig seems
to only e.g. apply point-based matches to queries using points, even if given a
pixel-based size that should fall within the range.

you can see this using https://github.com/derat/font-config-info. when i have a
fontconfig match for a "size" (i.e. points) >= 0 and <= 9 that disables
antialiasing, i see the following:

./font-config-info -f 'Arial 8'  # i.e. 8-point
...
Fontconfig (Arial 8):
requested size       8 points at 96.00 DPI
family               Arial
pixelsize            8.33 pixels
size                 8 points
antialias            0
hinting              1
autohint             0
hintstyle            1 (slight)
rgba                 5 (none)

./font-config-info -f 'Arial 4px'
...
Fontconfig (Arial 4px):
requested size       4.00 pixels at 96.00 DPI
family               Arial
pixelsize            4.00 pixels
size                 [no match]
antialias            1
hinting              1
autohint             0
hintstyle            3 (full)
rgba                 5 (none)

[msw, 2014/07/12 02:26:40]

Acknowledged.

+  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) {
+  const std::vector<std::string> font_list(1, font_name);
+  const FontRenderParams params =
+      GetCustomFontRenderParams(false, &font_list, &font_size, NULL, NULL);
   InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size,
-                  SkTypeface::kNormal);
+                  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 the delta is negative, it must not push the size below 1.
   if (size_delta < 0)
     DCHECK_LT(-size_delta, font_size_pixels_);
 
-  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_));
+  skia::RefPtr<SkTypeface> typeface = typeface_;
+  if (style != style_) {
+    // 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;
+    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)));
+  const int new_size = font_size_pixels_ + size_delta;
+  const std::vector<std::string> family_list(1, font_family_);
+  const FontRenderParams render_params =
+      GetCustomFontRenderParams(false, &family_list, &new_size, NULL, NULL);

[Daniel Erat, 2014/07/11 18:08:40]

calling this is only necessary when |size_delta| is nonzero. i'll update this in
the next revision.

[msw, 2014/07/12 00:27:33]

Really? What if the style (bold/italic) differs?
Please add a comment explaining why that's the case.

[Daniel Erat, 2014/07/12 01:55:33]

to be clear, i mean that the call to GetCustomFontRenderParams() is only
necessary if the size changed, since we only pass the family list and the size
to it. we can just use the previously-queried params otherwise.

[msw, 2014/07/12 02:26:40]

Acknowledged.

 
   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 15 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 style,
+                                     const FontRenderParams& render_params) {
+  InitFromDetails(typeface, name, size, style, render_params);
 }
 
 PlatformFontPango::~PlatformFontPango() {}
 
 void PlatformFontPango::InitFromDetails(
     const skia::RefPtr<SkTypeface>& typeface,
     const std::string& font_family,
     int font_size,
-    int style) {
+    int style,
+    const FontRenderParams& render_params) {
   DCHECK_GT(font_size, 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;
   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