Separate ash::test::DisplayManagerTestApi from ash

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/material_design/material_design_controller.h"
@@ skipping 173 matching lines @@
 display::Display GetPrimaryDisplay() {
   return display::Screen::GetScreen()->GetDisplayNearestWindow(
       Shell::GetAllRootWindows()[0]);
 }
 
 display::Display GetSecondaryDisplay() {
   return display::Screen::GetScreen()->GetDisplayNearestWindow(
       Shell::GetAllRootWindows()[1]);
 }
 
-void SetSecondaryDisplayLayoutAndOffset(
+class TestHelper {
+ public:
+  explicit TestHelper(test::AshTestBase* delegate);
+  ~TestHelper();
+
+  void SetSecondaryDisplayLayoutAndOffset(
+      display::DisplayPlacement::Position position,
+      int offset);
+
+  void SetSecondaryDisplayLayout(display::DisplayPlacement::Position position);
+
+  void SetDefaultDisplayLayout(display::DisplayPlacement::Position position);
+
+  float GetStoredUIScale(int64_t id);
+
+ private:
+  test::AshTestBase* delegate_;  // Not owned
+  DISALLOW_COPY_AND_ASSIGN(TestHelper);
+};
+
+TestHelper::TestHelper(test::AshTestBase* delegate) : delegate_(delegate) {}
+TestHelper::~TestHelper() {}
+
+void TestHelper::SetSecondaryDisplayLayoutAndOffset(
     display::DisplayPlacement::Position position,
     int offset) {
-  std::unique_ptr<display::DisplayLayout> layout(
-      test::CreateDisplayLayout(position, offset));
+  std::unique_ptr<display::DisplayLayout> layout(test::CreateDisplayLayout(
+      delegate_->display_manager(), position, offset));
   ASSERT_GT(display::Screen::GetScreen()->GetNumDisplays(), 1);
-  Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
-      std::move(layout));
+  delegate_->display_manager()->SetLayoutForCurrentDisplays(std::move(layout));
 }
 
-void SetSecondaryDisplayLayout(display::DisplayPlacement::Position position) {
+void TestHelper::SetSecondaryDisplayLayout(
+    display::DisplayPlacement::Position position) {
   SetSecondaryDisplayLayoutAndOffset(position, 0);
 }
 
-void SetDefaultDisplayLayout(display::DisplayPlacement::Position position) {
+void TestHelper::SetDefaultDisplayLayout(
+    display::DisplayPlacement::Position position) {
   display::DisplayPlacement default_placement(position, 0);
-
-  Shell::GetInstance()
-      ->display_manager()
-      ->layout_store()
-      ->SetDefaultDisplayPlacement(default_placement);
+  delegate_->display_manager()->layout_store()->SetDefaultDisplayPlacement(
+      default_placement);
 }
 
-class WindowTreeHostManagerShutdownTest : public test::AshTestBase {
+float TestHelper::GetStoredUIScale(int64_t id) {
+  return delegate_->display_manager()->GetDisplayInfo(id).GetEffectiveUIScale();
+}
+
+class WindowTreeHostManagerShutdownTest : public test::AshTestBase,
+                                          public TestHelper {
  public:
-  WindowTreeHostManagerShutdownTest() {}
+  WindowTreeHostManagerShutdownTest() : TestHelper(this) {}
   ~WindowTreeHostManagerShutdownTest() override {}
 
   void TearDown() override {
     test::AshTestBase::TearDown();
     if (!SupportsMultipleDisplays())
       return;
 
     // Make sure that primary display is accessible after shutdown.
     display::Display primary =
         display::Screen::GetScreen()->GetPrimaryDisplay();
@@ skipping 23 matching lines @@
   }
 
   bool displays_initialized() const { return displays_initialized_; }
 
  private:
   bool displays_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(StartupHelper);
 };
 
-class WindowTreeHostManagerStartupTest : public test::AshTestBase {
+class WindowTreeHostManagerStartupTest : public test::AshTestBase,
+                                         public TestHelper {
  public:
-  WindowTreeHostManagerStartupTest() : startup_helper_(new StartupHelper) {}
+  WindowTreeHostManagerStartupTest()
+      : TestHelper(this), startup_helper_(new StartupHelper) {}
   ~WindowTreeHostManagerStartupTest() override {}
 
   // ash::test::AshTestBase:
   void SetUp() override {
     ash_test_helper()->set_test_shell_delegate(startup_helper_);
     test::AshTestBase::SetUp();
   }
   void TearDown() override {
     Shell::GetInstance()->window_tree_host_manager()->RemoveObserver(
         startup_helper_);
@@ skipping 80 matching lines @@
   float touch_radius_x_;
   float touch_radius_y_;
   float scroll_x_offset_;
   float scroll_y_offset_;
   float scroll_x_offset_ordinal_;
   float scroll_y_offset_ordinal_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
 };
 
-float GetStoredUIScale(int64_t id) {
-  return Shell::GetInstance()
-      ->display_manager()
-      ->GetDisplayInfo(id)
-      .GetEffectiveUIScale();
-}
 
 class TestMouseWatcherListener : public views::MouseWatcherListener {
  public:
   TestMouseWatcherListener() {}
 
  private:
   // views::MouseWatcherListener:
   void MouseMovedOutOfHost() override {}
 
   DISALLOW_COPY_AND_ASSIGN(TestMouseWatcherListener);
 };
 
 }  // namespace
 
-using WindowTreeHostManagerTest = test::AshMDTestBase;
+class WindowTreeHostManagerTest : public test::AshMDTestBase,
+                                  public TestHelper {
+ public:
+  WindowTreeHostManagerTest() : TestHelper(this){};
+  ~WindowTreeHostManagerTest() override{};
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WindowTreeHostManagerTest);
+};
 
 INSTANTIATE_TEST_CASE_P(
     /* prefix intentionally left blank due to only one parameterization */,
     WindowTreeHostManagerTest,
     testing::Values(MaterialDesignController::NON_MATERIAL,
                     MaterialDesignController::MATERIAL_NORMAL,
                     MaterialDesignController::MATERIAL_EXPERIMENTAL));
 
 TEST_F(WindowTreeHostManagerShutdownTest, Shutdown) {
   if (!SupportsMultipleDisplays())
@@ skipping 18 matching lines @@
   w1->Focus();
 
   TestObserver observer;
   UpdateDisplay("500x500,400x400");
   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
   EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset());
   EXPECT_EQ(2, observer.GetWorkareaChangedCountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
   gfx::Insets insets(5, 5, 5, 5);
-  int64_t secondary_display_id = ScreenUtil::GetSecondaryDisplay().id();
-  Shell::GetInstance()->display_manager()->UpdateWorkAreaOfDisplay(
-      secondary_display_id, insets);
+  int64_t secondary_display_id = display_manager()->GetSecondaryDisplay().id();
+  display_manager()->UpdateWorkAreaOfDisplay(secondary_display_id, insets);
 
   // Default layout is RIGHT.
   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
   EXPECT_EQ("500,0 400x400", GetSecondaryDisplay().bounds().ToString());
   EXPECT_EQ("505,5 390x390", GetSecondaryDisplay().work_area().ToString());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
   // Layout the secondary display to the bottom of the primary.
   SetSecondaryDisplayLayout(display::DisplayPlacement::BOTTOM);
@@ skipping 136 matching lines @@
 
 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 display::ManagedDisplayInfo internal_display_info =
       CreateMirroredDisplayInfo(1, 2.0f);
   const display::ManagedDisplayInfo external_display_info =
       CreateMirroredDisplayInfo(2, 1.0f);
 
   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);
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
   const int64_t internal_display_id =
-      test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
+      test::DisplayManagerTestApi(display_manager())
+          .SetFirstDisplayAsInternalDisplay();
   EXPECT_EQ(1, internal_display_id);
-  EXPECT_EQ(2U, display_manager->num_connected_displays());
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
+  EXPECT_EQ(2U, display_manager()->num_connected_displays());
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&toggle_fullscreen_event);
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_EQ("0,0 250x250", w1->bounds().ToString());
   // Dock mode.
   TestObserver observer;
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
-  display_manager->OnNativeDisplaysChanged(display_info_list);
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
-  EXPECT_EQ(1U, display_manager->num_connected_displays());
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
+  EXPECT_EQ(1U, display_manager()->num_connected_displays());
   // Observers are called due to primary change.
   EXPECT_EQ(2, observer.GetChangedDisplayIdAndReset());
   EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset());
   EXPECT_EQ(1, observer.GetWorkareaChangedCountAndReset());
   EXPECT_EQ(1, observer.GetPrimaryChangedCountAndReset());
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_EQ("0,0 500x500", w1->bounds().ToString());
 }
 
 TEST_P(WindowTreeHostManagerTest, BoundsUpdated) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Creates windows to catch activation change event.
   std::unique_ptr<aura::Window> w1(CreateTestWindowInShellWithId(1));
   w1->Focus();
 
   TestObserver observer;
   SetDefaultDisplayLayout(display::DisplayPlacement::BOTTOM);
   UpdateDisplay("200x200,300x300");  // layout, resize and add.
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   gfx::Insets insets(5, 5, 5, 5);
-  display_manager->UpdateWorkAreaOfDisplay(
-      ScreenUtil::GetSecondaryDisplay().id(), insets);
+  display_manager()->UpdateWorkAreaOfDisplay(GetSecondaryDisplay().id(),
+                                             insets);
 
   EXPECT_EQ("0,0 200x200", GetPrimaryDisplay().bounds().ToString());
   EXPECT_EQ("0,200 300x300", GetSecondaryDisplay().bounds().ToString());
   EXPECT_EQ("5,205 290x290", GetSecondaryDisplay().work_area().ToString());
 
   UpdateDisplay("400x400,200x200");
   EXPECT_EQ(1, observer.CountAndReset());  // two resizes
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
   EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
@@ skipping 24 matching lines @@
   // No change
   UpdateDisplay("400x500*2,300x300");
   // We still call into Pre/PostDisplayConfigurationChange().
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
   // Rotation
   observer.GetRotationChangedCountAndReset();  // we only want to reset.
   int64_t primary_id = GetPrimaryDisplay().id();
-  display_manager->SetDisplayRotation(primary_id, display::Display::ROTATE_90,
-                                      display::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      primary_id, display::Display::ROTATE_90,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ(1, observer.GetRotationChangedCountAndReset());
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
-  display_manager->SetDisplayRotation(primary_id, display::Display::ROTATE_90,
-                                      display::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      primary_id, display::Display::ROTATE_90,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ(0, observer.GetRotationChangedCountAndReset());
   EXPECT_EQ(0, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
   // UI scale is eanbled only on internal display.
   int64_t secondary_id = GetSecondaryDisplay().id();
-  test::ScopedSetInternalDisplayId set_internal(secondary_id);
+  test::ScopedSetInternalDisplayId set_internal(display_manager(),
+                                                secondary_id);
   // Changing internal ID display changes the DisplayIdPair (it comes
   // first), which also changes the primary display candidate.  Update
   // the primary display manually to update the primary display to
   // avoid getting the OnDisplayConfigurationChanged() call twice in
   // SetDisplayUIScale. Note that this scenario will never happen on
   // real devices.
   Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
       secondary_id);
   EXPECT_EQ(1, observer.CountAndReset());
 
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(secondary_id,
-                                                             1.125f);
+  display_manager()->SetDisplayUIScale(secondary_id, 1.125f);
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(secondary_id,
-                                                             1.125f);
+  display_manager()->SetDisplayUIScale(secondary_id, 1.125f);
   EXPECT_EQ(0, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(primary_id,
-                                                             1.125f);
+  display_manager()->SetDisplayUIScale(primary_id, 1.125f);
   EXPECT_EQ(0, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(primary_id,
-                                                             1.125f);
+  display_manager()->SetDisplayUIScale(primary_id, 1.125f);
   EXPECT_EQ(0, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 }
 
 TEST_P(WindowTreeHostManagerTest, FindNearestDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   WindowTreeHostManager* window_tree_host_manager =
       Shell::GetInstance()->window_tree_host_manager();
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
   UpdateDisplay("200x200,300x300");
-  display_manager->SetLayoutForCurrentDisplays(
-      test::CreateDisplayLayout(display::DisplayPlacement::RIGHT, 50));
+  display_manager()->SetLayoutForCurrentDisplays(test::CreateDisplayLayout(
+      display_manager(), display::DisplayPlacement::RIGHT, 50));
 
   display::Display primary_display =
       display::Screen::GetScreen()->GetPrimaryDisplay();
-  display::Display secondary_display = ScreenUtil::GetSecondaryDisplay();
+  display::Display secondary_display = display_manager()->GetSecondaryDisplay();
   EXPECT_NE(primary_display.id(), secondary_display.id());
   aura::Window* primary_root =
       window_tree_host_manager->GetRootWindowForDisplayId(primary_display.id());
   aura::Window* secondary_root =
       window_tree_host_manager->GetRootWindowForDisplayId(
           secondary_display.id());
   EXPECT_NE(primary_root, secondary_root);
 
   // Test that points outside of any display return the nearest display.
   EXPECT_EQ(primary_display.id(),
@@ skipping 34 matching lines @@
                 .id());
 }
 
 TEST_P(WindowTreeHostManagerTest, SwapPrimaryById) {
   if (!SupportsMultipleDisplays())
     return;
   const int height_offset = GetMdMaximizedWindowHeightOffset();
 
   WindowTreeHostManager* window_tree_host_manager =
       Shell::GetInstance()->window_tree_host_manager();
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
   UpdateDisplay("200x200,300x300");
   display::Display primary_display =
       display::Screen::GetScreen()->GetPrimaryDisplay();
-  display::Display secondary_display = ScreenUtil::GetSecondaryDisplay();
+  display::Display secondary_display = display_manager()->GetSecondaryDisplay();
 
-  display_manager->SetLayoutForCurrentDisplays(
-      test::CreateDisplayLayout(display::DisplayPlacement::RIGHT, 50));
+  display_manager()->SetLayoutForCurrentDisplays(test::CreateDisplayLayout(
+      display_manager(), display::DisplayPlacement::RIGHT, 50));
 
   EXPECT_NE(primary_display.id(), secondary_display.id());
   aura::Window* primary_root =
       window_tree_host_manager->GetRootWindowForDisplayId(primary_display.id());
   aura::Window* secondary_root =
       window_tree_host_manager->GetRootWindowForDisplayId(
           secondary_display.id());
   aura::Window* shelf_window =
       GetPrimaryShelf()->shelf_widget()->GetNativeView();
   EXPECT_TRUE(primary_root->Contains(shelf_window));
   EXPECT_FALSE(secondary_root->Contains(shelf_window));
   EXPECT_NE(primary_root, secondary_root);
   EXPECT_EQ(primary_display.id(),
             display::Screen::GetScreen()
                 ->GetDisplayNearestPoint(gfx::Point(-100, -100))
                 .id());
   EXPECT_EQ(
       primary_display.id(),
       display::Screen::GetScreen()->GetDisplayNearestWindow(nullptr).id());
 
   EXPECT_EQ("0,0 200x200", primary_display.bounds().ToString());
   EXPECT_EQ(gfx::Rect(0, 0, 200, 153 + height_offset).ToString(),
             primary_display.work_area().ToString());
   EXPECT_EQ("200,0 300x300", secondary_display.bounds().ToString());
   EXPECT_EQ(gfx::Rect(200, 0, 300, 253 + height_offset).ToString(),
             secondary_display.work_area().ToString());
-  EXPECT_EQ(
-      "id=2200000001, parent=2200000000, right, 50",
-      display_manager->GetCurrentDisplayLayout().placement_list[0].ToString());
+  EXPECT_EQ("id=2200000001, parent=2200000000, right, 50",
+            display_manager()
+                ->GetCurrentDisplayLayout()
+                .placement_list[0]
+                .ToString());
 
   // Switch primary and secondary by display ID.
   TestObserver observer;
   window_tree_host_manager->SetPrimaryDisplayId(secondary_display.id());
   EXPECT_EQ(secondary_display.id(),
             display::Screen::GetScreen()->GetPrimaryDisplay().id());
-  EXPECT_EQ(primary_display.id(), ScreenUtil::GetSecondaryDisplay().id());
+  EXPECT_EQ(primary_display.id(),
+            display_manager()->GetSecondaryDisplay().id());
   EXPECT_LT(0, observer.CountAndReset());
 
   EXPECT_EQ(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               secondary_display.id()));
   EXPECT_EQ(secondary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                                 primary_display.id()));
   EXPECT_TRUE(primary_root->Contains(shelf_window));
   EXPECT_FALSE(secondary_root->Contains(shelf_window));
 
   const display::DisplayLayout& inverted_layout =
-      display_manager->GetCurrentDisplayLayout();
+      display_manager()->GetCurrentDisplayLayout();
 
   EXPECT_EQ("id=2200000000, parent=2200000001, left, -50",
             inverted_layout.placement_list[0].ToString());
   // Test if the bounds are correctly swapped.
   display::Display swapped_primary =
       display::Screen::GetScreen()->GetPrimaryDisplay();
-  display::Display swapped_secondary = ScreenUtil::GetSecondaryDisplay();
+  display::Display swapped_secondary = display_manager()->GetSecondaryDisplay();
   EXPECT_EQ("0,0 300x300", swapped_primary.bounds().ToString());
   EXPECT_EQ(gfx::Rect(0, 0, 300, 253 + height_offset).ToString(),
             swapped_primary.work_area().ToString());
   EXPECT_EQ("-200,-50 200x200", swapped_secondary.bounds().ToString());
   EXPECT_EQ(gfx::Rect(-200, -50, 200, 153 + height_offset).ToString(),
             swapped_secondary.work_area().ToString());
 
   // Calling the same ID don't do anything.
   window_tree_host_manager->SetPrimaryDisplayId(secondary_display.id());
   EXPECT_EQ(0, observer.CountAndReset());
@@ skipping 16 matching lines @@
       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<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(
-      display_manager->GetDisplayInfo(primary_display.id()));
+      display_manager()->GetDisplayInfo(primary_display.id()));
   display_info_list.push_back(
-      display_manager->GetDisplayInfo(secondary_display.id()));
+      display_manager()->GetDisplayInfo(secondary_display.id()));
 
-  display_manager->OnNativeDisplaysChanged(display_info_list);
+  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_display.id(),
+            display_manager()->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");
   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 display::ManagedDisplayInfo& primary_display_info =
-      display_manager->GetDisplayInfo(primary_display.id());
+      display_manager()->GetDisplayInfo(primary_display.id());
   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);
+  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(third_display_info.id(),
+            display_manager()->GetSecondaryDisplay().id());
   EXPECT_EQ(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               primary_display.id()));
   EXPECT_NE(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               third_display_info.id()));
   EXPECT_TRUE(primary_root->Contains(shelf_window));
 }
 
 TEST_P(WindowTreeHostManagerTest, NoSwapPrimaryWithThreeDisplays) {
   if (!SupportsMultipleDisplays())
     return;
   int64_t primary = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   UpdateDisplay("500x400,400x300,300x200");
   EXPECT_EQ(primary, display::Screen::GetScreen()->GetPrimaryDisplay().id());
   Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
-      ScreenUtil::GetSecondaryDisplay().id());
+      display_manager()->GetSecondaryDisplay().id());
   EXPECT_EQ(primary, display::Screen::GetScreen()->GetPrimaryDisplay().id());
 }
 
 TEST_P(WindowTreeHostManagerTest, OverscanInsets) {
   if (!SupportsMultipleDisplays())
     return;
 
   WindowTreeHostManager* window_tree_host_manager =
       Shell::GetInstance()->window_tree_host_manager();
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("120x200,300x400*2");
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   window_tree_host_manager->SetOverscanInsets(display1.id(),
                                               gfx::Insets(10, 15, 20, 25));
   EXPECT_EQ("0,0 80x170", root_windows[0]->bounds().ToString());
   EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
   EXPECT_EQ("80,0 150x200",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
 
   ui::test::EventGenerator generator(root_windows[0]);
   generator.MoveMouseToInHost(20, 25);
   EXPECT_EQ("5,15", event_handler.GetLocationAndReset());
 
   window_tree_host_manager->SetOverscanInsets(display1.id(), gfx::Insets());
   EXPECT_EQ("0,0 120x200", root_windows[0]->bounds().ToString());
   EXPECT_EQ("120,0 150x200",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
 
   generator.MoveMouseToInHost(30, 20);
   EXPECT_EQ("30,20", event_handler.GetLocationAndReset());
 
   // Make sure the root window transformer uses correct scale
   // factor when swapping display. Test crbug.com/253690.
   UpdateDisplay("400x300*2,600x400/o");
   root_windows = Shell::GetAllRootWindows();
   gfx::Point point;
   Shell::GetAllRootWindows()[1]->GetHost()->GetRootTransform().TransformPoint(
       &point);
   EXPECT_EQ("15,10", point.ToString());
 
-  test::SwapPrimaryDisplay();
+  SwapPrimaryDisplay();
   point.SetPoint(0, 0);
   Shell::GetAllRootWindows()[1]->GetHost()->GetRootTransform().TransformPoint(
       &point);
   EXPECT_EQ("15,10", point.ToString());
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
 TEST_P(WindowTreeHostManagerTest, Rotate) {
   if (!SupportsMultipleDisplays())
     return;
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("120x200,300x400*2");
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
-  int64_t display2_id = ScreenUtil::GetSecondaryDisplay().id();
+  int64_t display2_id = display_manager()->GetSecondaryDisplay().id();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   ui::test::EventGenerator generator1(root_windows[0]);
 
   TestObserver observer;
   EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString());
   EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
   EXPECT_EQ("120,0 150x200",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
   generator1.MoveMouseToInHost(50, 40);
   EXPECT_EQ("50,40", event_handler.GetLocationAndReset());
   EXPECT_EQ(display::Display::ROTATE_0,
             GetActiveDisplayRotation(display1.id()));
   EXPECT_EQ(display::Display::ROTATE_0, GetActiveDisplayRotation(display2_id));
   EXPECT_EQ(0, observer.GetRotationChangedCountAndReset());
 
-  display_manager->SetDisplayRotation(display1.id(),
-                                      display::Display::ROTATE_90,
-                                      display::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      display1.id(), display::Display::ROTATE_90,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString());
   EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
   EXPECT_EQ("200,0 150x200",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
   generator1.MoveMouseToInHost(50, 40);
   EXPECT_EQ("40,69", event_handler.GetLocationAndReset());
   EXPECT_EQ(display::Display::ROTATE_90,
             GetActiveDisplayRotation(display1.id()));
   EXPECT_EQ(display::Display::ROTATE_0, GetActiveDisplayRotation(display2_id));
   EXPECT_EQ(1, observer.GetRotationChangedCountAndReset());
 
-  display_manager->SetLayoutForCurrentDisplays(
-      test::CreateDisplayLayout(display::DisplayPlacement::BOTTOM, 50));
+  display_manager()->SetLayoutForCurrentDisplays(test::CreateDisplayLayout(
+      display_manager(), display::DisplayPlacement::BOTTOM, 50));
   EXPECT_EQ("50,120 150x200",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
 
-  display_manager->SetDisplayRotation(display2_id, display::Display::ROTATE_270,
-                                      display::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      display2_id, display::Display::ROTATE_270,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString());
   EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString());
   EXPECT_EQ("50,120 200x150",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
   EXPECT_EQ(display::Display::ROTATE_90,
             GetActiveDisplayRotation(display1.id()));
   EXPECT_EQ(display::Display::ROTATE_270,
             GetActiveDisplayRotation(display2_id));
   EXPECT_EQ(1, observer.GetRotationChangedCountAndReset());
 
 #if !defined(OS_WIN)
   ui::test::EventGenerator generator2(root_windows[1]);
   generator2.MoveMouseToInHost(50, 40);
   EXPECT_EQ("179,25", event_handler.GetLocationAndReset());
-  display_manager->SetDisplayRotation(display1.id(),
-                                      display::Display::ROTATE_180,
-                                      display::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      display1.id(), display::Display::ROTATE_180,
+      display::Display::ROTATION_SOURCE_ACTIVE);
 
   EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString());
   EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString());
   // Dislay must share at least 100, so the x's offset becomes 20.
   EXPECT_EQ("20,200 200x150",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
   EXPECT_EQ(display::Display::ROTATE_180,
             GetActiveDisplayRotation(display1.id()));
   EXPECT_EQ(display::Display::ROTATE_270,
             GetActiveDisplayRotation(display2_id));
   EXPECT_EQ(1, observer.GetRotationChangedCountAndReset());
 
   generator1.MoveMouseToInHost(50, 40);
   EXPECT_EQ("69,159", event_handler.GetLocationAndReset());
 #endif
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
 TEST_P(WindowTreeHostManagerTest, ScaleRootWindow) {
   if (!SupportsMultipleDisplays())
     return;
 
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("600x400*2@1.5,500x300");
 
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
-  test::ScopedSetInternalDisplayId set_internal(display1.id());
+  test::ScopedSetInternalDisplayId set_internal(display_manager(),
+                                                display1.id());
 
-  display::Display display2 = ScreenUtil::GetSecondaryDisplay();
+  display::Display display2 = display_manager()->GetSecondaryDisplay();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ("0,0 450x300", display1.bounds().ToString());
   EXPECT_EQ("0,0 450x300", root_windows[0]->bounds().ToString());
   EXPECT_EQ("450,0 500x300", display2.bounds().ToString());
   EXPECT_EQ(1.5f, GetStoredUIScale(display1.id()));
   EXPECT_EQ(1.0f, GetStoredUIScale(display2.id()));
 
   ui::test::EventGenerator generator(root_windows[0]);
   generator.MoveMouseToInHost(599, 200);
   EXPECT_EQ("449,150", event_handler.GetLocationAndReset());
 
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(display1.id(),
-                                                             1.25f);
+  display_manager()->SetDisplayUIScale(display1.id(), 1.25f);
   display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
-  display2 = ScreenUtil::GetSecondaryDisplay();
+  display2 = display_manager()->GetSecondaryDisplay();
   EXPECT_EQ("0,0 375x250", display1.bounds().ToString());
   EXPECT_EQ("0,0 375x250", root_windows[0]->bounds().ToString());
   EXPECT_EQ("375,0 500x300", display2.bounds().ToString());
   EXPECT_EQ(1.25f, GetStoredUIScale(display1.id()));
   EXPECT_EQ(1.0f, GetStoredUIScale(display2.id()));
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
 TEST_P(WindowTreeHostManagerTest, TouchScale) {
@@ skipping 87 matching lines @@
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
 // 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 display::ManagedDisplayInfo internal_display_info =
       CreateDisplayInfo(internal_id, 0, display::Display::ROTATE_0);
   const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(2, 1, display::Display::ROTATE_90);
 
   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);
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
   const int64_t internal_display_id =
-      test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
+      test::DisplayManagerTestApi(display_manager())
+          .SetFirstDisplayAsInternalDisplay();
   EXPECT_EQ(internal_id, internal_display_id);
-  EXPECT_EQ(2U, display_manager->GetNumDisplays());
+  EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 
   // Dock mode.
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
-  display_manager->OnNativeDisplaysChanged(display_info_list);
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_FALSE(Shell::GetPrimaryRootWindow()
                    ->GetHost()
                    ->GetRootTransform()
                    .IsIdentityOrIntegerTranslation());
 
   // Switch to single mode and make sure the transform is the one
   // for the internal display.
   display_info_list.clear();
   display_info_list.push_back(internal_display_info);
-  display_manager->OnNativeDisplaysChanged(display_info_list);
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_TRUE(Shell::GetPrimaryRootWindow()
                   ->GetHost()
                   ->GetRootTransform()
                   .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 display::ManagedDisplayInfo first_display_info =
       CreateDisplayInfo(10, 0, display::Display::ROTATE_0);
   const display::ManagedDisplayInfo second_display_info =
       CreateDisplayInfo(11, 1, display::Display::ROTATE_0);
 
   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);
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
 
-  test::SwapPrimaryDisplay();
+  SwapPrimaryDisplay();
 
   EXPECT_EQ(11, display::Screen::GetScreen()->GetPrimaryDisplay().id());
 
   display_info_list.clear();
   const display::ManagedDisplayInfo new_first_display_info =
       CreateDisplayInfo(20, 0, display::Display::ROTATE_0);
   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);
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(20, display::Screen::GetScreen()->GetPrimaryDisplay().id());
 }
 
 namespace {
 
 class RootWindowTestObserver : public aura::WindowObserver {
  public:
   RootWindowTestObserver() {}
   ~RootWindowTestObserver() override {}
@@ skipping 19 matching lines @@
 
 // Make sure that GetDisplayBoundsWithShelf returns the correct bounds
 // 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();
 
   display::ManagedDisplayInfo first_display_info =
       CreateDisplayInfo(10, 0, display::Display::ROTATE_0);
   first_display_info.SetBounds(gfx::Rect(0, 0, 400, 400));
   const display::ManagedDisplayInfo second_display_info =
       CreateDisplayInfo(11, 500, display::Display::ROTATE_0);
 
   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);
+  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 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);
+  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())
     return;
 
   UpdateDisplay("200x200,300x300");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
@@ skipping 33 matching lines @@
   UpdateDisplay("300x280,200x200");
   EXPECT_EQ("450,10", env->last_mouse_location().ToString());
 }
 
 TEST_P(WindowTreeHostManagerTest,
        UpdateMouseLocationAfterDisplayChange_2ndOnLeft) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Set the 2nd display on the left.
-  display::DisplayLayoutStore* layout_store =
-      Shell::GetInstance()->display_manager()->layout_store();
+  display::DisplayLayoutStore* layout_store = display_manager()->layout_store();
   display::DisplayPlacement new_default(display::DisplayPlacement::LEFT, 0);
   layout_store->SetDefaultDisplayPlacement(new_default);
 
   UpdateDisplay("200x200,300x300");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   EXPECT_EQ("-300,0 300x300",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
 
   aura::Env* env = aura::Env::GetInstance();
 
   // Set the initial position.
   root_windows[0]->MoveCursorTo(gfx::Point(-150, 250));
   EXPECT_EQ("-150,250", env->last_mouse_location().ToString());
 
   // A mouse pointer will stay in 2nd display.
   UpdateDisplay("300x300,200x300");
   EXPECT_EQ("-50,150", env->last_mouse_location().ToString());
@@ skipping 24 matching lines @@
       shell->window_tree_host_manager();
   test::CursorManagerTestApi test_api(shell->cursor_manager());
 
   window_tree_host_manager->GetPrimaryRootWindow()->MoveCursorTo(
       gfx::Point(20, 50));
 
   EXPECT_EQ("20,50", env->last_mouse_location().ToString());
   EXPECT_EQ(1.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_0, test_api.GetCurrentCursorRotation());
 
-  test::SwapPrimaryDisplay();
+  SwapPrimaryDisplay();
 
   EXPECT_EQ("20,50", env->last_mouse_location().ToString());
   EXPECT_EQ(2.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_90, test_api.GetCurrentCursorRotation());
 }
 
 // Test that the cursor moves to the other display and that its scale factor
 // and rotation are updated when the primary display is disconnected.
 TEST_P(WindowTreeHostManagerTest,
        UpdateMouseLocationAfterDisplayChange_PrimaryDisconnected) {
   if (!SupportsMultipleDisplays())
     return;
 
   aura::Env* env = aura::Env::GetInstance();
   Shell* shell = Shell::GetInstance();
   WindowTreeHostManager* window_tree_host_manager =
       shell->window_tree_host_manager();
   test::CursorManagerTestApi test_api(shell->cursor_manager());
 
   UpdateDisplay("300x300*2/r,200x200");
   // Swap the primary display to make it possible to remove the primary display
   // via UpdateDisplay().
-  test::SwapPrimaryDisplay();
+  SwapPrimaryDisplay();
   int primary_display_id = window_tree_host_manager->GetPrimaryDisplayId();
 
   window_tree_host_manager->GetPrimaryRootWindow()->MoveCursorTo(
       gfx::Point(20, 50));
 
   EXPECT_EQ("20,50", env->last_mouse_location().ToString());
   EXPECT_EQ(1.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_0, test_api.GetCurrentCursorRotation());
 
   UpdateDisplay("300x300*2/r");
   ASSERT_NE(primary_display_id,
             window_tree_host_manager->GetPrimaryDisplayId());
 
   // Cursor should be centered on the remaining display.
   EXPECT_EQ("75,75", env->last_mouse_location().ToString());
   EXPECT_EQ(2.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_90, test_api.GetCurrentCursorRotation());
 }
 
 // GetRootWindowForDisplayId() for removed display::Display during
 // OnDisplayRemoved() should not cause crash. See http://crbug.com/415222
 TEST_P(WindowTreeHostManagerTest,
        GetRootWindowForDisplayIdDuringDisplayDisconnection) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x300,200x200");
-  aura::Window* root2 =
-      Shell::GetInstance()
-          ->window_tree_host_manager()
-          ->GetRootWindowForDisplayId(ScreenUtil::GetSecondaryDisplay().id());
+  aura::Window* root2 = Shell::GetInstance()
+                            ->window_tree_host_manager()
+                            ->GetRootWindowForDisplayId(
+                                display_manager()->GetSecondaryDisplay().id());
   views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
       nullptr, root2, gfx::Rect(350, 0, 100, 100));
   views::View* view = new views::View();
   widget->GetContentsView()->AddChildView(view);
   view->SetBounds(0, 0, 100, 100);
   widget->Show();
 
   TestMouseWatcherListener listener;
   views::MouseWatcher watcher(
       new views::MouseWatcherViewHost(view, gfx::Insets()), &listener);
   watcher.Start();
 
   ui::test::EventGenerator event_generator(
       widget->GetNativeWindow()->GetRootWindow());
   event_generator.MoveMouseToCenterOf(widget->GetNativeWindow());
 
   UpdateDisplay("300x300");
   watcher.Stop();
 
   widget->CloseNow();
 }
 
 }  // namespace ash