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