linux: Cache families from FontRenderParams queries.

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"
@@ skipping 11 matching lines @@
 namespace gfx {
 
 namespace {
 
 #if defined(OS_CHROMEOS)
 // A device scale factor for an internal display (if any)
 // that is used to determine if subpixel positioning should be used.
 float device_scale_factor_for_internal_display = 1.0f;
 #endif
 
-// Keyed by hashes of FontRenderParamQuery structs from
-// HashFontRenderParamsQuery().
-typedef base::MRUCache<uint32, FontRenderParams> Cache;
-
 // Number of recent GetFontRenderParams() results to cache.
 const size_t kCacheSize = 20;
 
+// Cached result from a call to GetFontRenderParams().
+struct QueryResult {
+  QueryResult(const FontRenderParams& params, const std::string& family)
+      : params(params),
+        family(family) {
+  }
+  ~QueryResult() {}
+
+  FontRenderParams params;
+  std::string family;
+};
+
+// Keyed by hashes of FontRenderParamQuery structs from
+// HashFontRenderParamsQuery().
+typedef base::MRUCache<uint32, QueryResult> Cache;
+
 // A cache and the lock that must be held while accessing it.
 // GetFontRenderParams() is called by both the UI thread and the sandbox IPC
 // thread.
 struct SynchronizedCache {
   SynchronizedCache() : cache(kCacheSize) {}
 
   base::Lock lock;
   Cache cache;
 };
 
@@ skipping 112 matching lines @@
   return base::Hash(base::StringPrintf("%d|%d|%d|%d|%s",
       query.for_web_contents, query.pixel_size, query.point_size, query.style,
       JoinString(query.families, ',').c_str()));
 }
 
 }  // namespace
 
 FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
                                      std::string* family_out) {
   const uint32 hash = HashFontRenderParamsQuery(query);
-  if (!family_out) {
-    // The family returned by Fontconfig isn't part of FontRenderParams, so we
-    // can only return a value from the cache if it wasn't requested.
-    SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
+  SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
+
+  {
+    // Try to find a cached result so Fontconfig doesn't need to be queried.
     base::AutoLock lock(synchronized_cache->lock);
     Cache::const_iterator it = synchronized_cache->cache.Get(hash);
     if (it != synchronized_cache->cache.end()) {
       DVLOG(1) << "Returning cached params for " << hash;
-      return it->second;
+      const QueryResult& result = it->second;
+      if (family_out)
+        *family_out = result.family;
+      return result.params;
     }
-  } else {
+  }
+
+  DVLOG(1) << "Computing params for " << hash;
+  if (family_out)
     family_out->clear();
-  }
-  DVLOG(1) << "Computing params for " << hash
-           << (family_out ? " (family requested)" : "");
 
   // Start with the delegate's settings, but let Fontconfig have the final say.
   FontRenderParams params;
   const LinuxFontDelegate* delegate = LinuxFontDelegate::instance();
   if (delegate)
     params = delegate->GetDefaultFontRenderParams();
   QueryFontconfig(query, &params, family_out);
   if (!params.antialiasing) {
     // Cairo forces full hinting when antialiasing is disabled, since anything
     // less than that looks awful; do the same here. Requesting subpixel
@@ skipping 12 matching lines @@
 
     // To enable subpixel positioning, we need to disable hinting.
     if (params.subpixel_positioning)
       params.hinting = FontRenderParams::HINTING_NONE;
   }
 
   // Use the first family from the list if Fontconfig didn't suggest a family.
   if (family_out && family_out->empty() && !query.families.empty())
     *family_out = query.families[0];
 
-  // Store the computed struct. It's fine if this overwrites a struct that was
-  // cached by a different thread in the meantime; the values should be
-  // identical.
-  SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
-  base::AutoLock lock(synchronized_cache->lock);
-  synchronized_cache->cache.Put(hash, params);
+  {
+    // Store the result. It's fine if this overwrites a result that was cached
+    // by a different thread in the meantime; the values should be identical.
+    base::AutoLock lock(synchronized_cache->lock);
+    synchronized_cache->cache.Put(hash,
+        QueryResult(params, family_out ? *family_out : std::string()));
+  }
 
   return params;
 }
 
 void ClearFontRenderParamsCacheForTest() {
   SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
   base::AutoLock lock(synchronized_cache->lock);
   synchronized_cache->cache.Clear();
 }
 
 #if defined(OS_CHROMEOS)
 void SetFontRenderParamsDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_for_internal_display = device_scale_factor;
 }
 #endif
 
 }  // namespace gfx