Updates subpixel positioning and hinting when DSF is changed

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 43 matching lines @@
 struct SynchronizedCache {
   SynchronizedCache() : cache(kCacheSize) {}
 
   base::Lock lock;
   Cache cache;
 };
 
 base::LazyInstance<SynchronizedCache>::Leaky g_synchronized_cache =
     LAZY_INSTANCE_INITIALIZER;
 
-bool IsBrowserTextSubpixelPositioningEnabled() {
+bool IsBrowserTextSubpixelPositioningEnabled(
+    const FontRenderParamsQuery& query) {
 #if defined(OS_CHROMEOS)
-  return device_scale_factor_for_internal_display > 1.0f;
+  return query.device_scale_factor > 1.0f;
 #else
   return false;
 #endif
 }
 
 // Converts Fontconfig FC_HINT_STYLE to FontRenderParams::Hinting.
 FontRenderParams::Hinting ConvertFontconfigHintStyle(int hint_style) {
   switch (hint_style) {
     case FC_HINT_SLIGHT: return FontRenderParams::HINTING_SLIGHT;
     case FC_HINT_MEDIUM: return FontRenderParams::HINTING_MEDIUM;
@@ skipping 95 matching lines @@
       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",
-      query.for_web_contents, query.pixel_size, query.point_size, query.style,
-      JoinString(query.families, ',').c_str()));
+  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));
 }
 
 }  // namespace
 
 FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
                                      std::string* family_out) {
-  const uint32 hash = HashFontRenderParamsQuery(query);
+  FontRenderParamsQuery actual_query(query);
+#if defined(OS_CHROMEOS)
+  if (actual_query.device_scale_factor == 0)
+    actual_query.device_scale_factor = device_scale_factor_for_internal_display;
+#endif
+  const uint32 hash = HashFontRenderParamsQuery(actual_query);
   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;
       const QueryResult& result = it->second;
       if (family_out)
         *family_out = result.family;
       return result.params;
     }
   }
 
   DVLOG(1) << "Computing params for " << hash;
   if (family_out)
     family_out->clear();
 
   // 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);
+  QueryFontconfig(actual_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
     // rendering or positioning doesn't make sense either.
     params.hinting = FontRenderParams::HINTING_FULL;
     params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_NONE;
     params.subpixel_positioning = false;
   } else {
     // Fontconfig doesn't support configuring subpixel positioning; check a
     // flag.
     params.subpixel_positioning =
-        query.for_web_contents ?
-        CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableWebkitTextSubpixelPositioning) :
-        IsBrowserTextSubpixelPositioningEnabled();
+        actual_query.for_web_contents
+            ? CommandLine::ForCurrentProcess()->HasSwitch(
+                  switches::kEnableWebkitTextSubpixelPositioning)
+            : IsBrowserTextSubpixelPositioningEnabled(actual_query);
 
     // 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];
+  if (family_out && family_out->empty() && !actual_query.families.empty())
+    *family_out = actual_query.families[0];
 
   {
     // 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)
+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