Move ash::DisplayInfo to ui

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/new_window_delegate.h"
 #include "ash/common/system/system_notifier.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/display_manager.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
+#include "ui/display/manager/managed_display_info.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_delegate.h"
 #include "ui/message_center/notification_list.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 30 matching lines @@
 // 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 scoped_refptr<ManagedDisplayMode>& native_mode) {
+    const scoped_refptr<display::ManagedDisplayMode>& 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) {
     ASSIGN_ARRAY(ret, kUIScalesFor2x);
     return ret;
   } else if (native_mode->device_scale_factor() == 1.25f) {
     ASSIGN_ARRAY(ret, kUIScalesFor1_25x);
     return ret;
   }
@@ skipping 10 matching lines @@
       if (base::SysInfo::IsRunningOnChromeOS())
         NOTREACHED() << "Unknown resolution:" << native_mode->size().ToString();
 #endif
   }
   return ret;
 }
 
 struct ScaleComparator {
   explicit ScaleComparator(float s) : scale(s) {}
 
-  bool operator()(const scoped_refptr<ManagedDisplayMode>& mode) const {
+  bool operator()(
+      const scoped_refptr<display::ManagedDisplayMode>& mode) const {
     const float kEpsilon = 0.0001f;
     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);
 }
 
-scoped_refptr<ManagedDisplayMode> GetDisplayModeForUIScale(
-    const DisplayInfo& info,
+scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForUIScale(
+    const display::ManagedDisplayInfo& info,
     float ui_scale) {
-  const DisplayInfo::ManagedDisplayModeList& modes = info.display_modes();
-  auto iter =
-      std::find_if(modes.begin(), modes.end(),
-                   [ui_scale](const scoped_refptr<ManagedDisplayMode>& mode) {
-                     return mode->ui_scale() == ui_scale;
-                   });
+  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
+      info.display_modes();
+  auto iter = std::find_if(
+      modes.begin(), modes.end(),
+      [ui_scale](const scoped_refptr<display::ManagedDisplayMode>& mode) {
+        return mode->ui_scale() == ui_scale;
+      });
   if (iter == modes.end())
-    return scoped_refptr<ManagedDisplayMode>();
+    return scoped_refptr<display::ManagedDisplayMode>();
   return *iter;
 }
 
-scoped_refptr<ManagedDisplayMode> FindNextMode(
-    const DisplayInfo::ManagedDisplayModeList& modes,
+scoped_refptr<display::ManagedDisplayMode> FindNextMode(
+    const display::ManagedDisplayInfo::ManagedDisplayModeList& 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
 
-DisplayInfo::ManagedDisplayModeList CreateInternalManagedDisplayModeList(
-    const scoped_refptr<ManagedDisplayMode>& native_mode) {
-  DisplayInfo::ManagedDisplayModeList display_mode_list;
+display::ManagedDisplayInfo::ManagedDisplayModeList
+CreateInternalManagedDisplayModeList(
+    const scoped_refptr<display::ManagedDisplayMode>& native_mode) {
+  display::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list;
 
   float native_ui_scale = (native_mode->device_scale_factor() == 1.25f)
                               ? 1.0f
                               : native_mode->device_scale_factor();
   for (float ui_scale : GetScalesForDisplay(native_mode)) {
-    scoped_refptr<ManagedDisplayMode> mode(new ManagedDisplayMode(
-        native_mode->size(), native_mode->refresh_rate(),
-        native_mode->is_interlaced(), ui_scale == native_ui_scale, ui_scale,
-        native_mode->device_scale_factor()));
+    scoped_refptr<display::ManagedDisplayMode> mode(
+        new display::ManagedDisplayMode(
+            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;
 }
 
-DisplayInfo::ManagedDisplayModeList CreateUnifiedManagedDisplayModeList(
-    const scoped_refptr<ManagedDisplayMode>& native_mode,
+display::ManagedDisplayInfo::ManagedDisplayModeList
+CreateUnifiedManagedDisplayModeList(
+    const scoped_refptr<display::ManagedDisplayMode>& native_mode,
     const std::set<std::pair<float, float>>& dsf_scale_list) {
-  DisplayInfo::ManagedDisplayModeList display_mode_list;
+  display::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list;
 
   for (auto& pair : dsf_scale_list) {
     gfx::SizeF scaled_size(native_mode->size());
     scaled_size.Scale(pair.second);
-    scoped_refptr<ManagedDisplayMode> mode(new ManagedDisplayMode(
-        gfx::ToFlooredSize(scaled_size), native_mode->refresh_rate(),
-        native_mode->is_interlaced(), false /* native */,
-        native_mode->ui_scale(), pair.first /* device_scale_factor */));
+    scoped_refptr<display::ManagedDisplayMode> mode(
+        new display::ManagedDisplayMode(
+            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 scoped_refptr<ManagedDisplayMode>& a,
-               const scoped_refptr<ManagedDisplayMode>& b) {
+            [](const scoped_refptr<display::ManagedDisplayMode>& a,
+               const scoped_refptr<display::ManagedDisplayMode>& b) {
               return a->GetSizeInDIP(false).GetArea() <
                      b->GetSizeInDIP(false).GetArea();
             });
   return display_mode_list;
 }
 
-scoped_refptr<ManagedDisplayMode> GetDisplayModeForResolution(
-    const DisplayInfo& info,
+scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForResolution(
+    const display::ManagedDisplayInfo& info,
     const gfx::Size& resolution) {
   if (display::Display::IsInternalDisplayId(info.id()))
-    return scoped_refptr<ManagedDisplayMode>();
+    return scoped_refptr<display::ManagedDisplayMode>();
 
-  const DisplayInfo::ManagedDisplayModeList& modes = info.display_modes();
+  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
+      info.display_modes();
   DCHECK_NE(0u, modes.size());
-  scoped_refptr<ManagedDisplayMode> target_mode;
-  DisplayInfo::ManagedDisplayModeList::const_iterator iter =
-      std::find_if(modes.begin(), modes.end(),
-                   [resolution](const scoped_refptr<ManagedDisplayMode>& mode) {
-                     return mode->size() == resolution;
-                   });
+  scoped_refptr<display::ManagedDisplayMode> target_mode;
+  display::ManagedDisplayInfo::ManagedDisplayModeList::const_iterator iter =
+      std::find_if(
+          modes.begin(), modes.end(),
+          [resolution](const scoped_refptr<display::ManagedDisplayMode>& mode) {
+            return mode->size() == resolution;
+          });
   if (iter == modes.end()) {
     LOG(WARNING) << "Unsupported resolution was requested:"
                  << resolution.ToString();
-    return scoped_refptr<ManagedDisplayMode>();
+    return scoped_refptr<display::ManagedDisplayMode>();
   }
   return *iter;
 }
 
-scoped_refptr<ManagedDisplayMode> GetDisplayModeForNextUIScale(
-    const DisplayInfo& info,
+scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForNextUIScale(
+    const display::ManagedDisplayInfo& info,
     bool up) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->IsActiveDisplayId(info.id()) ||
       !display::Display::IsInternalDisplayId(info.id())) {
-    return scoped_refptr<ManagedDisplayMode>();
+    return scoped_refptr<display::ManagedDisplayMode>();
   }
-  const DisplayInfo::ManagedDisplayModeList& modes = info.display_modes();
+  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
+      info.display_modes();
   ScaleComparator comparator(info.configured_ui_scale());
   auto iter = std::find_if(modes.begin(), modes.end(), comparator);
   return FindNextMode(modes, iter - modes.begin(), up);
 }
 
-scoped_refptr<ManagedDisplayMode> GetDisplayModeForNextResolution(
-    const DisplayInfo& info,
+scoped_refptr<display::ManagedDisplayMode> GetDisplayModeForNextResolution(
+    const display::ManagedDisplayInfo& info,
     bool up) {
   if (display::Display::IsInternalDisplayId(info.id()))
-    return scoped_refptr<ManagedDisplayMode>();
+    return scoped_refptr<display::ManagedDisplayMode>();
 
-  const DisplayInfo::ManagedDisplayModeList& modes = info.display_modes();
-  scoped_refptr<ManagedDisplayMode> tmp = new ManagedDisplayMode(
-      info.size_in_pixel(), 0.0, false, false, 1.0, info.device_scale_factor());
+  const display::ManagedDisplayInfo::ManagedDisplayModeList& modes =
+      info.display_modes();
+  scoped_refptr<display::ManagedDisplayMode> tmp =
+      new display::ManagedDisplayMode(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<ManagedDisplayMode>& mode) {
-                     return mode->GetSizeInDIP(false) == resolution;
-                   });
+  auto iter = std::find_if(
+      modes.begin(), modes.end(),
+      [resolution](const scoped_refptr<display::ManagedDisplayMode>& 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);
+  const display::ManagedDisplayInfo& info = display_manager->GetDisplayInfo(id);
 
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       GetDisplayModeForUIScale(info, ui_scale);
   if (!mode)
     return false;
   return display_manager->SetDisplayMode(id, mode);
 }
 
-bool HasDisplayModeForUIScale(const DisplayInfo& info, float ui_scale) {
+bool HasDisplayModeForUIScale(const display::ManagedDisplayInfo& info,
+                              float ui_scale) {
   ScaleComparator comparator(ui_scale);
-  const DisplayInfo::ManagedDisplayModeList& modes = info.display_modes();
+  const display::ManagedDisplayInfo::ManagedDisplayModeList& 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