Move ash::DisplayInfo to ui

ash/display/display_manager_unittest.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 "ash/accelerators/accelerator_commands_aura.h"
 #include "ash/common/ash_switches.h"
-#include "ash/common/display/display_info.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_util.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_md_test_base.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/mirror_window_test_api.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.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_builder.h"
 #include "ui/display/manager/display_layout_store.h"
+#include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/font_render_params.h"
 
 namespace ash {
 
 using std::vector;
 using std::string;
 
 using base::StringPrintf;
@@ skipping 42 matching lines @@
   void reset() {
     changed_.clear();
     added_.clear();
     removed_count_ = 0U;
     changed_metrics_ = 0U;
     root_window_destroyed_ = false;
   }
 
   bool root_window_destroyed() const { return root_window_destroyed_; }
 
-  const DisplayInfo& GetDisplayInfo(const display::Display& display) {
+  const display::ManagedDisplayInfo& GetDisplayInfo(
+      const display::Display& display) {
     return display_manager()->GetDisplayInfo(display.id());
   }
 
-  const DisplayInfo& GetDisplayInfoAt(int index) {
+  const display::ManagedDisplayInfo& GetDisplayInfoAt(int index) {
     return GetDisplayInfo(display_manager()->GetDisplayAt(index));
   }
 
   const display::Display& GetDisplayForId(int64_t id) {
     return display_manager()->GetDisplayForId(id);
   }
 
-  const DisplayInfo& GetDisplayInfoForId(int64_t id) {
+  const display::ManagedDisplayInfo& GetDisplayInfoForId(int64_t id) {
     return GetDisplayInfo(display_manager()->GetDisplayForId(id));
   }
 
   // aura::DisplayObserver overrides:
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t changed_metrics) override {
     changed_.push_back(display);
     changed_metrics_ |= changed_metrics;
   }
   void OnDisplayAdded(const display::Display& new_display) override {
@@ skipping 76 matching lines @@
 
   // Secondary removed, primary changed.
   UpdateDisplay("1+1-800x300");
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("1 0 1", GetCountSummary());
   EXPECT_EQ(display_manager()->GetDisplayAt(0).id(), changed()[0].id());
   EXPECT_EQ("0,0 800x300", changed()[0].bounds().ToString());
   reset();
 
   // # of display can go to zero when screen is off.
-  const vector<DisplayInfo> empty;
+  const vector<display::ManagedDisplayInfo> empty;
   display_manager()->OnNativeDisplaysChanged(empty);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0 0 0", GetCountSummary());
   EXPECT_FALSE(root_window_destroyed());
   // Display configuration stays the same
   EXPECT_EQ("0,0 800x300",
             display_manager()->GetDisplayAt(0).bounds().ToString());
   reset();
 
   // Connect to display again
@@ skipping 260 matching lines @@
 #endif
 }
 
 TEST_P(DisplayManagerTest, OverscanInsetsTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("0+0-500x500,0+501-400x400");
   reset();
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
-  const DisplayInfo& display_info1 = GetDisplayInfoAt(0);
-  const DisplayInfo& display_info2 = GetDisplayInfoAt(1);
+  const display::ManagedDisplayInfo& display_info1 = GetDisplayInfoAt(0);
+  const display::ManagedDisplayInfo& display_info2 = GetDisplayInfoAt(1);
   display_manager()->SetOverscanInsets(display_info2.id(),
                                        gfx::Insets(13, 12, 11, 10));
 
   std::vector<display::Display> changed_displays = changed();
   EXPECT_EQ(1u, changed_displays.size());
   EXPECT_EQ(display_info2.id(), changed_displays[0].id());
   EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
-  DisplayInfo updated_display_info2 = GetDisplayInfoAt(1);
+  display::ManagedDisplayInfo updated_display_info2 = GetDisplayInfoAt(1);
   EXPECT_EQ("0,501 400x400",
             updated_display_info2.bounds_in_native().ToString());
   EXPECT_EQ("378x376", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("13,12,11,10",
             updated_display_info2.overscan_insets_in_dip().ToString());
   EXPECT_EQ("500,0 378x376",
             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
 
   // Make sure that SetOverscanInsets() is idempotent.
   display_manager()->SetOverscanInsets(display_info1.id(), gfx::Insets());
@@ skipping 17 matching lines @@
   // Recreate a new 2nd display. It won't apply the overscan inset because the
   // new display has a different ID.
   UpdateDisplay("0+0-500x500");
   UpdateDisplay("0+0-500x500,0+501-400x400");
   EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   EXPECT_EQ("0,501 400x400", GetDisplayInfoAt(1).bounds_in_native().ToString());
 
   // Recreate the displays with the same ID.  It should apply the overscan
   // inset.
   UpdateDisplay("0+0-500x500");
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(display_info1);
   display_info_list.push_back(display_info2);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ("1,1 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   updated_display_info2 = GetDisplayInfoAt(1);
   EXPECT_EQ("376x378", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("10,11,12,13",
             updated_display_info2.overscan_insets_in_dip().ToString());
 
   // HiDPI but overscan display. The specified insets size should be doubled.
@@ skipping 88 matching lines @@
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   EXPECT_EQ("1 0 0", GetCountSummary());
 
   UpdateDisplay("1000x600*2");
   EXPECT_EQ(2, host->compositor()->device_scale_factor());
   EXPECT_EQ("2 0 0", GetCountSummary());
   EXPECT_EQ("500x300",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 }
 
-DisplayInfo CreateDisplayInfo(int64_t id, const gfx::Rect& bounds) {
-  DisplayInfo info(id, ToDisplayName(id), false);
+display::ManagedDisplayInfo CreateDisplayInfo(int64_t id,
+                                              const gfx::Rect& bounds) {
+  display::ManagedDisplayInfo info(id, ToDisplayName(id), false);
   info.SetBounds(bounds);
   return info;
 }
 
 TEST_P(DisplayManagerTest, TestNativeDisplaysChanged) {
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const int external_id = 10;
   const int mirror_id = 11;
   const int64_t invalid_id = display::Display::kInvalidDisplayID;
-  const DisplayInfo internal_display_info =
+  const display::ManagedDisplayInfo internal_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
-  const DisplayInfo external_display_info =
+  const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
-  const DisplayInfo mirroring_display_info =
+  const display::ManagedDisplayInfo mirroring_display_info =
       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   std::string default_bounds =
       display_manager()->GetDisplayAt(0).bounds().ToString();
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   // Primary disconnected.
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(default_bounds,
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   if (!SupportsMultipleDisplays())
     return;
@@ skipping 137 matching lines @@
 // See: crbug.com/414394
 TEST_P(DisplayManagerTest, DisplayAddRemoveAtTheSameTime) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("100+0-500x500,0+501-400x400");
 
   const int64_t primary_id = WindowTreeHostManager::GetPrimaryDisplayId();
   const int64_t secondary_id = ScreenUtil::GetSecondaryDisplay().id();
 
-  DisplayInfo primary_info = display_manager()->GetDisplayInfo(primary_id);
-  DisplayInfo secondary_info = display_manager()->GetDisplayInfo(secondary_id);
+  display::ManagedDisplayInfo primary_info =
+      display_manager()->GetDisplayInfo(primary_id);
+  display::ManagedDisplayInfo secondary_info =
+      display_manager()->GetDisplayInfo(secondary_id);
 
   // An id which is different from primary and secondary.
   const int64_t third_id = secondary_id + 1;
 
-  DisplayInfo third_info =
+  display::ManagedDisplayInfo third_info =
       CreateDisplayInfo(third_id, gfx::Rect(0, 0, 600, 600));
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(third_info);
   display_info_list.push_back(secondary_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   // Secondary seconary_id becomes the primary as it has smaller output index.
   EXPECT_EQ(secondary_id, WindowTreeHostManager::GetPrimaryDisplayId());
   EXPECT_EQ(third_id, ScreenUtil::GetSecondaryDisplay().id());
   EXPECT_EQ("600x600", GetDisplayForId(third_id).size().ToString());
 }
 
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, TestNativeDisplaysChangedNoInternal) {
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Don't change the display info if all displays are disconnected.
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Connect another display which will become primary.
-  const DisplayInfo external_display_info =
+  const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
   EXPECT_EQ("100x100", ash::Shell::GetPrimaryRootWindow()
                            ->GetHost()
                            ->GetBounds()
                            .size()
                            .ToString());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
 
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
-  const DisplayInfo native_display_info =
+  const display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
-  const DisplayInfo secondary_display_info =
+  const display::ManagedDisplayInfo secondary_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_info_list.push_back(secondary_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("500,0 100x100", GetDisplayForId(10).bounds().ToString());
 
   ash::Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
       secondary_display_info.id());
   EXPECT_EQ("-500,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 
   // OnNativeDisplaysChanged may change the display bounds.  Here makes sure
   // nothing changed if the exactly same displays are specified.
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ("-500,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 }
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, DontRememberBestResolution) {
   int display_id = 1000;
-  DisplayInfo native_display_info =
+  display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
-  DisplayInfo::ManagedDisplayModeList display_modes;
-  display_modes.push_back(make_scoped_refptr(
-      new ManagedDisplayMode(gfx::Size(1000, 500), 58.0f, false, true)));
-  display_modes.push_back(make_scoped_refptr(
-      new ManagedDisplayMode(gfx::Size(800, 300), 59.0f, false, false)));
-  display_modes.push_back(make_scoped_refptr(
-      new ManagedDisplayMode(gfx::Size(400, 500), 60.0f, false, false)));
+  display::ManagedDisplayInfo::ManagedDisplayModeList display_modes;
+  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
+      gfx::Size(1000, 500), 58.0f, false, true)));
+  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
+      gfx::Size(800, 300), 59.0f, false, false)));
+  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
+      gfx::Size(400, 500), 60.0f, false, false)));
 
   native_display_info.SetManagedDisplayModes(display_modes);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
-  scoped_refptr<ManagedDisplayMode> mode;
-  scoped_refptr<ManagedDisplayMode> expected_mode(
-      new ManagedDisplayMode(gfx::Size(1000, 500), 0.0f, false, false));
+  scoped_refptr<display::ManagedDisplayMode> mode;
+  scoped_refptr<display::ManagedDisplayMode> expected_mode(
+      new display::ManagedDisplayMode(gfx::Size(1000, 500), 0.0f, false,
+                                      false));
 
   mode = display_manager()->GetSelectedModeForDisplayId(display_id);
   EXPECT_FALSE(!!mode);
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   // Unsupported resolution.
   test::SetDisplayResolution(display_id, gfx::Size(800, 4000));
   mode = display_manager()->GetSelectedModeForDisplayId(display_id);
   EXPECT_FALSE(!!mode);
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   // Supported resolution.
   test::SetDisplayResolution(display_id, gfx::Size(800, 300));
   mode = display_manager()->GetSelectedModeForDisplayId(display_id);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("800x300", mode->size().ToString());
   EXPECT_EQ(59.0f, mode->refresh_rate());
   EXPECT_FALSE(mode->native());
 
   expected_mode =
-      new ManagedDisplayMode(gfx::Size(800, 300), 0.0f, false, false);
+      new display::ManagedDisplayMode(gfx::Size(800, 300), 0.0f, false, false);
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   // Best resolution.
   test::SetDisplayResolution(display_id, gfx::Size(1000, 500));
   mode = display_manager()->GetSelectedModeForDisplayId(display_id);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("1000x500", mode->size().ToString());
   EXPECT_EQ(58.0f, mode->refresh_rate());
   EXPECT_TRUE(mode->native());
 
   expected_mode =
-      new ManagedDisplayMode(gfx::Size(1000, 500), 0.0f, false, false);
+      new display::ManagedDisplayMode(gfx::Size(1000, 500), 0.0f, false, false);
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 #endif  // defined(OS_CHROMEOS)
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, ResolutionFallback) {
   int display_id = 1000;
-  DisplayInfo native_display_info =
+  display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
-  DisplayInfo::ManagedDisplayModeList display_modes;
-  display_modes.push_back(make_scoped_refptr(
-      new ManagedDisplayMode(gfx::Size(1000, 500), 58.0f, false, true)));
-  display_modes.push_back(make_scoped_refptr(
-      new ManagedDisplayMode(gfx::Size(800, 300), 59.0f, false, false)));
-  display_modes.push_back(make_scoped_refptr(
-      new ManagedDisplayMode(gfx::Size(400, 500), 60.0f, false, false)));
+  display::ManagedDisplayInfo::ManagedDisplayModeList display_modes;
+  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
+      gfx::Size(1000, 500), 58.0f, false, true)));
+  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
+      gfx::Size(800, 300), 59.0f, false, false)));
+  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
+      gfx::Size(400, 500), 60.0f, false, false)));
 
-  DisplayInfo::ManagedDisplayModeList copy = display_modes;
+  display::ManagedDisplayInfo::ManagedDisplayModeList copy = display_modes;
   native_display_info.SetManagedDisplayModes(copy);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   {
     test::SetDisplayResolution(display_id, gfx::Size(800, 300));
-    DisplayInfo new_native_display_info =
+    display::ManagedDisplayInfo new_native_display_info =
         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 400, 500));
     copy = display_modes;
     new_native_display_info.SetManagedDisplayModes(copy);
-    std::vector<DisplayInfo> new_display_info_list;
+    std::vector<display::ManagedDisplayInfo> new_display_info_list;
     new_display_info_list.push_back(new_native_display_info);
     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 
-    scoped_refptr<ManagedDisplayMode> mode =
+    scoped_refptr<display::ManagedDisplayMode> mode =
         display_manager()->GetSelectedModeForDisplayId(display_id);
     EXPECT_TRUE(!!mode);
     EXPECT_EQ("400x500", mode->size().ToString());
     EXPECT_EQ(60.0f, mode->refresh_rate());
     EXPECT_FALSE(mode->native());
   }
   {
     // Best resolution should find itself on the resolutions list.
     test::SetDisplayResolution(display_id, gfx::Size(800, 300));
-    DisplayInfo new_native_display_info =
+    display::ManagedDisplayInfo new_native_display_info =
         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
-    DisplayInfo::ManagedDisplayModeList copy = display_modes;
+    display::ManagedDisplayInfo::ManagedDisplayModeList copy = display_modes;
     new_native_display_info.SetManagedDisplayModes(copy);
-    std::vector<DisplayInfo> new_display_info_list;
+    std::vector<display::ManagedDisplayInfo> new_display_info_list;
     new_display_info_list.push_back(new_native_display_info);
     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 
-    scoped_refptr<ManagedDisplayMode> mode =
+    scoped_refptr<display::ManagedDisplayMode> mode =
         display_manager()->GetSelectedModeForDisplayId(display_id);
     EXPECT_TRUE(!!mode);
     EXPECT_EQ("1000x500", mode->size().ToString());
     EXPECT_EQ(58.0f, mode->refresh_rate());
     EXPECT_TRUE(mode->native());
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, Rotate) {
@@ skipping 50 matching lines @@
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
 
   display_manager()->SetDisplayRotation(internal_display_id,
                                         display::Display::ROTATE_90,
                                         display::Display::ROTATION_SOURCE_USER);
   display_manager()->SetDisplayRotation(
       internal_display_id, display::Display::ROTATE_0,
       display::Display::ROTATION_SOURCE_ACTIVE);
 
-  const DisplayInfo info = GetDisplayInfoForId(internal_display_id);
+  const display::ManagedDisplayInfo info =
+      GetDisplayInfoForId(internal_display_id);
   EXPECT_EQ(display::Display::ROTATE_0, info.GetActiveRotation());
 
   // Deactivate internal display to simulate Docked Mode.
-  vector<DisplayInfo> secondary_only;
+  vector<display::ManagedDisplayInfo> secondary_only;
   secondary_only.push_back(GetDisplayInfoAt(1));
   display_manager()->OnNativeDisplaysChanged(secondary_only);
 
-  const DisplayInfo post_removal_info =
+  const display::ManagedDisplayInfo post_removal_info =
       display_manager()->display_info_[internal_display_id];
   EXPECT_NE(info.GetActiveRotation(), post_removal_info.GetActiveRotation());
   EXPECT_EQ(display::Display::ROTATE_90, post_removal_info.GetActiveRotation());
 
   display_manager()->SetDisplayRotation(
       internal_display_id, display::Display::ROTATE_180,
       display::Display::ROTATION_SOURCE_ACTIVE);
-  const DisplayInfo post_rotation_info =
+  const display::ManagedDisplayInfo post_rotation_info =
       display_manager()->display_info_[internal_display_id];
   EXPECT_NE(info.GetActiveRotation(), post_rotation_info.GetActiveRotation());
   EXPECT_EQ(display::Display::ROTATE_180,
             post_rotation_info.GetActiveRotation());
 }
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, UIScale) {
   test::ScopedDisable125DSFForUIScaling disable;
@@ skipping 87 matching lines @@
   display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(1.0f, display.device_scale_factor());
   EXPECT_EQ("1280x850", display.bounds().size().ToString());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, UIScaleWithDisplayMode) {
   int display_id = 1000;
 
   // Setup the display modes with UI-scale.
-  DisplayInfo native_display_info =
+  display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1280, 800));
-  const scoped_refptr<ManagedDisplayMode>& base_mode(
-      new ManagedDisplayMode(gfx::Size(1280, 800), 60.0f, false, false));
-  DisplayInfo::ManagedDisplayModeList mode_list =
+  const scoped_refptr<display::ManagedDisplayMode>& base_mode(
+      new display::ManagedDisplayMode(gfx::Size(1280, 800), 60.0f, false,
+                                      false));
+  display::ManagedDisplayInfo::ManagedDisplayModeList mode_list =
       CreateInternalManagedDisplayModeList(base_mode);
   native_display_info.SetManagedDisplayModes(mode_list);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
-  scoped_refptr<ManagedDisplayMode> expected_mode = base_mode;
+  scoped_refptr<display::ManagedDisplayMode> expected_mode = base_mode;
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   SetDisplayUIScale(display_id, 1.5f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
 
-  expected_mode = new ManagedDisplayMode(
+  expected_mode = new display::ManagedDisplayMode(
       expected_mode->size(), expected_mode->refresh_rate(),
       expected_mode->is_interlaced(), expected_mode->native(),
       1.125f /* ui_scale */, expected_mode->device_scale_factor());
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
 
-  expected_mode = new ManagedDisplayMode(
+  expected_mode = new display::ManagedDisplayMode(
       expected_mode->size(), expected_mode->refresh_rate(),
       expected_mode->is_interlaced(), expected_mode->native(),
       0.8f /* ui_scale */, expected_mode->device_scale_factor());
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
 
-  expected_mode = new ManagedDisplayMode(
+  expected_mode = new display::ManagedDisplayMode(
       expected_mode->size(), expected_mode->refresh_rate(),
       expected_mode->is_interlaced(), expected_mode->native(),
       0.625f /* ui_scale */, expected_mode->device_scale_factor());
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.6f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
 
-  expected_mode = new ManagedDisplayMode(
+  expected_mode = new display::ManagedDisplayMode(
       expected_mode->size(), expected_mode->refresh_rate(),
       expected_mode->is_interlaced(), expected_mode->native(),
       0.5f /* ui_scale */, expected_mode->device_scale_factor());
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
@@ skipping 24 matching lines @@
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, FHD125DefaultsTo08UIScaling) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   display_id++;
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   // Setup the display modes with UI-scale.
-  DisplayInfo native_display_info =
+  display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
-  const scoped_refptr<ManagedDisplayMode>& base_mode(
-      new ManagedDisplayMode(gfx::Size(1920, 1080), 60.0f, false, false));
-  DisplayInfo::ManagedDisplayModeList mode_list =
+  const scoped_refptr<display::ManagedDisplayMode>& base_mode(
+      new display::ManagedDisplayMode(gfx::Size(1920, 1080), 60.0f, false,
+                                      false));
+  display::ManagedDisplayInfo::ManagedDisplayModeList mode_list =
       CreateInternalManagedDisplayModeList(base_mode);
   native_display_info.SetManagedDisplayModes(mode_list);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
 
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 }
 #endif  // defined(OS_CHROMEOS)
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 // Don't default to 1.25 DSF if the user already has a prefrence stored for
 // the internal display.
 TEST_P(DisplayManagerTest, FHD125DefaultsTo08UIScalingNoOverride) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   display_id++;
   test::ScopedSetInternalDisplayId set_internal(display_id);
   const gfx::Insets dummy_overscan_insets;
   display_manager()->RegisterDisplayProperty(
       display_id, display::Display::ROTATE_0, 1.0f, &dummy_overscan_insets,
       gfx::Size(), 1.0f, ui::ColorCalibrationProfile());
 
   // Setup the display modes with UI-scale.
-  DisplayInfo native_display_info =
+  display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
-  const scoped_refptr<ManagedDisplayMode>& base_mode(
-      new ManagedDisplayMode(gfx::Size(1920, 1080), 60.0f, false, false));
-  DisplayInfo::ManagedDisplayModeList mode_list =
+  const scoped_refptr<display::ManagedDisplayMode>& base_mode(
+      new display::ManagedDisplayMode(gfx::Size(1920, 1080), 60.0f, false,
+                                      false));
+  display::ManagedDisplayInfo::ManagedDisplayModeList mode_list =
       CreateInternalManagedDisplayModeList(base_mode);
   native_display_info.SetManagedDisplayModes(mode_list);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
 
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, ResolutionChangeInUnifiedMode) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200, 400x400");
 
   int64_t unified_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
-  DisplayInfo info = display_manager()->GetDisplayInfo(unified_id);
+  display::ManagedDisplayInfo info =
+      display_manager()->GetDisplayInfo(unified_id);
   ASSERT_EQ(2u, info.display_modes().size());
   EXPECT_EQ("400x200", info.display_modes()[0]->size().ToString());
   EXPECT_TRUE(info.display_modes()[0]->native());
   EXPECT_EQ("800x400", info.display_modes()[1]->size().ToString());
   EXPECT_FALSE(info.display_modes()[1]->native());
   EXPECT_EQ(
       "400x200",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
-  scoped_refptr<ManagedDisplayMode> active_mode =
+  scoped_refptr<display::ManagedDisplayMode> active_mode =
       display_manager()->GetActiveModeForDisplayId(unified_id);
   EXPECT_EQ(1.0f, active_mode->ui_scale());
   EXPECT_EQ("400x200", active_mode->size().ToString());
 
   EXPECT_TRUE(test::SetDisplayResolution(unified_id, gfx::Size(800, 400)));
   EXPECT_EQ(
       "800x400",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
 
   active_mode = display_manager()->GetActiveModeForDisplayId(unified_id);
@@ skipping 207 matching lines @@
 TEST_P(DisplayManagerTest, SoftwareMirroringWithCompositingCursor) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(nullptr, test_api.GetHost());
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  DisplayInfo secondary_info =
+  display::ManagedDisplayInfo secondary_info =
       display_manager->GetDisplayInfo(ScreenUtil::GetSecondaryDisplay().id());
 
   display_manager->SetSoftwareMirroring(true);
   display_manager->UpdateDisplays();
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_FALSE(root_windows[0]->Contains(test_api.GetCursorWindow()));
 
   Shell::GetInstance()->SetCursorCompositingEnabled(true);
 
   EXPECT_TRUE(root_windows[0]->Contains(test_api.GetCursorWindow()));
 
   // Removes the first display and keeps the second one.
   display_manager->SetSoftwareMirroring(false);
-  std::vector<DisplayInfo> new_info_list;
+  std::vector<display::ManagedDisplayInfo> new_info_list;
   new_info_list.push_back(secondary_info);
   display_manager->OnNativeDisplaysChanged(new_info_list);
 
   root_windows = Shell::GetAllRootWindows();
   EXPECT_TRUE(root_windows[0]->Contains(test_api.GetCursorWindow()));
 
   Shell::GetInstance()->SetCursorCompositingEnabled(false);
 }
 #endif  // OS_CHROMEOS
 
@@ skipping 95 matching lines @@
               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 }
 
 TEST_P(DisplayManagerTest, NotifyPrimaryChangeUndock) {
   if (!SupportsMultipleDisplays())
     return;
   // Assume the default display is an external display, and
   // emulates undocking by switching to another display.
-  DisplayInfo another_display_info =
+  display::ManagedDisplayInfo another_display_info =
       CreateDisplayInfo(1, gfx::Rect(0, 0, 1280, 800));
-  std::vector<DisplayInfo> info_list;
+  std::vector<display::ManagedDisplayInfo> info_list;
   info_list.push_back(another_display_info);
   reset();
   display_manager()->OnNativeDisplaysChanged(info_list);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 }
@@ skipping 66 matching lines @@
   // Switch to single desktop.
   UpdateDisplay("500x300");
   EXPECT_EQ(gfx::Size(500, 300), screen->GetPrimaryDisplay().size());
 
   // Switch to unified desktop.
   UpdateDisplay("500x300,400x500");
   // 400 * 300 / 500 + 500 ~= 739.
   EXPECT_EQ(gfx::Size(739, 300), screen->GetPrimaryDisplay().size());
 
   // The default should fit to the internal display.
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(CreateDisplayInfo(10, gfx::Rect(0, 0, 500, 300)));
   display_info_list.push_back(
       CreateDisplayInfo(11, gfx::Rect(500, 0, 400, 500)));
   {
     test::ScopedSetInternalDisplayId set_internal(11);
     display_manager()->OnNativeDisplaysChanged(display_info_list);
     // 500 * 500 / 300 + 400 ~= 1233.
     EXPECT_EQ(gfx::Size(1233, 500), screen->GetPrimaryDisplay().size());
   }
 
@@ skipping 11 matching lines @@
                 .size());
 }
 
 TEST_P(DisplayManagerTest, UnifiedDesktopWithHardwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   // Enter to hardware mirroring.
-  DisplayInfo d1(1, "", false);
+  display::ManagedDisplayInfo d1(1, "", false);
   d1.SetBounds(gfx::Rect(0, 0, 500, 500));
-  DisplayInfo d2(2, "", false);
+  display::ManagedDisplayInfo d2(2, "", false);
   d2.SetBounds(gfx::Rect(0, 0, 500, 500));
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(d1);
   display_info_list.push_back(d2);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   ASSERT_TRUE(display_manager()->IsInMirrorMode());
   display_manager()->SetUnifiedDesktopEnabled(true);
   EXPECT_TRUE(display_manager()->IsInMirrorMode());
 
   // The display manager automaticaclly switches to software mirroring
   // if the displays are configured to use mirroring when running on desktop.
   // This is a workdaround to force the display manager to forget
@@ skipping 36 matching lines @@
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
   display::Screen* screen = display::Screen::GetScreen();
 
   // 2nd display is 2x.
   UpdateDisplay("400x500,1000x800*2");
-  DisplayInfo info =
+  display::ManagedDisplayInfo info =
       display_manager()->GetDisplayInfo(screen->GetPrimaryDisplay().id());
   EXPECT_EQ(2u, info.display_modes().size());
   EXPECT_EQ("1640x800", info.display_modes()[0]->size().ToString());
   EXPECT_EQ(2.0f, info.display_modes()[0]->device_scale_factor());
   EXPECT_EQ("1025x500", info.display_modes()[1]->size().ToString());
   EXPECT_EQ(1.0f, info.display_modes()[1]->device_scale_factor());
 
   // For 1x, 400 + 500 / 800 * 100 = 1025.
   EXPECT_EQ("1025x500", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1025x500",
@@ skipping 146 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 250, 253 + height_offset).ToString(),
             docked->bounds().ToString());
 }
 
 TEST_P(DisplayManagerTest, DockMode) {
   if (!SupportsMultipleDisplays())
     return;
   const int64_t internal_id = 1;
   const int64_t external_id = 2;
 
-  const DisplayInfo internal_display_info =
+  const display::ManagedDisplayInfo internal_display_info =
       CreateDisplayInfo(internal_id, gfx::Rect(0, 0, 500, 500));
-  const DisplayInfo external_display_info =
+  const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
 
   // software mirroring.
   display_info_list.push_back(internal_display_info);
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   EXPECT_EQ(internal_id, internal_display_id);
 
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->active_display_list().size());
 
   EXPECT_TRUE(display_manager()->IsActiveDisplayId(external_id));
   EXPECT_FALSE(display_manager()->IsActiveDisplayId(internal_id));
 
-  const DisplayInfo& info = display_manager()->GetDisplayInfo(internal_id);
+  const display::ManagedDisplayInfo& info =
+      display_manager()->GetDisplayInfo(internal_id);
 
   EXPECT_FALSE(!!GetDisplayModeForNextUIScale(info, true));
   EXPECT_FALSE(!!GetDisplayModeForNextUIScale(info, false));
   EXPECT_FALSE(SetDisplayUIScale(internal_id, 1.0f));
 
-  DisplayInfo invalid_info;
+  display::ManagedDisplayInfo invalid_info;
   EXPECT_FALSE(!!GetDisplayModeForNextUIScale(invalid_info, true));
   EXPECT_FALSE(!!GetDisplayModeForNextUIScale(invalid_info, false));
   EXPECT_FALSE(SetDisplayUIScale(display::Display::kInvalidDisplayID, 1.0f));
 }
 
 // Make sure that bad layout information is ignored and does not crash.
 TEST_P(DisplayManagerTest, DontRegisterBadConfig) {
   if (!SupportsMultipleDisplays())
     return;
   display::DisplayIdList list = ash::test::CreateDisplayIdList2(1, 2);
@@ skipping 161 matching lines @@
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_P(DisplayManagerTest, CheckInitializationOfRotationProperty) {
   int64_t id = display_manager()->GetDisplayAt(0).id();
   display_manager()->RegisterDisplayProperty(id, display::Display::ROTATE_90,
                                              1.0f, nullptr, gfx::Size(), 1.0f,
                                              ui::COLOR_PROFILE_STANDARD);
 
-  const DisplayInfo& info = display_manager()->GetDisplayInfo(id);
+  const display::ManagedDisplayInfo& info =
+      display_manager()->GetDisplayInfo(id);
 
   EXPECT_EQ(display::Display::ROTATE_90,
             info.GetRotation(display::Display::ROTATION_SOURCE_USER));
   EXPECT_EQ(display::Display::ROTATE_90,
             info.GetRotation(display::Display::ROTATION_SOURCE_ACTIVE));
 }
 
 TEST_P(DisplayManagerTest, RejectInvalidLayoutData) {
   display::DisplayLayoutStore* layout_store = display_manager()->layout_store();
   int64_t id1 = 10001;
@@ skipping 33 matching lines @@
   const display::DisplayLayout& stored =
       layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash