Move ash::DisplayInfo to ui

ash/display/window_tree_host_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/window_tree_host_manager.h"
 
 #include <memory>
 
 #include "ash/aura/wm_window_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/shelf/shelf.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/display_util.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/ash_test_helper.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/display/display.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/manager/display_layout.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/event_handler.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/mouse_watcher.h"
 #include "ui/views/mouse_watcher_view_host.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_client.h"
 
@@ skipping 497 matching lines @@
   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
   EXPECT_EQ("-300,500 400x400", GetSecondaryDisplay().bounds().ToString());
 
   UpdateDisplay("500x500");
   EXPECT_LE(1, observer.GetFocusChangedCountAndReset());
   EXPECT_LE(1, observer.GetActivationChangedCountAndReset());
 }
 
 namespace {
 
-DisplayInfo CreateDisplayInfo(int64_t id,
-                              int y,
-                              display::Display::Rotation rotation) {
-  DisplayInfo info(id, "", false);
+display::ManagedDisplayInfo
+CreateDisplayInfo(int64_t id, int y, display::Display::Rotation rotation) {
+  display::ManagedDisplayInfo info(id, "", false);
   info.SetBounds(gfx::Rect(0, y, 500, 500));
   info.SetRotation(rotation, display::Display::ROTATION_SOURCE_ACTIVE);
   return info;
 }
 
-DisplayInfo CreateMirroredDisplayInfo(int64_t id, float device_scale_factor) {
-  DisplayInfo info = CreateDisplayInfo(id, 0, display::Display::ROTATE_0);
+display::ManagedDisplayInfo CreateMirroredDisplayInfo(
+    int64_t id,
+    float device_scale_factor) {
+  display::ManagedDisplayInfo info =
+      CreateDisplayInfo(id, 0, display::Display::ROTATE_0);
   info.set_device_scale_factor(device_scale_factor);
   return info;
 }
 
 }  // namespace
 
 TEST_P(WindowTreeHostManagerTest, MirrorToDockedWithFullscreen) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Creates windows to catch activation change event.
   std::unique_ptr<aura::Window> w1(CreateTestWindowInShellWithId(1));
   w1->Focus();
 
   // Docked mode.
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
-  const DisplayInfo internal_display_info = CreateMirroredDisplayInfo(1, 2.0f);
-  const DisplayInfo external_display_info = CreateMirroredDisplayInfo(2, 1.0f);
+  const display::ManagedDisplayInfo internal_display_info =
+      CreateMirroredDisplayInfo(1, 2.0f);
+  const display::ManagedDisplayInfo external_display_info =
+      CreateMirroredDisplayInfo(2, 1.0f);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   // Mirror.
   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(1, internal_display_id);
   EXPECT_EQ(2U, display_manager->num_connected_displays());
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
 
@@ skipping 288 matching lines @@
                 .id());
   EXPECT_EQ(
       primary_display.id(),
       display::Screen::GetScreen()->GetDisplayNearestWindow(nullptr).id());
   EXPECT_TRUE(tracker.Contains(primary_root));
   EXPECT_FALSE(tracker.Contains(secondary_root));
   EXPECT_TRUE(primary_root->Contains(shelf_window));
 
   // Adding 2nd display with the same ID.  The 2nd display should become primary
   // since secondary id is still stored as desirable_primary_id.
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(
       display_manager->GetDisplayInfo(primary_display.id()));
   display_info_list.push_back(
       display_manager->GetDisplayInfo(secondary_display.id()));
 
   display_manager->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(secondary_display.id(),
             display::Screen::GetScreen()->GetPrimaryDisplay().id());
   EXPECT_EQ(primary_display.id(), ScreenUtil::GetSecondaryDisplay().id());
   EXPECT_EQ(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               secondary_display.id()));
   EXPECT_NE(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               primary_display.id()));
   EXPECT_TRUE(primary_root->Contains(shelf_window));
 
   // Deleting 2nd display and adding 2nd display with a different ID.  The 2nd
   // display shouldn't become primary.
   UpdateDisplay("200x200");
-  DisplayInfo third_display_info(secondary_display.id() + 1, std::string(),
-                                 false);
+  display::ManagedDisplayInfo third_display_info(secondary_display.id() + 1,
+                                                 std::string(), false);
   third_display_info.SetBounds(secondary_display.bounds());
   ASSERT_NE(primary_display.id(), third_display_info.id());
 
-  const DisplayInfo& primary_display_info =
+  const display::ManagedDisplayInfo& primary_display_info =
       display_manager->GetDisplayInfo(primary_display.id());
-  std::vector<DisplayInfo> display_info_list2;
+  std::vector<display::ManagedDisplayInfo> display_info_list2;
   display_info_list2.push_back(primary_display_info);
   display_info_list2.push_back(third_display_info);
   display_manager->OnNativeDisplaysChanged(display_info_list2);
   EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(primary_display.id(),
             display::Screen::GetScreen()->GetPrimaryDisplay().id());
   EXPECT_EQ(third_display_info.id(), ScreenUtil::GetSecondaryDisplay().id());
   EXPECT_EQ(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               primary_display.id()));
   EXPECT_NE(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
@@ skipping 276 matching lines @@
 // Make sure that the compositor based mirroring can switch
 // from/to dock mode.
 TEST_P(WindowTreeHostManagerTest, DockToSingle) {
   if (!SupportsMultipleDisplays())
     return;
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
   const int64_t internal_id = 1;
 
-  const DisplayInfo internal_display_info =
+  const display::ManagedDisplayInfo internal_display_info =
       CreateDisplayInfo(internal_id, 0, display::Display::ROTATE_0);
-  const DisplayInfo external_display_info =
+  const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(2, 1, display::Display::ROTATE_90);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   // Extended
   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);
   EXPECT_EQ(2U, display_manager->GetNumDisplays());
 
   // Dock mode.
@@ skipping 17 matching lines @@
                   .IsIdentityOrIntegerTranslation());
 }
 
 // Tests if switching two displays at the same time while the primary display
 // is swapped should not cause a crash. (crbug.com/426292)
 TEST_P(WindowTreeHostManagerTest, ReplaceSwappedPrimary) {
   if (!SupportsMultipleDisplays())
     return;
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
-  const DisplayInfo first_display_info =
+  const display::ManagedDisplayInfo first_display_info =
       CreateDisplayInfo(10, 0, display::Display::ROTATE_0);
-  const DisplayInfo second_display_info =
+  const display::ManagedDisplayInfo second_display_info =
       CreateDisplayInfo(11, 1, display::Display::ROTATE_0);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   // Extended
   display_info_list.push_back(first_display_info);
   display_info_list.push_back(second_display_info);
   display_manager->OnNativeDisplaysChanged(display_info_list);
 
   test::SwapPrimaryDisplay();
 
   EXPECT_EQ(11, display::Screen::GetScreen()->GetPrimaryDisplay().id());
 
   display_info_list.clear();
-  const DisplayInfo new_first_display_info =
+  const display::ManagedDisplayInfo new_first_display_info =
       CreateDisplayInfo(20, 0, display::Display::ROTATE_0);
-  const DisplayInfo new_second_display_info =
+  const display::ManagedDisplayInfo new_second_display_info =
       CreateDisplayInfo(21, 1, display::Display::ROTATE_0);
   display_info_list.push_back(new_first_display_info);
   display_info_list.push_back(new_second_display_info);
   display_manager->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(20, display::Screen::GetScreen()->GetPrimaryDisplay().id());
 }
 
 namespace {
 
@@ skipping 25 matching lines @@
 // when the primary display gets replaced in one of the following scenarios:
 // 1) Two displays connected: a) b)
 // 2) both are disconnected and new one with the same size as b) is connected
 // in one configuration event.
 // See crbug.com/547280.
 TEST_P(WindowTreeHostManagerTest, ReplacePrimary) {
   if (!SupportsMultipleDisplays())
     return;
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
-  DisplayInfo first_display_info =
+  display::ManagedDisplayInfo first_display_info =
       CreateDisplayInfo(10, 0, display::Display::ROTATE_0);
   first_display_info.SetBounds(gfx::Rect(0, 0, 400, 400));
-  const DisplayInfo second_display_info =
+  const display::ManagedDisplayInfo second_display_info =
       CreateDisplayInfo(11, 500, display::Display::ROTATE_0);
 
-  std::vector<DisplayInfo> display_info_list;
+  std::vector<display::ManagedDisplayInfo> display_info_list;
   // Extended
   display_info_list.push_back(first_display_info);
   display_info_list.push_back(second_display_info);
   display_manager->OnNativeDisplaysChanged(display_info_list);
   aura::Window* primary_root = Shell::GetAllRootWindows()[0];
 
   int64_t new_display_id = 20;
   RootWindowTestObserver test_observer;
   primary_root->AddObserver(&test_observer);
 
   display_info_list.clear();
-  const DisplayInfo new_first_display_info =
+  const display::ManagedDisplayInfo new_first_display_info =
       CreateDisplayInfo(new_display_id, 0, display::Display::ROTATE_0);
 
   display_info_list.push_back(new_first_display_info);
   display_manager->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ("0,0 500x500", test_observer.shelf_display_bounds().ToString());
   primary_root->RemoveObserver(&test_observer);
 }
 
 TEST_P(WindowTreeHostManagerTest, UpdateMouseLocationAfterDisplayChange) {
   if (!SupportsMultipleDisplays())
@@ skipping 169 matching lines @@
       widget->GetNativeWindow()->GetRootWindow());
   event_generator.MoveMouseToCenterOf(widget->GetNativeWindow());
 
   UpdateDisplay("300x300");
   watcher.Stop();
 
   widget->CloseNow();
 }
 
 }  // namespace ash