Unified Desktop: Support 2xDSF display

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 <utility>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_util.h"
 #include "ash/display/extended_mouse_warp_controller.h"
 #include "ash/display/null_mouse_warp_controller.h"
 #include "ash/display/screen_ash.h"
 #include "ash/display/unified_mouse_warp_controller.h"
 #include "ash/screen_util.h"
@@ skipping 55 matching lines @@
   bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
     return a.id() < b.id();
   }
 };
 
 gfx::Display& GetInvalidDisplay() {
   static gfx::Display* invalid_display = new gfx::Display();
   return *invalid_display;
 }
 
+template <typename F>
+std::vector<DisplayMode>::const_iterator FindDisplayModeL(

[Jun Mukai, 2015/07/30 17:11:11]

I am not sure what is the benefit of defining this function -- at least it's
only used in FindDisplayMode(), so you can invoke std::find_if there.  Also the
body is just two-lines, not sure how beneficial is defining it.

[oshima, 2015/07/30 18:43:28]

Thanks for the catch. I was going to clean up but apparently forgot it.
Done.

+    const DisplayInfo& info,
+    F function) {
+  const std::vector<DisplayMode>& modes = info.display_modes();
+  return std::find_if(modes.begin(), modes.end(), function);
+}
+
 std::vector<DisplayMode>::const_iterator FindDisplayMode(
     const DisplayInfo& info,
     const DisplayMode& target_mode) {
-  const std::vector<DisplayMode>& modes = info.display_modes();
-  return std::find_if(modes.begin(), modes.end(),
-                      [target_mode](const DisplayMode& mode) {
-                        return target_mode.IsEquivalent(mode);
-                      });
+  return FindDisplayModeL(info, [target_mode](const DisplayMode& mode) {
+    return target_mode.IsEquivalent(mode);
+  });
 }
 
 void SetInternalDisplayModeList(DisplayInfo* info) {
   DisplayMode native_mode;
   native_mode.size = info->bounds_in_native().size();
   native_mode.device_scale_factor = info->device_scale_factor();
   native_mode.ui_scale = 1.0f;
   info->SetDisplayModes(CreateInternalDisplayModeList(native_mode));
 }
 
 void MaybeInitInternalDisplay(DisplayInfo* info) {
   int64 id = info->id();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal)) {
     gfx::Display::SetInternalDisplayId(id);
     SetInternalDisplayModeList(info);
   }
 }
 
+gfx::Size GetMaxNativeSize(const DisplayInfo& info) {
+  gfx::Size size;
+  for (auto& mode : info.display_modes()) {
+    if (mode.size.GetArea() > size.GetArea())
+      size = mode.size;
+  }
+  return size;
+}
+
 }  // namespace
 
 using std::string;
 using std::vector;
 
 // static
 int64 DisplayManager::kUnifiedDisplayId = -10;
 
 DisplayManager::DisplayManager()
     : delegate_(NULL),
@@ skipping 323 matching lines @@
   DisplayMode selected_mode;
   if (GetSelectedModeForDisplayId(display_id, &selected_mode))
     return selected_mode;
 
   // If 'selected' mode is empty, it should return the default mode. This means
   // the native mode for the external display. Unfortunately this is not true
   // for the internal display because restoring UI-scale doesn't register the
   // restored mode to |display_mode_|, so it needs to look up the mode whose
   // UI-scale value matches. See the TODO in RegisterDisplayProperty().
   const DisplayInfo& info = GetDisplayInfo(display_id);
-  const std::vector<DisplayMode>& display_modes = info.display_modes();
 
-  if (GetDisplayIdForUIScaling() == display_id) {
-    for (size_t i = 0; i < display_modes.size(); ++i) {
-      if (info.configured_ui_scale() == display_modes[i].ui_scale)
-        return display_modes[i];
-    }
-  } else {
-    for (size_t i = 0; i < display_modes.size(); ++i) {
-      if (display_modes[i].native)
-        return display_modes[i];
+  for (auto& mode : info.display_modes()) {
+    if (GetDisplayIdForUIScaling() == display_id) {
+      if (info.configured_ui_scale() == mode.ui_scale)
+        return mode;
+    } else if (mode.native) {
+      return mode;
     }
   }
   return selected_mode;
 }
 
 void DisplayManager::RegisterDisplayRotationProperties(bool rotation_lock,
     gfx::Display::Rotation rotation) {
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   registered_internal_display_rotation_lock_ = rotation_lock;
@@ skipping 630 matching lines @@
       }
       case UNIFIED: {
         // TODO(oshima): Currently, all displays are laid out horizontally,
         // from left to right. Allow more flexible layouts, such as
         // right to left, or vertical layouts.
         gfx::Rect unified_bounds;
         software_mirroring_display_list_.clear();
 
         // 1st Pass. Find the max size.
         int max_height = std::numeric_limits<int>::min();
-        for (auto& info : *display_info_list)
+
+        int default_height = 0;
+        float default_device_scale_factor = 1.0f;
+        for (auto& info : *display_info_list) {
           max_height = std::max(max_height, info.size_in_pixel().height());
+          if (!default_height || gfx::Display::IsInternalDisplayId(info.id())) {
+            default_height = info.size_in_pixel().height();
+            default_device_scale_factor = info.device_scale_factor();
+          }
+        }
 
         std::vector<DisplayMode> display_mode_list;
-        std::set<float> scales;
+        std::set<std::pair<float, float>> dsf_scale_list;
 
         // 2nd Pass. Compute the unified display size.
         for (auto& info : *display_info_list) {
           InsertAndUpdateDisplayInfo(info);
           gfx::Point origin(unified_bounds.right(), 0);
           float scale =
               info.size_in_pixel().height() / static_cast<float>(max_height);
           // The display is scaled to fit the unified desktop size.
           gfx::Display display = CreateMirroringDisplayFromDisplayInfoById(
               info.id(), origin, 1.0f / scale);
           unified_bounds.Union(display.bounds());
 
-          scales.insert(scale);
+          dsf_scale_list.insert(
+              std::make_pair(info.device_scale_factor(), scale));
         }
 
         DisplayInfo info(kUnifiedDisplayId, "Unified Desktop", false);
-        info.SetBounds(unified_bounds);
 
         DisplayMode native_mode(unified_bounds.size(), 60.0f, false, true);
-        info.SetDisplayModes(CreateUnifiedDisplayModeList(native_mode, scales));
+        std::vector<DisplayMode> modes =
+            CreateUnifiedDisplayModeList(native_mode, dsf_scale_list);
+
+        // Find the default mode.
+        auto iter = std::find_if(
+            modes.begin(), modes.end(),
+            [default_height,
+             default_device_scale_factor](const DisplayMode& mode) {
+              return mode.size.height() == default_height &&
+                     mode.device_scale_factor == default_device_scale_factor;
+            });
+        iter->native = true;
+        info.SetDisplayModes(modes);
+        info.set_device_scale_factor(iter->device_scale_factor);
+        info.SetBounds(gfx::Rect(iter->size));
 
         // Forget the configured resolution if the original unified
         // desktop resolution has changed.
         if (display_info_.count(kUnifiedDisplayId) != 0 &&
-            display_info_[kUnifiedDisplayId].size_in_pixel() !=
-                info.size_in_pixel()) {
+            GetMaxNativeSize(display_info_[kUnifiedDisplayId]) !=
+                unified_bounds.size()) {
           display_modes_.erase(kUnifiedDisplayId);
         }
 
         // 3rd Pass. Set the selected mode, then recompute the mirroring
         // display size.
         DisplayMode mode;
         if (GetSelectedModeForDisplayId(kUnifiedDisplayId, &mode) &&
             FindDisplayMode(info, mode) != info.display_modes().end()) {
-          // TODO(oshima): device scale factor.
+          info.set_device_scale_factor(mode.device_scale_factor);
           info.SetBounds(gfx::Rect(mode.size));
         } else {
           display_modes_.erase(kUnifiedDisplayId);
         }
 
         int unified_display_height = info.size_in_pixel().height();
         gfx::Point origin;
         for (auto& info : *display_info_list) {
           float display_scale = info.size_in_pixel().height() /
                                 static_cast<float>(unified_display_height);
@@ skipping 200 matching lines @@
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash