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 448 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::SetDisplayMode(int64 display_id,
+                                    const DisplayMode& display_mode) {
+  if (IsInternalDisplayId(display_id)) {
+    SetDisplayUIScale(display_id, display_mode.ui_scale);
+    return;
+  }
+
+  DisplayInfoList display_info_list;
+  bool display_property_changed = false;
+  bool resolution_changed = false;
+  for (DisplayList::const_iterator iter = displays_.begin();
+       iter != displays_.end(); ++iter) {
+    DisplayInfo info = GetDisplayInfo(iter->id());
+    if (info.id() == display_id) {
+      if (info.bounds_in_native().size() != display_mode.size) {
+        const std::vector<DisplayMode>& modes = info.display_modes();
+        std::vector<DisplayMode>::const_iterator iter =
+            std::find_if(modes.begin(), modes.end(),
+                         DisplayModeMatcher(display_mode.size));
+        if (iter == modes.end()) {
+          LOG(WARNING) << "Unsupported resolution was requested:"
+                       << display_mode.size.ToString();
+          return;
+        }
+        display_modes_[display_id] = *iter;
+        resolution_changed = true;
+      }
+      if (info.device_scale_factor() != display_mode.device_scale_factor) {
+        info.set_device_scale_factor(display_mode.device_scale_factor);
+        display_property_changed = true;
+      }
+    }
+    display_info_list.push_back(info);
+  }
+  if (display_property_changed) {
+    AddMirrorDisplayInfoIfAny(&display_info_list);
+    UpdateDisplays(display_info_list);
+  }
+#if defined(OS_CHROMEOS)
+  if (resolution_changed && base::SysInfo::IsRunningOnChromeOS())
+    Shell::GetInstance()->display_configurator()->OnConfigurationChanged();
+#endif
+}
+
 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