Make ash::DisplayMode more like ui::DisplayMode

ash/display/display_change_observer_chromeos.cc

Index: ash/display/display_change_observer_chromeos.cc
diff --git a/ash/display/display_change_observer_chromeos.cc b/ash/display/display_change_observer_chromeos.cc
index a6521ef99618ca4b8af18694b89e59062c76abb2..401456613a7294487757b017bb54114feecc43d5 100644
--- a/ash/display/display_change_observer_chromeos.cc
+++ b/ash/display/display_change_observer_chromeos.cc
@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "ash/common/ash_switches.h"
-#include "ash/common/display/display_info.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
@@ -76,32 +75,34 @@ void UpdateInternalDisplayId(
 }  // namespace
 
 // static
-std::vector<DisplayMode> DisplayChangeObserver::GetInternalDisplayModeList(
+DisplayInfo::DisplayModeList DisplayChangeObserver::GetInternalDisplayModeList(
     const DisplayInfo& display_info,
     const ui::DisplaySnapshot& output) {
   const ui::DisplayMode* ui_native_mode = output.native_mode();
-  DisplayMode native_mode(ui_native_mode->size(),
-                          ui_native_mode->refresh_rate(),
-                          ui_native_mode->is_interlaced(), true);
-  native_mode.device_scale_factor = display_info.device_scale_factor();
+  scoped_refptr<DisplayMode> native_mode =
+      new DisplayMode(ui_native_mode->size(), ui_native_mode->refresh_rate(),
+                      ui_native_mode->is_interlaced(), true, 1.0,
+                      display_info.device_scale_factor());
 
   return CreateInternalDisplayModeList(native_mode);
 }
 
 // static
-std::vector<DisplayMode> DisplayChangeObserver::GetExternalDisplayModeList(
+DisplayInfo::DisplayModeList DisplayChangeObserver::GetExternalDisplayModeList(
     const ui::DisplaySnapshot& output) {
-  typedef std::map<std::pair<int, int>, DisplayMode> DisplayModeMap;
+  using DisplayModeMap =
+      std::map<std::pair<int, int>, scoped_refptr<DisplayMode>>;
   DisplayModeMap display_mode_map;
 
-  DisplayMode native_mode;
+  scoped_refptr<DisplayMode> native_mode = new DisplayMode();
   for (const auto& mode_info : output.modes()) {
     const std::pair<int, int> size(mode_info->size().width(),
                                    mode_info->size().height());
-    const DisplayMode display_mode(mode_info->size(), mode_info->refresh_rate(),
-                                   mode_info->is_interlaced(),
-                                   output.native_mode() == mode_info.get());
-    if (display_mode.native)
+    scoped_refptr<DisplayMode> display_mode =
+        new DisplayMode(mode_info->size(), mode_info->refresh_rate(),
+                        mode_info->is_interlaced(),
+                        output.native_mode() == mode_info.get(), 1.0, 1.0);
+    if (display_mode->native())
       native_mode = display_mode;
 
     // Add the display mode if it isn't already present and override interlaced
@@ -109,31 +110,33 @@ std::vector<DisplayMode> DisplayChangeObserver::GetExternalDisplayModeList(
     DisplayModeMap::iterator display_mode_it = display_mode_map.find(size);
     if (display_mode_it == display_mode_map.end())
       display_mode_map.insert(std::make_pair(size, display_mode));
-    else if (display_mode_it->second.interlaced && !display_mode.interlaced)
-      display_mode_it->second = display_mode;
+    else if (display_mode_it->second->is_interlaced() &&
+             !display_mode->is_interlaced())
+      display_mode_it->second = std::move(display_mode);
   }
 
-  std::vector<DisplayMode> display_mode_list;
+  DisplayInfo::DisplayModeList display_mode_list;
   for (const auto& display_mode_pair : display_mode_map)
-    display_mode_list.push_back(display_mode_pair.second);
+    display_mode_list.push_back(std::move(display_mode_pair.second));
 
   if (output.native_mode()) {
-    const std::pair<int, int> size(native_mode.size.width(),
-                                   native_mode.size.height());
+    const std::pair<int, int> size(native_mode->size().width(),
+                                   native_mode->size().height());
     DisplayModeMap::iterator it = display_mode_map.find(size);
     DCHECK(it != display_mode_map.end())
         << "Native mode must be part of the mode list.";
 
     // If the native mode was replaced re-add it.
-    if (!it->second.native)
+    if (!it->second->native())
       display_mode_list.push_back(native_mode);
   }
 
-  if (native_mode.size.width() >= kMinimumWidthFor4K) {
+  if (native_mode->size().width() >= kMinimumWidthFor4K) {
     for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k); ++i) {
-      DisplayMode mode = native_mode;
-      mode.device_scale_factor = kAdditionalDeviceScaleFactorsFor4k[i];
-      mode.native = false;
+      scoped_refptr<DisplayMode> mode = new DisplayMode(
+          native_mode->size(), native_mode->refresh_rate(),
+          native_mode->is_interlaced(), false /* native */,
+          native_mode->ui_scale(), kAdditionalDeviceScaleFactorsFor4k[i]);
       display_mode_list.push_back(mode);
     }
   }
@@ -172,12 +175,12 @@ ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds(
 
 bool DisplayChangeObserver::GetResolutionForDisplayId(int64_t display_id,
                                                       gfx::Size* size) const {
-  DisplayMode mode;
-  if (!Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
-          display_id, &mode))
+  scoped_refptr<DisplayMode> mode =
+      Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
+          display_id);
+  if (!mode)
     return false;
-
-  *size = mode.size;
+  *size = mode->size();
   return true;
 }
 
@@ -202,10 +205,11 @@ void DisplayChangeObserver::OnDisplayModeChanged(
       if (dpi)
         device_scale_factor = FindDeviceScaleFactor(dpi);
     } else {
-      DisplayMode mode;
-      if (Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
-              state->display_id(), &mode)) {
-        device_scale_factor = mode.device_scale_factor;
+      scoped_refptr<DisplayMode> mode =
+          Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
+              state->display_id());
+      if (mode) {
+        device_scale_factor = mode->device_scale_factor();
       } else {
         // For monitors that are 40 inches and 4K or above, set
         // |device_scale_factor| to 2x. For margin purposes, 100 is subtracted
@@ -254,7 +258,7 @@ void DisplayChangeObserver::OnDisplayModeChanged(
     if (dpi)
       new_info.set_device_dpi(dpi);
 
-    std::vector<DisplayMode> display_modes =
+    DisplayInfo::DisplayModeList display_modes =
         (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
             ? GetInternalDisplayModeList(new_info, *state)
             : GetExternalDisplayModeList(*state);