linux/chromeos: Improve querying for Fontconfig defaults.

ui/gfx/font_render_params_linux.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/font_render_params.h"
 
 #include <fontconfig/fontconfig.h>
 
 #include "base/command_line.h"
 #include "base/containers/mru_cache.h"
 #include "base/hash.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/linux_font_delegate.h"
 #include "ui/gfx/switches.h"
 
 namespace gfx {
 
 namespace {
@@ skipping 64 matching lines @@
     case FC_RGBA_VBGR: return FontRenderParams::SUBPIXEL_RENDERING_VBGR;
     default:           return FontRenderParams::SUBPIXEL_RENDERING_NONE;
   }
 }
 
 // Queries Fontconfig for rendering settings and updates |params_out| and
 // |family_out| (if non-NULL). Returns false on failure.
 bool QueryFontconfig(const FontRenderParamsQuery& query,
                      FontRenderParams* params_out,
                      std::string* family_out) {
-  FcPattern* query_pattern = FcPatternCreate();
+  struct FcPatternDeleter {
+    void operator()(FcPattern* ptr) const { FcPatternDestroy(ptr); }
+  };
+  typedef scoped_ptr<FcPattern, FcPatternDeleter> ScopedFcPattern;
+
+  ScopedFcPattern query_pattern(FcPatternCreate());
   CHECK(query_pattern);
 
-  FcPatternAddBool(query_pattern, FC_SCALABLE, FcTrue);
+  FcPatternAddBool(query_pattern.get(), FC_SCALABLE, FcTrue);
 
   for (std::vector<std::string>::const_iterator it = query.families.begin();
        it != query.families.end(); ++it) {
-    FcPatternAddString(query_pattern,
+    FcPatternAddString(query_pattern.get(),
         FC_FAMILY, reinterpret_cast<const FcChar8*>(it->c_str()));
   }
   if (query.pixel_size > 0)
-    FcPatternAddDouble(query_pattern, FC_PIXEL_SIZE, query.pixel_size);
+    FcPatternAddDouble(query_pattern.get(), FC_PIXEL_SIZE, query.pixel_size);
   if (query.point_size > 0)
-    FcPatternAddInteger(query_pattern, FC_SIZE, query.point_size);
+    FcPatternAddInteger(query_pattern.get(), FC_SIZE, query.point_size);
   if (query.style >= 0) {
-    FcPatternAddInteger(query_pattern, FC_SLANT,
+    FcPatternAddInteger(query_pattern.get(), FC_SLANT,
         (query.style & Font::ITALIC) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
-    FcPatternAddInteger(query_pattern, FC_WEIGHT,
+    FcPatternAddInteger(query_pattern.get(), FC_WEIGHT,
         (query.style & Font::BOLD) ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL);
   }
 
-  FcConfigSubstitute(NULL, query_pattern, FcMatchPattern);
-  FcDefaultSubstitute(query_pattern);
+  FcConfigSubstitute(NULL, query_pattern.get(), FcMatchPattern);
+  FcDefaultSubstitute(query_pattern.get());
 
-  // If the query was non-empty, match a specific font and destroy the query
-  // pattern. Otherwise, just use the query pattern.
-  FcPattern* result_pattern = query_pattern;
-  if (!query.is_empty()) {
+  ScopedFcPattern result_pattern;
+  if (query.is_empty()) {
+    // If the query was empty, call FcConfigSubstituteWithPat() to get
+    // non-family-specific configuration so it can be used as the default.
+    result_pattern.reset(FcPatternDuplicate(query_pattern.get()));
+    if (!result_pattern)
+      return false;
+    FcPatternDel(result_pattern.get(), FC_FAMILY);
+    FcConfigSubstituteWithPat(NULL, result_pattern.get(), query_pattern.get(),
+                              FcMatchFont);
+  } else {
     FcResult result;
-    result_pattern = FcFontMatch(NULL, query_pattern, &result);
-    FcPatternDestroy(query_pattern);
-    query_pattern = NULL;
+    result_pattern.reset(FcFontMatch(NULL, query_pattern.get(), &result));
     if (!result_pattern)
       return false;
   }
+  DCHECK(result_pattern);
 
   if (family_out) {
     FcChar8* family = NULL;
-    FcPatternGetString(result_pattern, FC_FAMILY, 0, &family);
+    FcPatternGetString(result_pattern.get(), FC_FAMILY, 0, &family);
     if (family)
       family_out->assign(reinterpret_cast<const char*>(family));
   }
 
   if (params_out) {
     FcBool fc_antialias = 0;
-    if (FcPatternGetBool(result_pattern, FC_ANTIALIAS, 0, &fc_antialias) ==
-        FcResultMatch) {
+    if (FcPatternGetBool(result_pattern.get(), FC_ANTIALIAS, 0,
+                         &fc_antialias) == FcResultMatch) {
       params_out->antialiasing = fc_antialias;
     }
 
     FcBool fc_autohint = 0;
-    if (FcPatternGetBool(result_pattern, FC_AUTOHINT, 0, &fc_autohint) ==
+    if (FcPatternGetBool(result_pattern.get(), FC_AUTOHINT, 0, &fc_autohint) ==
         FcResultMatch) {
       params_out->autohinter = fc_autohint;
     }
 
     FcBool fc_bitmap = 0;
-    if (FcPatternGetBool(result_pattern, FC_EMBEDDED_BITMAP, 0, &fc_bitmap) ==
+    if (FcPatternGetBool(result_pattern.get(), FC_EMBEDDED_BITMAP, 0,
+                         &fc_bitmap) ==
         FcResultMatch) {
       params_out->use_bitmaps = fc_bitmap;
     }
 
     FcBool fc_hinting = 0;
-    if (FcPatternGetBool(result_pattern, FC_HINTING, 0, &fc_hinting) ==
+    if (FcPatternGetBool(result_pattern.get(), FC_HINTING, 0, &fc_hinting) ==
         FcResultMatch) {
       int fc_hint_style = FC_HINT_NONE;
-      if (fc_hinting)
-        FcPatternGetInteger(result_pattern, FC_HINT_STYLE, 0, &fc_hint_style);
+      if (fc_hinting) {
+        FcPatternGetInteger(
+            result_pattern.get(), FC_HINT_STYLE, 0, &fc_hint_style);
+      }
       params_out->hinting = ConvertFontconfigHintStyle(fc_hint_style);
     }
 
     int fc_rgba = FC_RGBA_NONE;
-    if (FcPatternGetInteger(result_pattern, FC_RGBA, 0, &fc_rgba) ==
+    if (FcPatternGetInteger(result_pattern.get(), FC_RGBA, 0, &fc_rgba) ==
         FcResultMatch)
       params_out->subpixel_rendering = ConvertFontconfigRgba(fc_rgba);
   }
 
-  FcPatternDestroy(result_pattern);
   return true;
 }
 
 // Serialize |query| into a string and hash it to a value suitable for use as a
 // cache key.
 uint32 HashFontRenderParamsQuery(const FontRenderParamsQuery& query) {
   return base::Hash(base::StringPrintf(
       "%d|%d|%d|%d|%s|%f", query.for_web_contents, query.pixel_size,
       query.point_size, query.style, JoinString(query.families, ',').c_str(),
       query.device_scale_factor));
@@ skipping 80 matching lines @@
 float GetFontRenderParamsDeviceScaleFactor() {
   return device_scale_factor_for_internal_display;
 }
 
 void SetFontRenderParamsDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_for_internal_display = device_scale_factor;
 }
 #endif
 
 }  // namespace gfx