ui/gfx/font_render_params_linux.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/font_render_params.h"
   6
   7 #include <fontconfig/fontconfig.h>
   8
   9 #include "base/command_line.h"
  10 #include "base/containers/mru_cache.h"
  11 #include "base/hash.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/logging.h"
  14 #include "base/macros.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/synchronization/lock.h"
  19 #include "ui/gfx/font.h"
  20 #include "ui/gfx/linux_font_delegate.h"
  21 #include "ui/gfx/switches.h"
  22
  23 namespace gfx {
  24
  25 namespace {
  26
  27 #if defined(OS_CHROMEOS)
  28 // A device scale factor for an internal display (if any)
  29 // that is used to determine if subpixel positioning should be used.
  30 float device_scale_factor_for_internal_display = 1.0f;
  31 #endif
  32
  33 // Number of recent GetFontRenderParams() results to cache.
  34 const size_t kCacheSize = 256;
  35
  36 // Cached result from a call to GetFontRenderParams().
  37 struct QueryResult {
  38   QueryResult(const FontRenderParams& params, const std::string& family)
  39       : params(params),
  40         family(family) {
  41   }
  42   ~QueryResult() {}
  43
  44   FontRenderParams params;
  45   std::string family;
  46 };
  47
  48 // Keyed by hashes of FontRenderParamQuery structs from
  49 // HashFontRenderParamsQuery().
  50 typedef base::MRUCache<uint32, QueryResult> Cache;
  51
  52 // A cache and the lock that must be held while accessing it.
  53 // GetFontRenderParams() is called by both the UI thread and the sandbox IPC
  54 // thread.
  55 struct SynchronizedCache {
  56   SynchronizedCache() : cache(kCacheSize) {}
  57
  58   base::Lock lock;
  59   Cache cache;
  60 };
  61
  62 base::LazyInstance<SynchronizedCache>::Leaky g_synchronized_cache =
  63     LAZY_INSTANCE_INITIALIZER;
  64
  65 bool IsBrowserTextSubpixelPositioningEnabled(
  66     const FontRenderParamsQuery& query) {
  67 #if defined(OS_CHROMEOS)
  68   return query.device_scale_factor > 1.0f;
  69 #else
  70   return false;
  71 #endif
  72 }
  73
  74 // Converts Fontconfig FC_HINT_STYLE to FontRenderParams::Hinting.
  75 FontRenderParams::Hinting ConvertFontconfigHintStyle(int hint_style) {
  76   switch (hint_style) {
  77     case FC_HINT_SLIGHT: return FontRenderParams::HINTING_SLIGHT;
  78     case FC_HINT_MEDIUM: return FontRenderParams::HINTING_MEDIUM;
  79     case FC_HINT_FULL:   return FontRenderParams::HINTING_FULL;
  80     default:             return FontRenderParams::HINTING_NONE;
  81   }
  82 }
  83
  84 // Converts Fontconfig FC_RGBA to FontRenderParams::SubpixelRendering.
  85 FontRenderParams::SubpixelRendering ConvertFontconfigRgba(int rgba) {
  86   switch (rgba) {
  87     case FC_RGBA_RGB:  return FontRenderParams::SUBPIXEL_RENDERING_RGB;
  88     case FC_RGBA_BGR:  return FontRenderParams::SUBPIXEL_RENDERING_BGR;
  89     case FC_RGBA_VRGB: return FontRenderParams::SUBPIXEL_RENDERING_VRGB;
  90     case FC_RGBA_VBGR: return FontRenderParams::SUBPIXEL_RENDERING_VBGR;
  91     default:           return FontRenderParams::SUBPIXEL_RENDERING_NONE;
  92   }
  93 }
  94
  95 // Queries Fontconfig for rendering settings and updates |params_out| and
  96 // |family_out| (if non-NULL). Returns false on failure.
  97 bool QueryFontconfig(const FontRenderParamsQuery& query,
  98                      FontRenderParams* params_out,
  99                      std::string* family_out) {
 100   struct FcPatternDeleter {
 101     void operator()(FcPattern* ptr) const { FcPatternDestroy(ptr); }
 102   };
 103   typedef scoped_ptr<FcPattern, FcPatternDeleter> ScopedFcPattern;
 104
 105   ScopedFcPattern query_pattern(FcPatternCreate());
 106   CHECK(query_pattern);
 107
 108   FcPatternAddBool(query_pattern.get(), FC_SCALABLE, FcTrue);
 109
 110   for (std::vector<std::string>::const_iterator it = query.families.begin();
 111        it != query.families.end(); ++it) {
 112     FcPatternAddString(query_pattern.get(),
 113         FC_FAMILY, reinterpret_cast<const FcChar8*>(it->c_str()));
 114   }
 115   if (query.pixel_size > 0)
 116     FcPatternAddDouble(query_pattern.get(), FC_PIXEL_SIZE, query.pixel_size);
 117   if (query.point_size > 0)
 118     FcPatternAddInteger(query_pattern.get(), FC_SIZE, query.point_size);
 119   if (query.style >= 0) {
 120     FcPatternAddInteger(query_pattern.get(), FC_SLANT,
 121         (query.style & Font::ITALIC) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
 122     FcPatternAddInteger(query_pattern.get(), FC_WEIGHT,
 123         (query.style & Font::BOLD) ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL);
 124   }
 125
 126   FcConfigSubstitute(NULL, query_pattern.get(), FcMatchPattern);
 127   FcDefaultSubstitute(query_pattern.get());
 128
 129   ScopedFcPattern result_pattern;
 130   if (query.is_empty()) {
 131     // If the query was empty, call FcConfigSubstituteWithPat() to get a
 132     // non-family- or size-specific configuration so it can be used as the
 133     // default.
 134     result_pattern.reset(FcPatternDuplicate(query_pattern.get()));
 135     if (!result_pattern)
 136       return false;
 137     FcPatternDel(result_pattern.get(), FC_FAMILY);
 138     FcPatternDel(result_pattern.get(), FC_PIXEL_SIZE);
 139     FcPatternDel(result_pattern.get(), FC_SIZE);
 140     FcConfigSubstituteWithPat(NULL, result_pattern.get(), query_pattern.get(),
 141                               FcMatchFont);
 142   } else {
 143     FcResult result;
 144     result_pattern.reset(FcFontMatch(NULL, query_pattern.get(), &result));
 145     if (!result_pattern)
 146       return false;
 147   }
 148   DCHECK(result_pattern);
 149
 150   if (family_out) {
 151     FcChar8* family = NULL;
 152     FcPatternGetString(result_pattern.get(), FC_FAMILY, 0, &family);
 153     if (family)
 154       family_out->assign(reinterpret_cast<const char*>(family));
 155   }
 156
 157   if (params_out) {
 158     FcBool fc_antialias = 0;
 159     if (FcPatternGetBool(result_pattern.get(), FC_ANTIALIAS, 0,
 160                          &fc_antialias) == FcResultMatch) {
 161       params_out->antialiasing = fc_antialias;
 162     }
 163
 164     FcBool fc_autohint = 0;
 165     if (FcPatternGetBool(result_pattern.get(), FC_AUTOHINT, 0, &fc_autohint) ==
 166         FcResultMatch) {
 167       params_out->autohinter = fc_autohint;
 168     }
 169
 170     FcBool fc_bitmap = 0;
 171     if (FcPatternGetBool(result_pattern.get(), FC_EMBEDDED_BITMAP, 0,
 172                          &fc_bitmap) ==
 173         FcResultMatch) {
 174       params_out->use_bitmaps = fc_bitmap;
 175     }
 176
 177     FcBool fc_hinting = 0;
 178     if (FcPatternGetBool(result_pattern.get(), FC_HINTING, 0, &fc_hinting) ==
 179         FcResultMatch) {
 180       int fc_hint_style = FC_HINT_NONE;
 181       if (fc_hinting) {
 182         FcPatternGetInteger(
 183             result_pattern.get(), FC_HINT_STYLE, 0, &fc_hint_style);
 184       }
 185       params_out->hinting = ConvertFontconfigHintStyle(fc_hint_style);
 186     }
 187
 188     int fc_rgba = FC_RGBA_NONE;
 189     if (FcPatternGetInteger(result_pattern.get(), FC_RGBA, 0, &fc_rgba) ==
 190         FcResultMatch)
 191       params_out->subpixel_rendering = ConvertFontconfigRgba(fc_rgba);
 192   }
 193
 194   return true;
 195 }
 196
 197 // Serialize |query| into a string and hash it to a value suitable for use as a
 198 // cache key.
 199 uint32 HashFontRenderParamsQuery(const FontRenderParamsQuery& query) {
 200   return base::Hash(base::StringPrintf(
 201       "%d|%d|%d|%d|%s|%f", query.for_web_contents, query.pixel_size,
 202       query.point_size, query.style, JoinString(query.families, ',').c_str(),
 203       query.device_scale_factor));
 204 }
 205
 206 }  // namespace
 207
 208 FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
 209                                      std::string* family_out) {
 210   FontRenderParamsQuery actual_query(query);
 211 #if defined(OS_CHROMEOS)
 212   if (actual_query.device_scale_factor == 0)
 213     actual_query.device_scale_factor = device_scale_factor_for_internal_display;
 214 #endif
 215   const uint32 hash = HashFontRenderParamsQuery(actual_query);
 216   SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
 217
 218   {
 219     // Try to find a cached result so Fontconfig doesn't need to be queried.
 220     base::AutoLock lock(synchronized_cache->lock);
 221     Cache::const_iterator it = synchronized_cache->cache.Get(hash);
 222     if (it != synchronized_cache->cache.end()) {
 223       DVLOG(1) << "Returning cached params for " << hash;
 224       const QueryResult& result = it->second;
 225       if (family_out)
 226         *family_out = result.family;
 227       return result.params;
 228     }
 229   }
 230
 231   DVLOG(1) << "Computing params for " << hash;
 232   if (family_out)
 233     family_out->clear();
 234
 235   // Start with the delegate's settings, but let Fontconfig have the final say.
 236   FontRenderParams params;
 237   const LinuxFontDelegate* delegate = LinuxFontDelegate::instance();
 238   if (delegate)
 239     params = delegate->GetDefaultFontRenderParams();
 240   QueryFontconfig(actual_query, &params, family_out);
 241   if (!params.antialiasing) {
 242     // Cairo forces full hinting when antialiasing is disabled, since anything
 243     // less than that looks awful; do the same here. Requesting subpixel
 244     // rendering or positioning doesn't make sense either.
 245     params.hinting = FontRenderParams::HINTING_FULL;
 246     params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_NONE;
 247     params.subpixel_positioning = false;
 248   } else {
 249     // Fontconfig doesn't support configuring subpixel positioning; check a
 250     // flag.
 251     params.subpixel_positioning =
 252         actual_query.for_web_contents
 253             ? base::CommandLine::ForCurrentProcess()->HasSwitch(
 254                   switches::kEnableWebkitTextSubpixelPositioning)
 255             : IsBrowserTextSubpixelPositioningEnabled(actual_query);
 256
 257     // To enable subpixel positioning, we need to disable hinting.
 258     if (params.subpixel_positioning)
 259       params.hinting = FontRenderParams::HINTING_NONE;
 260   }
 261
 262   // Use the first family from the list if Fontconfig didn't suggest a family.
 263   if (family_out && family_out->empty() && !actual_query.families.empty())
 264     *family_out = actual_query.families[0];
 265
 266   {
 267     // Store the result. It's fine if this overwrites a result that was cached
 268     // by a different thread in the meantime; the values should be identical.
 269     base::AutoLock lock(synchronized_cache->lock);
 270     synchronized_cache->cache.Put(hash,
 271         QueryResult(params, family_out ? *family_out : std::string()));
 272   }
 273
 274   return params;
 275 }
 276
 277 void ClearFontRenderParamsCacheForTest() {
 278   SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
 279   base::AutoLock lock(synchronized_cache->lock);
 280   synchronized_cache->cache.Clear();
 281 }
 282
 283 #if defined(OS_CHROMEOS)
 284 float GetFontRenderParamsDeviceScaleFactor() {
 285   return device_scale_factor_for_internal_display;
 286 }
 287
 288 void SetFontRenderParamsDeviceScaleFactor(float device_scale_factor) {
 289   device_scale_factor_for_internal_display = device_scale_factor;
 290 }
 291 #endif
 292
 293 }  // namespace gfx