Make ash::DisplayMode more like ui::DisplayMode

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/common/display/display_info.h"
 #include "ash/common/system/system_notifier.h"
@@ skipping 50 matching lines @@
 // List of value UI Scale values. Scales for 2x are equivalent to 640,
 // 800, 1024, 1280, 1440, 1600 and 1920 pixel width respectively on
 // 2560 pixel width 2x density display. Please see crbug.com/233375
 // for the full list of resolutions.
 const float kUIScalesFor2x[] = {0.5f,   0.625f, 0.8f, 1.0f,
                                 1.125f, 1.25f,  1.5f, 2.0f};
 const float kUIScalesFor1_25x[] = {0.5f, 0.625f, 0.8f, 1.0f, 1.25f};
 const float kUIScalesFor1280[] = {0.5f, 0.625f, 0.8f, 1.0f, 1.125f};
 const float kUIScalesFor1366[] = {0.5f, 0.6f, 0.75f, 1.0f, 1.125f};
 
-std::vector<float> GetScalesForDisplay(const DisplayMode& native_mode) {
+std::vector<float> GetScalesForDisplay(
+    const scoped_refptr<DisplayMode>& native_mode) {
 #define ASSIGN_ARRAY(v, a) v.assign(a, a + arraysize(a))
 
   std::vector<float> ret;
-  if (native_mode.device_scale_factor == 2.0f) {
+  if (native_mode->device_scale_factor() == 2.0f) {
     ASSIGN_ARRAY(ret, kUIScalesFor2x);
     return ret;
-  } else if (native_mode.device_scale_factor == 1.25f) {
+  } else if (native_mode->device_scale_factor() == 1.25f) {
     ASSIGN_ARRAY(ret, kUIScalesFor1_25x);
     return ret;
   }
-  switch (native_mode.size.width()) {
+  switch (native_mode->size().width()) {
     case 1280:
       ASSIGN_ARRAY(ret, kUIScalesFor1280);
       break;
     case 1366:
       ASSIGN_ARRAY(ret, kUIScalesFor1366);
       break;
     default:
       ASSIGN_ARRAY(ret, kUIScalesFor1280);
 #if defined(OS_CHROMEOS)
       if (base::SysInfo::IsRunningOnChromeOS())
-        NOTREACHED() << "Unknown resolution:" << native_mode.size.ToString();
+        NOTREACHED() << "Unknown resolution:" << native_mode->size().ToString();
 #endif
   }
   return ret;
 }
 
 struct ScaleComparator {
   explicit ScaleComparator(float s) : scale(s) {}
 
-  bool operator()(const DisplayMode& mode) const {
+  bool operator()(const scoped_refptr<DisplayMode>& mode) const {
     const float kEpsilon = 0.0001f;
-    return std::abs(scale - mode.ui_scale) < kEpsilon;
+    return std::abs(scale - mode->ui_scale()) < kEpsilon;
   }
   float scale;
 };
 
 void ConvertPointFromScreenToNative(aura::WindowTreeHost* host,
                                     gfx::Point* point) {
   ::wm::ConvertPointFromScreen(host->window(), point);
   host->ConvertPointToNativeScreen(point);
 }
 
-bool GetDisplayModeForUIScale(const DisplayInfo& info,
-                              float ui_scale,
-                              DisplayMode* out) {
-  const std::vector<DisplayMode>& modes = info.display_modes();
+scoped_refptr<DisplayMode> GetDisplayModeForUIScale(const DisplayInfo& info,
+                                                    float ui_scale) {
+  const DisplayInfo::DisplayModeList& modes = info.display_modes();
   auto iter = std::find_if(modes.begin(), modes.end(),
-                           [ui_scale](const DisplayMode& mode) {
-                             return mode.ui_scale == ui_scale;
+                           [ui_scale](const scoped_refptr<DisplayMode>& mode) {
+                             return mode->ui_scale() == ui_scale;
                            });
   if (iter == modes.end())
-    return false;
-  *out = *iter;
-  return true;
+    return scoped_refptr<DisplayMode>();
+  return *iter;
 }
 
-DisplayMode FindNextMode(const std::vector<DisplayMode>& modes,
-                         size_t index,
-                         bool up) {
+scoped_refptr<DisplayMode>
+FindNextMode(const DisplayInfo::DisplayModeList& modes, size_t index, bool up) {
   DCHECK_LT(index, modes.size());
   size_t new_index = index;
   if (up && (index + 1 < modes.size()))
     ++new_index;
   else if (!up && index != 0)
     --new_index;
   return modes[new_index];
 }
 
 }  // namespace
 
-std::vector<DisplayMode> CreateInternalDisplayModeList(
-    const DisplayMode& native_mode) {
-  std::vector<DisplayMode> display_mode_list;
+DisplayInfo::DisplayModeList CreateInternalDisplayModeList(
+    const scoped_refptr<DisplayMode>& native_mode) {
+  DisplayInfo::DisplayModeList display_mode_list;
 
-  float native_ui_scale = (native_mode.device_scale_factor == 1.25f)
+  float native_ui_scale = (native_mode->device_scale_factor() == 1.25f)
                               ? 1.0f
-                              : native_mode.device_scale_factor;
+                              : native_mode->device_scale_factor();
   for (float ui_scale : GetScalesForDisplay(native_mode)) {
-    DisplayMode mode = native_mode;
-    mode.ui_scale = ui_scale;
-    mode.native = (ui_scale == native_ui_scale);
+    scoped_refptr<DisplayMode> mode(new DisplayMode(
+        native_mode->size(), native_mode->refresh_rate(),
+        native_mode->is_interlaced(), ui_scale == native_ui_scale, ui_scale,
+        native_mode->device_scale_factor()));
     display_mode_list.push_back(mode);
   }
   return display_mode_list;
 }
 
-std::vector<DisplayMode> CreateUnifiedDisplayModeList(
-    const DisplayMode& native_mode,
+DisplayInfo::DisplayModeList CreateUnifiedDisplayModeList(
+    const scoped_refptr<DisplayMode>& native_mode,
     const std::set<std::pair<float, float>>& dsf_scale_list) {
-  std::vector<DisplayMode> display_mode_list;
+  DisplayInfo::DisplayModeList display_mode_list;
 
   for (auto& pair : dsf_scale_list) {
-    DisplayMode mode = native_mode;
-    mode.device_scale_factor = pair.first;
-    gfx::SizeF scaled_size(native_mode.size);
+    gfx::SizeF scaled_size(native_mode->size());
     scaled_size.Scale(pair.second);
-    mode.size = gfx::ToFlooredSize(scaled_size);
-    mode.native = false;
+    scoped_refptr<DisplayMode> mode(new DisplayMode(
+        gfx::ToFlooredSize(scaled_size), native_mode->refresh_rate(),
+        native_mode->is_interlaced(), false /* native */,
+        native_mode->ui_scale(), pair.first /* device_scale_factor */));
     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();
+            [](const scoped_refptr<DisplayMode>& a,
+               const scoped_refptr<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) {
+scoped_refptr<DisplayMode> GetDisplayModeForResolution(
+    const DisplayInfo& info,
+    const gfx::Size& resolution) {
   if (display::Display::IsInternalDisplayId(info.id()))
-    return false;
+    return scoped_refptr<DisplayMode>();
 
-  const std::vector<DisplayMode>& modes = info.display_modes();
+  const DisplayInfo::DisplayModeList& modes = info.display_modes();
   DCHECK_NE(0u, modes.size());
-  DisplayMode target_mode;
-  target_mode.size = resolution;
-  std::vector<DisplayMode>::const_iterator iter = std::find_if(
-      modes.begin(), modes.end(), [resolution](const DisplayMode& mode) {
-        return mode.size == resolution;
-      });
+  scoped_refptr<DisplayMode> target_mode;
+  DisplayInfo::DisplayModeList::const_iterator iter =
+      std::find_if(modes.begin(), modes.end(),
+                   [resolution](const scoped_refptr<DisplayMode>& mode) {
+                     return mode->size() == resolution;
+                   });
   if (iter == modes.end()) {
     LOG(WARNING) << "Unsupported resolution was requested:"
                  << resolution.ToString();
-    return false;
+    return scoped_refptr<DisplayMode>();
   }
-  *out = *iter;
-  return true;
+  return *iter;
 }
 
-bool GetDisplayModeForNextUIScale(const DisplayInfo& info,
-                                  bool up,
-                                  DisplayMode* out) {
+scoped_refptr<DisplayMode> GetDisplayModeForNextUIScale(const DisplayInfo& info,
+                                                        bool up) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->IsActiveDisplayId(info.id()) ||
       !display::Display::IsInternalDisplayId(info.id())) {
-    return false;
+    return scoped_refptr<DisplayMode>();
   }
-  const std::vector<DisplayMode>& modes = info.display_modes();
+  const DisplayInfo::DisplayModeList& modes = info.display_modes();
   ScaleComparator comparator(info.configured_ui_scale());
   auto iter = std::find_if(modes.begin(), modes.end(), comparator);
-  *out = FindNextMode(modes, iter - modes.begin(), up);
-  return true;
+  return FindNextMode(modes, iter - modes.begin(), up);
 }
 
-bool GetDisplayModeForNextResolution(const DisplayInfo& info,
-                                     bool up,
-                                     DisplayMode* out) {
+scoped_refptr<DisplayMode> GetDisplayModeForNextResolution(
+    const DisplayInfo& info,
+    bool up) {
   if (display::Display::IsInternalDisplayId(info.id()))
-    return false;
-  const std::vector<DisplayMode>& modes = info.display_modes();
-  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.GetSizeInDIP(false) == resolution;
-                           });
-  *out = FindNextMode(modes, iter - modes.begin(), up);
-  return true;
+    return scoped_refptr<DisplayMode>();
+
+  const DisplayInfo::DisplayModeList& modes = info.display_modes();
+  scoped_refptr<DisplayMode> tmp = new DisplayMode(
+      info.size_in_pixel(), 0.0, false, false, 1.0, info.device_scale_factor());
+  gfx::Size resolution = tmp->GetSizeInDIP(false);
+
+  auto iter =
+      std::find_if(modes.begin(), modes.end(),
+                   [resolution](const scoped_refptr<DisplayMode>& mode) {
+                     return mode->GetSizeInDIP(false) == resolution;
+                   });
+  return FindNextMode(modes, iter - modes.begin(), up);
 }
 
 bool SetDisplayUIScale(int64_t id, float ui_scale) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->IsActiveDisplayId(id) ||
       !display::Display::IsInternalDisplayId(id)) {
     return false;
   }
   const DisplayInfo& info = display_manager->GetDisplayInfo(id);
-  DisplayMode mode;
-  if (!GetDisplayModeForUIScale(info, ui_scale, &mode))
+
+  scoped_refptr<DisplayMode> mode = GetDisplayModeForUIScale(info, ui_scale);
+  if (!mode)
     return false;
   return display_manager->SetDisplayMode(id, mode);
 }
 
 bool HasDisplayModeForUIScale(const DisplayInfo& info, float ui_scale) {
   ScaleComparator comparator(ui_scale);
-  const std::vector<DisplayMode>& modes = info.display_modes();
+  const DisplayInfo::DisplayModeList& modes = info.display_modes();
   return std::find_if(modes.begin(), modes.end(), comparator) != modes.end();
 }
 
 bool ComputeBoundary(const display::Display& a_display,
                      const display::Display& b_display,
                      gfx::Rect* a_edge_in_screen,
                      gfx::Rect* b_edge_in_screen) {
   const gfx::Rect& a_bounds = a_display.bounds();
   const gfx::Rect& b_bounds = b_display.bounds();
 
@@ skipping 204 matching lines @@
   message_center::NotificationList::Notifications notifications =
       message_center::MessageCenter::Get()->GetVisibleNotifications();
   for (auto* const notification : notifications) {
     if (notification->id() == kDisplayErrorNotificationId)
       return notification->message();
   }
   return base::string16();
 }
 
 }  // namespace ash