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 1086 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)
-          max_height = std::max(max_height, info.size_in_pixel().height());
+        float default_device_scale_factor = 1.0f;
+
+        for (auto& info : *display_info_list) {
+          if (max_height < info.size_in_pixel().height()) {
+            max_height = info.size_in_pixel().height();
+            default_device_scale_factor = info.device_scale_factor();

[Jun Mukai, 2015/07/29 21:26:28]

This means that if two displays are in the same height (i.e. in the same
resolution) but their DSF are different, the default one is the
device_scale_factor which happens to appear the first.
Considering HD Chromebook + external display or multiple 4K display
concatenations, I think it might be better to choose the lower-DSF as the
default.

[oshima, 2015/07/30 01:33:31]

Per offline discussion, changed to use the 1st or internal display as a default.

+          }
+        }
 
         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));

[Jun Mukai, 2015/07/29 21:26:28]

Also, can we add a case of dsf=1.0 as an option?

[oshima, 2015/07/30 01:33:32]

Let's wait for user's feedback. My guess is that users want other resolutions
rather than 1.0dsf, but that should be easy to add.

         }
 
         DisplayInfo info(kUnifiedDisplayId, "Unified Desktop", false);
+        info.set_device_scale_factor(default_device_scale_factor);
         info.SetBounds(unified_bounds);
 
         DisplayMode native_mode(unified_bounds.size(), 60.0f, false, true);
-        info.SetDisplayModes(CreateUnifiedDisplayModeList(native_mode, scales));
+        info.SetDisplayModes(
+            CreateUnifiedDisplayModeList(native_mode, dsf_scale_list));
 
         // 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()) {
           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