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() {
-#if defined(OS_CHROMEOS)
-  return device_scale_factor_for_internal_display > 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;
     case FC_HINT_FULL:   return FontRenderParams::HINTING_FULL;
     default:             return FontRenderParams::HINTING_NONE;
   }
 }
 
@@ skipping 97 matching lines @@
 // 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()));
 }
 
 }  // namespace
 
-FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
-                                     std::string* family_out) {
+FontRenderParams GetSystemFontRenderParams(const FontRenderParamsQuery& query,
+                                           std::string* family_out) {
   const uint32 hash = HashFontRenderParamsQuery(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;
@@ skipping 12 matching lines @@
   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
     // 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();
-
-    // To enable subpixel positioning, we need to disable hinting.
-    if (params.subpixel_positioning)
-      params.hinting = FontRenderParams::HINTING_NONE;
   }
+  params.subpixel_positioning = false;
 
   // 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 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