Unified Desktop: Support 2xDSF display

ash/display/display_util.cc

 // Copyright 2014 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_util.h"
 
 #include <algorithm>
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
@@ skipping 108 matching lines @@
     DisplayMode mode = native_mode;
     mode.ui_scale = ui_scale;
     mode.native = (ui_scale == native_ui_scale);
     display_mode_list.push_back(mode);
   }
   return display_mode_list;
 }
 
 std::vector<DisplayMode> CreateUnifiedDisplayModeList(
     const DisplayMode& native_mode,
-    const std::set<float>& scales) {
+    const std::set<std::pair<float, float>>& dsf_scale_list) {
   std::vector<DisplayMode> display_mode_list;
 
-  for (float ui_scale : scales) {
+  for (auto& pair : dsf_scale_list) {
     DisplayMode mode = native_mode;
+    mode.device_scale_factor = pair.first;
     gfx::SizeF scaled_size(native_mode.size);
-    scaled_size.Scale(ui_scale);
+    scaled_size.Scale(pair.second);
     mode.size = gfx::ToFlooredSize(scaled_size);
     mode.native = mode.size == native_mode.size;
     display_mode_list.push_back(mode);
   }
+  // Sort the mode by the size in DIP.
+  std::sort(display_mode_list.begin(), display_mode_list.end(),
+            [](const DisplayMode& a, const DisplayMode& b) {
+              return a.GetSizeInDIP(false).GetArea() <
+                     b.GetSizeInDIP(false).GetArea();
+            });
   return display_mode_list;
 }
 
 bool GetDisplayModeForResolution(const DisplayInfo& info,
                                  const gfx::Size& resolution,
                                  DisplayMode* out) {
   if (gfx::Display::IsInternalDisplayId(info.id()))
     return false;
 
   const std::vector<DisplayMode>& modes = info.display_modes();
@@ skipping 24 matching lines @@
   FindNextMode(iter, modes, up, out);
   return true;
 }
 
 bool GetDisplayModeForNextResolution(const DisplayInfo& info,
                                      bool up,
                                      DisplayMode* out) {
   if (gfx::Display::IsInternalDisplayId(info.id()))
     return false;
   const std::vector<DisplayMode>& modes = info.display_modes();
-  const gfx::Size& resolution = info.size_in_pixel();
+  DisplayMode tmp(info.size_in_pixel(), 0.0f, false, false);
+  tmp.device_scale_factor = info.device_scale_factor();
+  gfx::Size resolution = tmp.GetSizeInDIP(false);
   auto iter = std::find_if(modes.begin(), modes.end(),
                            [resolution](const DisplayMode& mode) {
-                             return mode.size == resolution;
+                             return mode.GetSizeInDIP(false) == resolution;
                            });
   FindNextMode(iter, modes, up, out);
   return true;
 }
 
 bool SetDisplayUIScale(int64 id, float ui_scale) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   const DisplayInfo& info = display_manager->GetDisplayInfo(id);
   DisplayMode mode;
   if (!GetDisplayModeForUIScale(info, ui_scale, &mode))
@@ skipping 125 matching lines @@
 int FindDisplayIndexContainingPoint(const std::vector<gfx::Display>& displays,
                                     const gfx::Point& point_in_screen) {
   auto iter = std::find_if(displays.begin(), displays.end(),
                            [point_in_screen](const gfx::Display& display) {
                              return display.bounds().Contains(point_in_screen);
                            });
   return iter == displays.end() ? -1 : (iter - displays.begin());
 }
 
 }  // namespace ash