Make ash::DisplayMode more like ui::DisplayMode

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 <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
+#include "ash/common/display/display_info.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"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 50 matching lines @@
   bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
     return CompareDisplayIds(a.id(), b.id());
   }
 };
 
 display::Display& GetInvalidDisplay() {
   static display::Display* invalid_display = new display::Display();
   return *invalid_display;
 }
 
-std::vector<DisplayMode>::const_iterator FindDisplayMode(
+DisplayInfo::DisplayModeList::const_iterator FindDisplayMode(
     const DisplayInfo& info,
-    const DisplayMode& target_mode) {
-  const std::vector<DisplayMode>& modes = info.display_modes();
+    const scoped_refptr<DisplayMode>& target_mode) {
+  const DisplayInfo::DisplayModeList& modes = info.display_modes();
   return std::find_if(modes.begin(), modes.end(),
-                      [target_mode](const DisplayMode& mode) {
-                        return target_mode.IsEquivalent(mode);
+                      [target_mode](const scoped_refptr<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;
+  scoped_refptr<DisplayMode> native_mode =
+      new DisplayMode(info->bounds_in_native().size(),
+                      /* refresh_rate */ 0.0,
+                      /* interlaced */ false,
+                      /* native_mode */ false,
+                      /* ui_scale */ 1.0, info->device_scale_factor());
   info->SetDisplayModes(CreateInternalDisplayModeList(native_mode));
 }
 
 void MaybeInitInternalDisplay(DisplayInfo* info) {
   int64_t id = info->id();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal)) {
     display::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;
+    if (mode->size().GetArea() > size.GetArea())
+      size = mode->size();
   }
   return size;
 }
 
 }  // namespace
 
 using std::string;
 using std::vector;
 
 // static
@@ skipping 211 matching lines @@
   }
   if (is_active) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
     UpdateDisplaysWith(display_info_list);
   } else if (display_info_.find(display_id) != display_info_.end()) {
     // Inactive displays can reactivate, ensure they have been updated.
     display_info_[display_id].SetRotation(rotation, source);
   }
 }
 
-bool DisplayManager::SetDisplayMode(int64_t display_id,
-                                    const DisplayMode& display_mode) {
+bool DisplayManager::SetDisplayMode(
+    int64_t display_id,
+    const scoped_refptr<DisplayMode>& display_mode) {
   bool change_ui_scale = GetDisplayIdForUIScaling() == display_id;
 
   DisplayInfoList display_info_list;
   bool display_property_changed = false;
   bool resolution_changed = false;
   for (const auto& display : active_display_list_) {
     DisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       auto iter = FindDisplayMode(info, display_mode);
       if (iter == info.display_modes().end()) {
         LOG(WARNING) << "Unsupported display mode was requested:"
-                     << "size=" << display_mode.size.ToString()
-                     << ", ui scale=" << display_mode.ui_scale
-                     << ", scale fator=" << display_mode.device_scale_factor;
+                     << "size=" << display_mode->size().ToString()
+                     << ", ui scale=" << display_mode->ui_scale()
+                     << ", scale factor="
+                     << display_mode->device_scale_factor();
         return false;
       }
 
       if (change_ui_scale) {
-        if (info.configured_ui_scale() == display_mode.ui_scale)
+        if (info.configured_ui_scale() == display_mode->ui_scale())
           return true;
-        info.set_configured_ui_scale(display_mode.ui_scale);
+        info.set_configured_ui_scale(display_mode->ui_scale());
         display_property_changed = true;
       } else {
         display_modes_[display_id] = *iter;
-        if (info.bounds_in_native().size() != display_mode.size)
+        if (info.bounds_in_native().size() != display_mode->size())
           resolution_changed = true;
-        if (info.device_scale_factor() != display_mode.device_scale_factor) {
-          info.set_device_scale_factor(display_mode.device_scale_factor);
+        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);
     UpdateDisplaysWith(display_info_list);
   }
@@ skipping 31 matching lines @@
   // TODO(mukai): register |display_modes_| here as well, so the lookup for the
   // default mode in GetActiveModeForDisplayId() gets much simpler.
   if (0.5f <= ui_scale && ui_scale <= 2.0f)
     display_info_[display_id].set_configured_ui_scale(ui_scale);
   if (overscan_insets)
     display_info_[display_id].SetOverscanInsets(*overscan_insets);
   if (!resolution_in_pixels.IsEmpty()) {
     DCHECK(!display::Display::IsInternalDisplayId(display_id));
     // Default refresh rate, until OnNativeDisplaysChanged() updates us with the
     // actual display info, is 60 Hz.
-    DisplayMode mode(resolution_in_pixels, 60.0f, false, false);
-    mode.device_scale_factor = device_scale_factor;
+    scoped_refptr<DisplayMode> mode = new DisplayMode(
+        resolution_in_pixels, 60.0f, false, false, 1.0, device_scale_factor);
     display_modes_[display_id] = mode;
   }
 }
 
-DisplayMode DisplayManager::GetActiveModeForDisplayId(
+scoped_refptr<DisplayMode> DisplayManager::GetActiveModeForDisplayId(
     int64_t display_id) const {
-  DisplayMode selected_mode;
-  if (GetSelectedModeForDisplayId(display_id, &selected_mode))
+  scoped_refptr<DisplayMode> selected_mode(
+      GetSelectedModeForDisplayId(display_id));
+  if (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);
 
   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;
+      if (info.configured_ui_scale() == mode->ui_scale())
+        return mode.get();
+    } else if (mode->native()) {
+      return mode.get();
     }
   }
   return selected_mode;
 }
 
 void DisplayManager::RegisterDisplayRotationProperties(
     bool rotation_lock,
     display::Display::Rotation rotation) {
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   registered_internal_display_rotation_lock_ = rotation_lock;
   registered_internal_display_rotation_ = rotation;
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 }
 
-bool DisplayManager::GetSelectedModeForDisplayId(int64_t id,
-                                                 DisplayMode* mode_out) const {
-  std::map<int64_t, DisplayMode>::const_iterator iter = display_modes_.find(id);
+scoped_refptr<DisplayMode> DisplayManager::GetSelectedModeForDisplayId(
+    int64_t id) const {
+  std::map<int64_t, scoped_refptr<DisplayMode>>::const_iterator iter =
+      display_modes_.find(id);
   if (iter == display_modes_.end())
-    return false;
-  *mode_out = iter->second;
-  return true;
+    return scoped_refptr<DisplayMode>();
+  return iter->second;
 }
 
 bool DisplayManager::IsDisplayUIScalingEnabled() const {
   return GetDisplayIdForUIScaling() != display::Display::kInvalidDisplayID;
 }
 
 gfx::Insets DisplayManager::GetOverscanInsets(int64_t display_id) const {
   std::map<int64_t, DisplayInfo>::const_iterator it =
       display_info_.find(display_id);
   return (it != display_info_.end()) ? it->second.overscan_insets_in_dip()
@@ skipping 73 matching lines @@
     // Mirrored monitors have the same origins.
     gfx::Point origin = iter->bounds_in_native().origin();
     if (origins.find(origin) != origins.end()) {
       InsertAndUpdateDisplayInfo(*iter);
       mirroring_display_id_ = iter->id();
     } else {
       origins.insert(origin);
       new_display_info_list.push_back(*iter);
     }
 
-    DisplayMode new_mode;
-    new_mode.size = iter->bounds_in_native().size();
-    new_mode.device_scale_factor = iter->device_scale_factor();
-    new_mode.ui_scale = iter->configured_ui_scale();
-    const std::vector<DisplayMode>& display_modes = iter->display_modes();
+    scoped_refptr<DisplayMode> new_mode(
+        new DisplayMode(iter->bounds_in_native().size(),
+                        /* refresh rate */ 0.0,
+                        /* interlaced */ false,
+                        /* native */ false, iter->configured_ui_scale(),
+                        iter->device_scale_factor()));
+    const DisplayInfo::DisplayModeList& display_modes = iter->display_modes();
     // This is empty the displays are initialized from InitFromCommandLine.
     if (display_modes.empty())
       continue;
     auto display_modes_iter = FindDisplayMode(*iter, new_mode);
     // Update the actual resolution selected as the resolution request may fail.
     if (display_modes_iter == display_modes.end())
       display_modes_.erase(iter->id());
     else if (display_modes_.find(iter->id()) != display_modes_.end())
       display_modes_[iter->id()] = *display_modes_iter;
   }
@@ skipping 531 matching lines @@
       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 ||
             display::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;
+      DisplayInfo::DisplayModeList display_mode_list;
       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.
         display::Display display = CreateMirroringDisplayFromDisplayInfoById(
             info.id(), origin, 1.0f / scale);
         unified_bounds.Union(display.bounds());
 
         dsf_scale_list.insert(
             std::make_pair(info.device_scale_factor(), scale));
       }
 
       DisplayInfo info(kUnifiedDisplayId, "Unified Desktop", false);
 
-      DisplayMode native_mode(unified_bounds.size(), 60.0f, false, true);
-      std::vector<DisplayMode> modes =
+      scoped_refptr<DisplayMode> native_mode(
+          new DisplayMode(unified_bounds.size(), 60.0f, false, true, 1.0, 1.0));
+      DisplayInfo::DisplayModeList 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;
+          [default_height, default_device_scale_factor](
+              const scoped_refptr<DisplayMode>& mode) {
+            return mode->size().height() == default_height &&
+                   mode->device_scale_factor() == default_device_scale_factor;
           });
-      iter->native = true;
+
+      scoped_refptr<DisplayMode> dm(*iter);
+      *iter = make_scoped_refptr(new DisplayMode(
+          dm->size(), dm->refresh_rate(), dm->is_interlaced(),
+          /* native */ true, dm->ui_scale(), dm->device_scale_factor()));

[oshima, 2016/08/02 19:44:57]

nit:

true /* native */

is what I've been using and I believe it's a bit more common.
You may leave it if you prefer this way though.

[rjkroege, 2016/08/04 00:12:04]

Done.  (Hopefully everywhere.)

+
       info.SetDisplayModes(modes);
-      info.set_device_scale_factor(iter->device_scale_factor);
-      info.SetBounds(gfx::Rect(iter->size));
+      info.set_device_scale_factor(dm->device_scale_factor());
+      info.SetBounds(gfx::Rect(dm->size()));
 
       // Forget the configured resolution if the original unified
       // desktop resolution has changed.
       if (display_info_.count(kUnifiedDisplayId) != 0 &&
           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()) {
-        info.set_device_scale_factor(mode.device_scale_factor);
-        info.SetBounds(gfx::Rect(mode.size));
+      scoped_refptr<DisplayMode> mode =
+          GetSelectedModeForDisplayId(kUnifiedDisplayId);
+      if (mode && FindDisplayMode(info, mode) != info.display_modes().end()) {
+        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);
         display::Display display = CreateMirroringDisplayFromDisplayInfoById(
@@ skipping 12 matching lines @@
       break;
   }
 }
 
 display::Display* DisplayManager::FindDisplayForId(int64_t id) {
   auto iter = std::find_if(
       active_display_list_.begin(), active_display_list_.end(),
       [id](const display::Display& display) { return display.id() == id; });
   if (iter != active_display_list_.end())
     return &(*iter);
-  // TODO(oshima): This happens when a windows in unified desktop have
-  // been moved to normal window. Fix this.
+  // TODO(oshima): This happens when windows in unified desktop have
+  // been moved to a normal window. Fix this.
   if (id != kUnifiedDisplayId)
     DLOG(WARNING) << "Could not find display:" << id;
   return nullptr;
 }
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
   if (software_mirroring_enabled() && IsInMirrorMode()) {
     display_info_list->push_back(GetDisplayInfo(mirroring_display_id_));
     software_mirroring_display_list_.clear();
@@ skipping 110 matching lines @@
   layout.ApplyToDisplayList(display_list, updated_ids,
                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash