Move ash::DisplayInfo to ui

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_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"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/display/display.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/manager/display_layout_store.h"
+#include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"  // nogncheck
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace ash {
-typedef std::vector<DisplayInfo> DisplayInfoList;
 
 namespace {
 
 // We need to keep this in order for unittests to tell if
 // the object in display::Screen::GetScreenByType is for shutdown.
 display::Screen* screen_for_shutdown = nullptr;
 
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 100;
 
 struct DisplaySortFunctor {
   bool operator()(const display::Display& a, const display::Display& b) {
     return CompareDisplayIds(a.id(), b.id());
   }
 };
 
 struct DisplayInfoSortFunctor {
-  bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
+  bool operator()(const ui::ManagedDisplayInfo& a,
+                  const ui::ManagedDisplayInfo& b) {
     return CompareDisplayIds(a.id(), b.id());
   }
 };
 
 display::Display& GetInvalidDisplay() {
   static display::Display* invalid_display = new display::Display();
   return *invalid_display;
 }
 
-DisplayInfo::ManagedDisplayModeList::const_iterator FindDisplayMode(
-    const DisplayInfo& info,
-    const scoped_refptr<ManagedDisplayMode>& target_mode) {
-  const DisplayInfo::ManagedDisplayModeList& modes = info.display_modes();
+ui::ManagedDisplayInfo::ManagedDisplayModeList::const_iterator FindDisplayMode(
+    const ui::ManagedDisplayInfo& info,
+    const scoped_refptr<ui::ManagedDisplayMode>& target_mode) {
+  const ui::ManagedDisplayInfo::ManagedDisplayModeList& modes =
+      info.display_modes();
   return std::find_if(
       modes.begin(), modes.end(),
-      [target_mode](const scoped_refptr<ManagedDisplayMode>& mode) {
+      [target_mode](const scoped_refptr<ui::ManagedDisplayMode>& mode) {
         return target_mode->IsEquivalent(mode);
       });
 }
 
-void SetInternalManagedDisplayModeList(DisplayInfo* info) {
-  scoped_refptr<ManagedDisplayMode> native_mode = new ManagedDisplayMode(
-      info->bounds_in_native().size(), 0.0 /* refresh_rate */,
-      false /* interlaced */, false /* native_mode */, 1.0 /* ui_scale */,
-      info->device_scale_factor());
+void SetInternalManagedDisplayModeList(ui::ManagedDisplayInfo* info) {
+  scoped_refptr<ui::ManagedDisplayMode> native_mode =
+      new ui::ManagedDisplayMode(info->bounds_in_native().size(),
+                                 0.0 /* refresh_rate */, false /* interlaced */,
+                                 false /* native_mode */, 1.0 /* ui_scale */,
+                                 info->device_scale_factor());
   info->SetManagedDisplayModes(
       CreateInternalManagedDisplayModeList(native_mode));
 }
 
-void MaybeInitInternalDisplay(DisplayInfo* info) {
+void MaybeInitInternalDisplay(ui::ManagedDisplayInfo* info) {
   int64_t id = info->id();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal)) {
     display::Display::SetInternalDisplayId(id);
     SetInternalManagedDisplayModeList(info);
   }
 }
 
-gfx::Size GetMaxNativeSize(const DisplayInfo& info) {
+gfx::Size GetMaxNativeSize(const ui::ManagedDisplayInfo& info) {
   gfx::Size size;
   for (auto& mode : info.display_modes()) {
     if (mode->size().GetArea() > size.GetArea())
       size = mode->size();
   }
   return size;
 }
 
 }  // namespace
 
@@ skipping 39 matching lines @@
 
 bool DisplayManager::InitFromCommandLine() {
   DisplayInfoList info_list;
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kAshHostWindowBounds))
     return false;
   const string size_str =
       command_line->GetSwitchValueASCII(switches::kAshHostWindowBounds);
   for (const std::string& part : base::SplitString(
            size_str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-    info_list.push_back(DisplayInfo::CreateFromSpec(part));
+    info_list.push_back(ui::ManagedDisplayInfo::CreateFromSpec(part));
     info_list.back().set_native(true);
   }
   MaybeInitInternalDisplay(&info_list[0]);
   if (info_list.size() > 1 &&
       command_line->HasSwitch(switches::kAshEnableSoftwareMirroring)) {
     SetMultiDisplayMode(MIRRORING);
   }
   OnNativeDisplaysChanged(info_list);
   return true;
 }
 
 void DisplayManager::InitDefaultDisplay() {
   DisplayInfoList info_list;
-  info_list.push_back(DisplayInfo::CreateFromSpec(std::string()));
+  info_list.push_back(ui::ManagedDisplayInfo::CreateFromSpec(std::string()));
   info_list.back().set_native(true);
   MaybeInitInternalDisplay(&info_list[0]);
   OnNativeDisplaysChanged(info_list);
 }
 
 void DisplayManager::RefreshFontParams() {
 #if defined(OS_CHROMEOS)
   // Use the largest device scale factor among currently active displays. Non
   // internal display may have bigger scale factor in case the external display
   // is an 4K display.
   float largest_device_scale_factor = 1.0f;
   for (const display::Display& display : active_display_list_) {
-    const ash::DisplayInfo& info = display_info_[display.id()];
+    const ui::ManagedDisplayInfo& info = display_info_[display.id()];
     largest_device_scale_factor = std::max(
         largest_device_scale_factor, info.GetEffectiveDeviceScaleFactor());
   }
   gfx::SetFontRenderParamsDeviceScaleFactor(largest_device_scale_factor);
 #endif  // OS_CHROMEOS
 }
 
 const display::DisplayLayout& DisplayManager::GetCurrentDisplayLayout() const {
   DCHECK_LE(2U, num_connected_displays());
   if (num_connected_displays() > 1) {
@@ skipping 83 matching lines @@
         *display, display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   }
   return workarea_changed;
 }
 
 void DisplayManager::SetOverscanInsets(int64_t display_id,
                                        const gfx::Insets& insets_in_dip) {
   bool update = false;
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_) {
-    DisplayInfo info = GetDisplayInfo(display.id());
+    ui::ManagedDisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       if (insets_in_dip.IsEmpty()) {
         info.set_clear_overscan_insets(true);
       } else {
         info.set_clear_overscan_insets(false);
         info.SetOverscanInsets(insets_in_dip);
       }
       update = true;
     }
     display_info_list.push_back(info);
   }
   if (update) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
     UpdateDisplaysWith(display_info_list);
   } else {
     display_info_[display_id].SetOverscanInsets(insets_in_dip);
   }
 }
 
 void DisplayManager::SetDisplayRotation(
     int64_t display_id,
     display::Display::Rotation rotation,
     display::Display::RotationSource source) {
   if (IsInUnifiedMode())
     return;
 
   DisplayInfoList display_info_list;
   bool is_active = false;
   for (const auto& display : active_display_list_) {
-    DisplayInfo info = GetDisplayInfo(display.id());
+    ui::ManagedDisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       if (info.GetRotation(source) == rotation &&
           info.GetActiveRotation() == rotation) {
         return;
       }
       info.SetRotation(rotation, source);
       is_active = true;
     }
     display_info_list.push_back(info);
   }
   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 scoped_refptr<ManagedDisplayMode>& display_mode) {
+    const scoped_refptr<ui::ManagedDisplayMode>& 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());
+    ui::ManagedDisplayInfo 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 factor="
                      << display_mode->device_scale_factor();
         return false;
       }
@@ skipping 31 matching lines @@
 
 void DisplayManager::RegisterDisplayProperty(
     int64_t display_id,
     display::Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets,
     const gfx::Size& resolution_in_pixels,
     float device_scale_factor,
     ui::ColorCalibrationProfile color_profile) {
   if (display_info_.find(display_id) == display_info_.end())
-    display_info_[display_id] = DisplayInfo(display_id, std::string(), false);
+    display_info_[display_id] =
+        ui::ManagedDisplayInfo(display_id, std::string(), false);
 
   // Do not allow rotation in unified desktop mode.
   if (display_id == kUnifiedDisplayId)
     rotation = display::Display::ROTATE_0;
 
   display_info_[display_id].SetRotation(rotation,
                                         display::Display::ROTATION_SOURCE_USER);
   display_info_[display_id].SetRotation(
       rotation, display::Display::ROTATION_SOURCE_ACTIVE);
   display_info_[display_id].SetColorProfile(color_profile);
   // Just in case the preference file was corrupted.
   // 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.
-    scoped_refptr<ManagedDisplayMode> mode = new ManagedDisplayMode(
+    scoped_refptr<ui::ManagedDisplayMode> mode = new ui::ManagedDisplayMode(
         resolution_in_pixels, 60.0f, false, false, 1.0, device_scale_factor);
     display_modes_[display_id] = mode;
   }
 }
 
-scoped_refptr<ManagedDisplayMode> DisplayManager::GetActiveModeForDisplayId(
+scoped_refptr<ui::ManagedDisplayMode> DisplayManager::GetActiveModeForDisplayId(
     int64_t display_id) const {
-  scoped_refptr<ManagedDisplayMode> selected_mode(
+  scoped_refptr<ui::ManagedDisplayMode> 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);
+  const ui::ManagedDisplayInfo& info = GetDisplayInfo(display_id);
 
   for (auto& mode : info.display_modes()) {
     if (GetDisplayIdForUIScaling() == display_id) {
       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();
 }
 
-scoped_refptr<ManagedDisplayMode> DisplayManager::GetSelectedModeForDisplayId(
-    int64_t id) const {
-  std::map<int64_t, scoped_refptr<ManagedDisplayMode>>::const_iterator iter =
-      display_modes_.find(id);
+scoped_refptr<ui::ManagedDisplayMode>
+DisplayManager::GetSelectedModeForDisplayId(int64_t id) const {
+  std::map<int64_t, scoped_refptr<ui::ManagedDisplayMode>>::const_iterator
+      iter = display_modes_.find(id);
   if (iter == display_modes_.end())
-    return scoped_refptr<ManagedDisplayMode>();
+    return scoped_refptr<ui::ManagedDisplayMode>();
   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 =
+  std::map<int64_t, ui::ManagedDisplayInfo>::const_iterator it =
       display_info_.find(display_id);
   return (it != display_info_.end()) ? it->second.overscan_insets_in_dip()
                                      : gfx::Insets();
 }
 
 void DisplayManager::SetColorCalibrationProfile(
     int64_t display_id,
     ui::ColorCalibrationProfile profile) {
 #if defined(OS_CHROMEOS)
   if (!display_info_[display_id].IsColorProfileAvailable(profile))
     return;
 
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   // Just sets color profile if it's not running on ChromeOS (like tests).
   if (!base::SysInfo::IsRunningOnChromeOS() ||
       Shell::GetInstance()->display_configurator()->SetColorCalibrationProfile(
           display_id, profile)) {
     display_info_[display_id].SetColorProfile(profile);
     UMA_HISTOGRAM_ENUMERATION("ChromeOS.Display.ColorProfile", profile,
                               ui::NUM_COLOR_PROFILES);
   }
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 #endif
 }
 
 void DisplayManager::OnNativeDisplaysChanged(
-    const std::vector<DisplayInfo>& updated_displays) {
+    const DisplayInfoList& updated_displays) {
   if (updated_displays.empty()) {
     VLOG(1) << "OnNativeDisplaysChanged(0): # of current displays="
             << active_display_list_.size();
     // If the device is booted without display, or chrome is started
     // without --ash-host-window-bounds on linux desktop, use the
     // default display.
     if (active_display_list_.empty()) {
-      std::vector<DisplayInfo> init_displays;
-      init_displays.push_back(DisplayInfo::CreateFromSpec(std::string()));
+      DisplayInfoList init_displays;
+      init_displays.push_back(
+          ui::ManagedDisplayInfo::CreateFromSpec(std::string()));
       MaybeInitInternalDisplay(&init_displays[0]);
       OnNativeDisplaysChanged(init_displays);
     } else {
       // Otherwise don't update the displays when all displays are disconnected.
       // This happens when:
       // - the device is idle and powerd requested to turn off all displays.
       // - the device is suspended. (kernel turns off all displays)
       // - the internal display's brightness is set to 0 and no external
       //   display is connected.
       // - the internal display's brightness is 0 and external display is
@@ skipping 27 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);
     }
 
-    scoped_refptr<ManagedDisplayMode> new_mode(new ManagedDisplayMode(
+    scoped_refptr<ui::ManagedDisplayMode> new_mode(new ui::ManagedDisplayMode(
         iter->bounds_in_native().size(), 0.0 /* refresh rate */,
         false /* interlaced */, false /* native */, iter->configured_ui_scale(),
         iter->device_scale_factor()));
-    const DisplayInfo::ManagedDisplayModeList& display_modes =
+    const ui::ManagedDisplayInfo::ManagedDisplayModeList& 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;
   }
   if (display::Display::HasInternalDisplay() && !internal_display_connected) {
     if (display_info_.find(display::Display::InternalDisplayId()) ==
         display_info_.end()) {
       // Create a dummy internal display if the chrome restarted
       // in docked mode.
-      DisplayInfo internal_display_info(
+      ui::ManagedDisplayInfo internal_display_info(
           display::Display::InternalDisplayId(),
           l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME),
           false /*Internal display must not have overscan */);
       internal_display_info.SetBounds(gfx::Rect(0, 0, 800, 600));
       display_info_[display::Display::InternalDisplayId()] =
           internal_display_info;
     } else {
       // Internal display is no longer active. Reset its rotation to user
       // preference, so that it is restored when the internal display becomes
       // active again.
       display::Display::Rotation user_rotation =
           display_info_[display::Display::InternalDisplayId()].GetRotation(
               display::Display::ROTATION_SOURCE_USER);
       display_info_[display::Display::InternalDisplayId()].SetRotation(
           user_rotation, display::Display::ROTATION_SOURCE_USER);
     }
   }
 
 #if defined(OS_CHROMEOS)
   if (!base::SysInfo::IsRunningOnChromeOS() &&
       new_display_info_list.size() > 1) {
     display::DisplayIdList list = GenerateDisplayIdList(
         new_display_info_list.begin(), new_display_info_list.end(),
-        [](const DisplayInfo& info) { return info.id(); });
+        [](const ui::ManagedDisplayInfo& info) { return info.id(); });
 
     const display::DisplayLayout& layout =
         layout_store_->GetRegisteredDisplayLayout(list);
     // Mirror mode is set by DisplayConfigurator on the device.
     // Emulate it when running on linux desktop.
     if (layout.mirrored)
       SetMultiDisplayMode(MIRRORING);
   }
 #endif
 
   UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::UpdateDisplays() {
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_)
     display_info_list.push_back(GetDisplayInfo(display.id()));
   AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplaysWith(display_info_list);
 }
 
 void DisplayManager::UpdateDisplaysWith(
-    const std::vector<DisplayInfo>& updated_display_info_list) {
+    const DisplayInfoList& updated_display_info_list) {
 #if defined(OS_WIN)
   DCHECK_EQ(1u, updated_display_info_list.size())
       << ": Multiple display test does not work on Windows bots. Please "
          "skip (don't disable) the test using SupportsMultipleDisplays()";
 #endif
 
   DisplayInfoList new_display_info_list = updated_display_info_list;
   std::sort(active_display_list_.begin(), active_display_list_.end(),
             DisplaySortFunctor());
   std::sort(new_display_info_list.begin(), new_display_info_list.end(),
             DisplayInfoSortFunctor());
 
   if (new_display_info_list.size() > 1) {
     display::DisplayIdList list = GenerateDisplayIdList(
         new_display_info_list.begin(), new_display_info_list.end(),
-        [](const DisplayInfo& info) { return info.id(); });
+        [](const ui::ManagedDisplayInfo& info) { return info.id(); });
     const display::DisplayLayout& layout =
         layout_store_->GetRegisteredDisplayLayout(list);
     current_default_multi_display_mode_ =
         (layout.default_unified && unified_desktop_enabled_) ? UNIFIED
                                                              : EXTENDED;
   }
 
   if (multi_display_mode_ != MIRRORING)
     multi_display_mode_ = current_default_multi_display_mode_;
 
@@ skipping 22 matching lines @@
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     } else if (new_info_iter == new_display_info_list.end()) {
       // more displays in current list.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
     } else if (curr_iter->id() == new_info_iter->id()) {
       const display::Display& current_display = *curr_iter;
       // Copy the info because |InsertAndUpdateDisplayInfo| updates the
       // instance.
-      const DisplayInfo current_display_info =
+      const ui::ManagedDisplayInfo current_display_info =
           GetDisplayInfo(current_display.id());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       display::Display new_display =
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
-      const DisplayInfo& new_display_info = GetDisplayInfo(new_display.id());
+      const ui::ManagedDisplayInfo& new_display_info =
+          GetDisplayInfo(new_display.id());
 
       uint32_t metrics = display::DisplayObserver::DISPLAY_METRIC_NONE;
 
       // At that point the new Display objects we have are not entirely updated,
       // they are missing the translation related to the Display disposition in
       // the layout.
       // Using display.bounds() and display.work_area() would fail most of the
       // time.
       if (force_bounds_changed_ || (current_display_info.bounds_in_native() !=
                                     new_display_info.bounds_in_native()) ||
@@ skipping 165 matching lines @@
   // info in hardware mirroring comes from DisplayConfigurator.
   if (!IsInMirrorMode())
     ReconfigureDisplays();
 }
 
 bool DisplayManager::IsInUnifiedMode() const {
   return multi_display_mode_ == UNIFIED &&
          !software_mirroring_display_list_.empty();
 }
 
-const DisplayInfo& DisplayManager::GetDisplayInfo(int64_t display_id) const {
+const ui::ManagedDisplayInfo& DisplayManager::GetDisplayInfo(
+    int64_t display_id) const {
   DCHECK_NE(display::Display::kInvalidDisplayID, display_id);
 
-  std::map<int64_t, DisplayInfo>::const_iterator iter =
+  std::map<int64_t, ui::ManagedDisplayInfo>::const_iterator iter =
       display_info_.find(display_id);
   CHECK(iter != display_info_.end()) << display_id;
   return iter->second;
 }
 
 const display::Display DisplayManager::GetMirroringDisplayById(
     int64_t display_id) const {
   auto iter = std::find_if(software_mirroring_display_list_.begin(),
                            software_mirroring_display_list_.end(),
                            [display_id](const display::Display& display) {
                              return display.id() == display_id;
                            });
   return iter == software_mirroring_display_list_.end() ? display::Display()
                                                         : *iter;
 }
 
 std::string DisplayManager::GetDisplayNameForId(int64_t id) {
   if (id == display::Display::kInvalidDisplayID)
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
-  std::map<int64_t, DisplayInfo>::const_iterator iter = display_info_.find(id);
+  std::map<int64_t, ui::ManagedDisplayInfo>::const_iterator iter =
+      display_info_.find(id);
   if (iter != display_info_.end() && !iter->second.name().empty())
     return iter->second.name();
 
   return base::StringPrintf("Display %d", static_cast<int>(id));
 }
 
 int64_t DisplayManager::GetDisplayIdForUIScaling() const {
   // UI Scaling is effective on internal display.
   return display::Display::HasInternalDisplay()
              ? display::Display::InternalDisplayId()
@@ skipping 14 matching lines @@
     return;
   }
 #endif
   multi_display_mode_ =
       mirror ? MIRRORING : current_default_multi_display_mode_;
   ReconfigureDisplays();
 }
 
 void DisplayManager::AddRemoveDisplay() {
   DCHECK(!active_display_list_.empty());
-  std::vector<DisplayInfo> new_display_info_list;
-  const DisplayInfo& first_display =
+  DisplayInfoList new_display_info_list;
+  const ui::ManagedDisplayInfo& first_display =
       IsInUnifiedMode()
           ? GetDisplayInfo(software_mirroring_display_list_[0].id())
           : GetDisplayInfo(active_display_list_[0].id());
   new_display_info_list.push_back(first_display);
   // Add if there is only one display connected.
   if (num_connected_displays() == 1) {
     const int kVerticalOffsetPx = 100;
     // Layout the 2nd display below the primary as with the real device.
     gfx::Rect host_bounds = first_display.bounds_in_native();
     new_display_info_list.push_back(
-        DisplayInfo::CreateFromSpec(base::StringPrintf(
+        ui::ManagedDisplayInfo::CreateFromSpec(base::StringPrintf(
             "%d+%d-600x%d", host_bounds.x(),
             host_bounds.bottom() + kVerticalOffsetPx, host_bounds.height())));
   }
   num_connected_displays_ = new_display_info_list.size();
   mirroring_display_id_ = display::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
   UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!active_display_list_.empty());
-  std::vector<DisplayInfo> new_display_info_list;
+  DisplayInfoList new_display_info_list;
   for (display::DisplayList::const_iterator iter = active_display_list_.begin();
        iter != active_display_list_.end(); ++iter) {
-    DisplayInfo display_info = GetDisplayInfo(iter->id());
+    ui::ManagedDisplayInfo display_info = GetDisplayInfo(iter->id());
     display_info.set_device_scale_factor(
         display_info.device_scale_factor() == 1.0f ? 2.0f : 1.0f);
     new_display_info_list.push_back(display_info);
   }
   AddMirrorDisplayInfoIfAny(&new_display_info_list);
   UpdateDisplaysWith(new_display_info_list);
 }
 
 #if defined(OS_CHROMEOS)
 void DisplayManager::SetSoftwareMirroring(bool enabled) {
@@ skipping 76 matching lines @@
 void DisplayManager::CreateScreenForShutdown() const {
   delete screen_for_shutdown;
   screen_for_shutdown = screen_->CloneForShutdown();
   display::Screen::SetScreenInstance(screen_for_shutdown);
 }
 
 void DisplayManager::UpdateInternalManagedDisplayModeListForTest() {
   if (!display::Display::HasInternalDisplay() ||
       display_info_.count(display::Display::InternalDisplayId()) == 0)
     return;
-  DisplayInfo* info = &display_info_[display::Display::InternalDisplayId()];
+  ui::ManagedDisplayInfo* info =
+      &display_info_[display::Display::InternalDisplayId()];
   SetInternalManagedDisplayModeList(info);
 }
 
 void DisplayManager::CreateSoftwareMirroringDisplayInfo(
     DisplayInfoList* display_info_list) {
   // Use the internal display or 1st as the mirror source, then scale
   // the root window so that it matches the external display's
   // resolution. This is necessary in order for scaling to work while
   // mirrored.
   switch (multi_display_mode_) {
     case MIRRORING: {
       if (display_info_list->size() != 2)
         return;
       bool zero_is_source =
           first_display_id_ == (*display_info_list)[0].id() ||
           display::Display::IsInternalDisplayId((*display_info_list)[0].id());
       DCHECK_EQ(MIRRORING, multi_display_mode_);
       mirroring_display_id_ = (*display_info_list)[zero_is_source ? 1 : 0].id();
 
       int64_t display_id = mirroring_display_id_;
       auto iter =
           std::find_if(display_info_list->begin(), display_info_list->end(),
-                       [display_id](const DisplayInfo& info) {
+                       [display_id](const ui::ManagedDisplayInfo& info) {
                          return info.id() == display_id;
                        });
       DCHECK(iter != display_info_list->end());
 
-      DisplayInfo info = *iter;
+      ui::ManagedDisplayInfo info = *iter;
       info.SetOverscanInsets(gfx::Insets());
       InsertAndUpdateDisplayInfo(info);
       software_mirroring_display_list_.push_back(
           CreateMirroringDisplayFromDisplayInfoById(mirroring_display_id_,
                                                     gfx::Point(), 1.0f));
       display_info_list->erase(iter);
       break;
     }
     case UNIFIED: {
       if (display_info_list->size() == 1)
@@ skipping 10 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();
         }
       }
 
-      DisplayInfo::ManagedDisplayModeList display_mode_list;
+      ui::ManagedDisplayInfo::ManagedDisplayModeList 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);
+      ui::ManagedDisplayInfo info(kUnifiedDisplayId, "Unified Desktop", false);
 
-      scoped_refptr<ManagedDisplayMode> native_mode(new ManagedDisplayMode(
-          unified_bounds.size(), 60.0f, false, true, 1.0, 1.0));
-      DisplayInfo::ManagedDisplayModeList modes =
+      scoped_refptr<ui::ManagedDisplayMode> native_mode(
+          new ui::ManagedDisplayMode(unified_bounds.size(), 60.0f, false, true,
+                                     1.0, 1.0));
+      ui::ManagedDisplayInfo::ManagedDisplayModeList modes =
           CreateUnifiedManagedDisplayModeList(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 scoped_refptr<ManagedDisplayMode>& mode) {
+              const scoped_refptr<ui::ManagedDisplayMode>& mode) {
             return mode->size().height() == default_height &&
                    mode->device_scale_factor() == default_device_scale_factor;
           });
 
-      scoped_refptr<ManagedDisplayMode> dm(*iter);
-      *iter = make_scoped_refptr(new ManagedDisplayMode(
+      scoped_refptr<ui::ManagedDisplayMode> dm(*iter);
+      *iter = make_scoped_refptr(new ui::ManagedDisplayMode(
           dm->size(), dm->refresh_rate(), dm->is_interlaced(),
           true /* native */, dm->ui_scale(), dm->device_scale_factor()));
 
       info.SetManagedDisplayModes(modes);
       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.
-      scoped_refptr<ManagedDisplayMode> mode =
+      scoped_refptr<ui::ManagedDisplayMode> 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;
@@ skipping 24 matching lines @@
   if (iter != active_display_list_.end())
     return &(*iter);
   // 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) {
+    DisplayInfoList* display_info_list) {
   if (software_mirroring_enabled() && IsInMirrorMode()) {
     display_info_list->push_back(GetDisplayInfo(mirroring_display_id_));
     software_mirroring_display_list_.clear();
   }
 }
 
-void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
-  std::map<int64_t, DisplayInfo>::iterator info =
+void DisplayManager::InsertAndUpdateDisplayInfo(
+    const ui::ManagedDisplayInfo& new_info) {
+  std::map<int64_t, ui::ManagedDisplayInfo>::iterator info =
       display_info_.find(new_info.id());
   if (info != display_info_.end()) {
     info->second.Copy(new_info);
   } else {
     display_info_[new_info.id()] = new_info;
     display_info_[new_info.id()].set_native(false);
     // FHD with 1.25 DSF behaves differently from other configuration.
     // It uses 1.25 DSF only when UI-Scale is set to 0.8.
     // For new users, use the UI-scale to 0.8 so that it will use DSF=1.25
     // internally.
     if (display::Display::IsInternalDisplayId(new_info.id()) &&
         new_info.bounds_in_native().height() == 1080 &&
         new_info.device_scale_factor() == 1.25f) {
       display_info_[new_info.id()].set_configured_ui_scale(0.8f);
     }
   }
   display_info_[new_info.id()].UpdateDisplaySize();
   OnDisplayInfoUpdated(display_info_[new_info.id()]);
 }
 
-void DisplayManager::OnDisplayInfoUpdated(const DisplayInfo& display_info) {
+void DisplayManager::OnDisplayInfoUpdated(
+    const ui::ManagedDisplayInfo& display_info) {
 #if defined(OS_CHROMEOS)
   ui::ColorCalibrationProfile color_profile = display_info.color_profile();
   if (color_profile != ui::COLOR_PROFILE_STANDARD) {
     Shell::GetInstance()->display_configurator()->SetColorCalibrationProfile(
         display_info.id(), color_profile);
   }
 #endif
 }
 
 display::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64_t id) {
   DCHECK(display_info_.find(id) != display_info_.end()) << "id=" << id;
-  const DisplayInfo& display_info = display_info_[id];
+  const ui::ManagedDisplayInfo& display_info = display_info_[id];
 
   display::Display new_display(display_info.id());
   gfx::Rect bounds_in_native(display_info.size_in_pixel());
   float device_scale_factor = display_info.GetEffectiveDeviceScaleFactor();
 
   // Simply set the origin to (0,0).  The primary display's origin is
   // always (0,0) and the bounds of non-primary display(s) will be updated
   // in |UpdateNonPrimaryDisplayBoundsForLayout| called in |UpdateDisplay|.
   new_display.SetScaleAndBounds(device_scale_factor,
                                 gfx::Rect(bounds_in_native.size()));
   new_display.set_rotation(display_info.GetActiveRotation());
   new_display.set_touch_support(display_info.touch_support());
   new_display.set_maximum_cursor_size(display_info.maximum_cursor_size());
   return new_display;
 }
 
 display::Display DisplayManager::CreateMirroringDisplayFromDisplayInfoById(
     int64_t id,
     const gfx::Point& origin,
     float scale) {
   DCHECK(display_info_.find(id) != display_info_.end()) << "id=" << id;
-  const DisplayInfo& display_info = display_info_[id];
+  const ui::ManagedDisplayInfo& display_info = display_info_[id];
 
   display::Display new_display(display_info.id());
   new_display.SetScaleAndBounds(
       1.0f, gfx::Rect(origin, gfx::ScaleToFlooredSize(
                                   display_info.size_in_pixel(), scale)));
   new_display.set_touch_support(display_info.touch_support());
   new_display.set_maximum_cursor_size(display_info.maximum_cursor_size());
   return new_display;
 }
 
@@ skipping 40 matching lines @@
   layout.ApplyToDisplayList(display_list, updated_ids,
                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash