Updates subpixel positioning and hinting when DSF is changed

ash/display/display_manager.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 "ash/display/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <string>
@@ skipping 93 matching lines @@
   static gfx::Display* invalid_display = new gfx::Display();
   return *invalid_display;
 }
 
 void MaybeInitInternalDisplay(int64 id) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal))
     gfx::Display::SetInternalDisplayId(id);
 }
 
+class FontRenderParamsRewriterAsh : public gfx::FontRenderParamsRewriter {
+ public:
+  FontRenderParamsRewriterAsh() {}
+  ~FontRenderParamsRewriterAsh() override {}
+
+ private:
+  bool IsBrowserTextSubpixelPositioningEnabled() {
+    DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+    if (!display_manager->HasInternalDisplay())
+      return false;
+    int64 internal_id = gfx::Display::InternalDisplayId();
+    const gfx::Display& internal_display =
+        display_manager->GetDisplayForId(internal_id);
+    // The internal display ID exists but the display object does not exist in
+    // case of the docked mode.
+    if (!internal_display.is_valid())
+      return false;
+    const DisplayInfo& display_info =
+        display_manager->GetDisplayInfo(internal_id);
+    return display_info.GetEffectiveDeviceScaleFactor() > 1.0f;
+  }
+
+  // gfx::FontRenderParamsRewriter:
+  void RewriteParams(gfx::FontRenderParams* params) override {
+#if defined(OS_CHROMEOS)
+    if (params->antialiasing) {
+      params->subpixel_positioning = IsBrowserTextSubpixelPositioningEnabled();
+      if (params->subpixel_positioning)
+        params->hinting = gfx::FontRenderParams::HINTING_NONE;
+    }
+#endif
+  }
+};
+
 }  // namespace
 
 using std::string;
 using std::vector;
 
 DisplayManager::DisplayManager()
     : delegate_(NULL),
       screen_ash_(new ScreenAsh),
       screen_(screen_ash_.get()),
       layout_store_(new DisplayLayoutStore),
@@ skipping 21 matching lines @@
   // If there is no native, or the native was for shutdown,
   // use ash's screen.
   if (!current_native ||
       current_native == screen_for_shutdown) {
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
                                    screen_ash_.get());
   }
 }
 
 DisplayManager::~DisplayManager() {
-#if defined(OS_CHROMEOS)
-  // Reset the font params.
-  gfx::SetFontRenderParamsDeviceScaleFactor(1.0f);
-#endif
+  gfx::FontRenderParamsRewriter::Shutdown();
 }
 
 // static
 std::vector<float> DisplayManager::GetScalesForDisplay(
     const DisplayInfo& info) {
 
 #define ASSIGN_ARRAY(v, a) v.assign(a, a + arraysize(a))
 
   std::vector<float> ret;
   if (info.device_scale_factor() == 2.0f) {
@@ skipping 62 matching lines @@
 
 void DisplayManager::InitDefaultDisplay() {
   DisplayInfoList info_list;
   info_list.push_back(DisplayInfo::CreateFromSpec(std::string()));
   info_list.back().set_native(true);
   MaybeInitInternalDisplay(info_list[0].id());
   OnNativeDisplaysChanged(info_list);
 }
 
 void DisplayManager::InitFontParams() {
-#if defined(OS_CHROMEOS)
-  if (!HasInternalDisplay())
-    return;
-  const DisplayInfo& display_info =
-      GetDisplayInfo(gfx::Display::InternalDisplayId());
-  gfx::SetFontRenderParamsDeviceScaleFactor(
-      display_info.GetEffectiveDeviceScaleFactor());
-#endif  // OS_CHROMEOS
+  gfx::FontRenderParamsRewriter::SetInstance(new FontRenderParamsRewriterAsh());
 }
 
 // static
 void DisplayManager::UpdateDisplayBoundsForLayoutById(
     const DisplayLayout& layout,
     const gfx::Display& primary_display,
     int64 secondary_display_id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, secondary_display_id);
   UpdateDisplayBoundsForLayout(
       layout, primary_display,
@@ skipping 1038 matching lines @@
       new_secondary_origin.Offset(-secondary_bounds.width(), offset);
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace ash