Enable subpixel positioning for internal display with dsf larger than 1.0

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 "base/command_line.h"
 #include "base/containers/mru_cache.h"
 #include "base/hash.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/linux_font_delegate.h"
 #include "ui/gfx/switches.h"
 
 #include <fontconfig/fontconfig.h>
 
 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;

[Alexei Svitkine (slow), 2014/08/21 15:36:38]

Nit: add g_ prefix

+#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;
 
 // 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;
 };
 
 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 113 matching lines @@
   }
   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
     // 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 = CommandLine::ForCurrentProcess()->HasSwitch(
+    params.subpixel_positioning =
         query.for_web_contents ?
-        switches::kEnableWebkitTextSubpixelPositioning :
-        switches::kEnableBrowserTextSubpixelPositioning);
+        CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableWebkitTextSubpixelPositioning) :
+        IsBrowserTextSubpixelPositioningEnabled();
 
     // 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);
 
   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