Introduce user customization of external HighDPI mode for 4K monitor.

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>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/screen_ash.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
@@ skipping 44 matching lines @@
 
 // List of value UI Scale values. Scales for 2x are equivalent to 640,
 // 800, 1024, 1280, 1440, 1600 and 1920 pixel width respectively on
 // 2560 pixel width 2x density display. Please see crbug.com/233375
 // for the full list of resolutions.
 const float kUIScalesFor2x[] =
     {0.5f, 0.625f, 0.8f, 1.0f, 1.125f, 1.25f, 1.5f, 2.0f};
 const float kUIScalesFor1_25x[] = {0.5f, 0.625f, 0.8f, 1.0f, 1.25f };
 const float kUIScalesFor1280[] = {0.5f, 0.625f, 0.8f, 1.0f, 1.125f };
 const float kUIScalesFor1366[] = {0.5f, 0.6f, 0.75f, 1.0f, 1.125f };
+const float kDeviceScaleFactorsFor4k[] = {1.0f, 1.25f, 2.0f};
 
 struct DisplaySortFunctor {
   bool operator()(const gfx::Display& a, const gfx::Display& b) {
     return a.id() < b.id();
   }
 };
 
 struct DisplayInfoSortFunctor {
   bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
     return a.id() < b.id();
   }
 };
 
 struct DisplayModeMatcher {
   DisplayModeMatcher(const gfx::Size& size) : size(size) {}
   bool operator()(const DisplayMode& mode) { return mode.size == size; }
   gfx::Size size;
 };
 
+bool CompareDisplayModeBySize(const DisplayMode& m1, const DisplayMode& m2) {
+  return m1.size.GetArea() < m2.size.GetArea();
+}
+
 struct ScaleComparator {
   explicit ScaleComparator(float s) : scale(s) {}
 
   bool operator()(float s) const {
     const float kEpsilon = 0.0001f;
     return std::abs(scale - s) < kEpsilon;
   }
   float scale;
 };
 
@@ skipping 106 matching lines @@
       ASSIGN_ARRAY(ret, kUIScalesFor1280);
 #if defined(OS_CHROMEOS)
       if (base::SysInfo::IsRunningOnChromeOS())
         NOTREACHED() << "Unknown resolution:" << info.ToString();
 #endif
   }
   return ret;
 }
 
 // static
+std::vector<float> DisplayManager::GetDeviceScaleFactorsForDisplay(
+    const DisplayInfo& info) {
+  // This method is currently only used for external displays.
+  std::vector<float> scale_factors;
+  scale_factors.push_back(1.0f);
+  if (gfx::Display::InternalDisplayId() == info.id())
+    return scale_factors;
+
+  const std::vector<DisplayMode>& display_modes = info.display_modes();
+  std::vector<DisplayMode>::const_iterator iter =
+      std::max_element(display_modes.begin(), display_modes.end(),
+                       CompareDisplayModeBySize);
+  if (iter != display_modes.end() && iter->size.width() >= 3840)
+    ASSIGN_ARRAY(scale_factors, kDeviceScaleFactorsFor4k);
+  return scale_factors;
+}
+
+// static
 float DisplayManager::GetNextUIScale(const DisplayInfo& info, bool up) {
   float scale = info.configured_ui_scale();
   std::vector<float> scales = GetScalesForDisplay(info);
   for (size_t i = 0; i < scales.size(); ++i) {
     if (ScaleComparator(scales[i])(scale)) {
       if (up && i != scales.size() - 1)
         return scales[i + 1];
       if (!up && i != 0)
         return scales[i - 1];
       return scales[i];
@@ skipping 239 matching lines @@
                  << resolution.ToString();
     return;
   }
   display_modes_[display_id] = *iter;
 #if defined(OS_CHROMEOS)
   if (base::SysInfo::IsRunningOnChromeOS())
     Shell::GetInstance()->display_configurator()->OnConfigurationChanged();
 #endif
 }
 
+void DisplayManager::SetDisplayDeviceScaleFactor(int64 display_id,
+                                                 float device_scale_factor) {
+  DCHECK_NE(gfx::Display::InternalDisplayId(), display_id);
+  if (gfx::Display::InternalDisplayId() == display_id)
+    return;
+
+  DisplayInfoList display_info_list;
+  for (DisplayList::const_iterator iter = displays_.begin();
+       iter != displays_.end(); ++iter) {
+    DisplayInfo info = GetDisplayInfo(iter->id());
+    if (info.id() == display_id) {
+      if (info.device_scale_factor() == device_scale_factor)
+        return;
+      std::vector<float> scales = GetDeviceScaleFactorsForDisplay(info);
+      ScaleComparator comparator(device_scale_factor);
+      if (std::find_if(scales.begin(), scales.end(), comparator) ==
+          scales.end()) {
+        return;
+      }
+      info.set_device_scale_factor(device_scale_factor);
+    }
+    display_info_list.push_back(info);
+  }
+  UpdateDisplays(display_info_list);
+}
+
 void DisplayManager::RegisterDisplayProperty(
     int64 display_id,
     gfx::Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets,
     const gfx::Size& resolution_in_pixels,
     ui::ColorCalibrationProfile color_profile) {
   if (display_info_.find(display_id) == display_info_.end())
     display_info_[display_id] = DisplayInfo(display_id, std::string(), false);
 
@@ skipping 659 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