Separate ash::test::DisplayManagerTestApi from ash

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/material_design/material_design_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/display/display_configuration_controller.h"
@@ skipping 58 matching lines @@
     AshMDTestBase::SetUp();
     display::Screen::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
   void TearDown() override {
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
     display::Screen::GetScreen()->RemoveObserver(this);
     AshMDTestBase::TearDown();
   }
 
-  DisplayManager* display_manager() {
-    return Shell::GetInstance()->display_manager();
-  }
   const vector<display::Display>& changed() const { return changed_; }
   const vector<display::Display>& added() const { return added_; }
   uint32_t changed_metrics() const { return changed_metrics_; }
 
   string GetCountSummary() const {
     return StringPrintf("%" PRIuS " %" PRIuS " %" PRIuS, changed_.size(),
                         added_.size(), removed_count_);
   }
 
   void reset() {
@@ skipping 406 matching lines @@
   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());
   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());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
 
   // Make sure that SetOverscanInsets() is idempotent.
   display_manager()->SetOverscanInsets(display_info1.id(), gfx::Insets());
   display_manager()->SetOverscanInsets(display_info2.id(),
                                        gfx::Insets(13, 12, 11, 10));
   EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   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());
@@ skipping 36 matching lines @@
   EXPECT_EQ("0,501 400x400",
             updated_display_info2.bounds_in_native().ToString());
   EXPECT_EQ("376x380", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("4,5,6,7",
             updated_display_info2.overscan_insets_in_dip().ToString());
   EXPECT_EQ("8,10,12,14",
             updated_display_info2.GetOverscanInsetsInPixel().ToString());
 
   // Make sure switching primary display applies the overscan offset only once.
   ash::Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
-      ScreenUtil::GetSecondaryDisplay().id());
+      display_manager()->GetSecondaryDisplay().id());
   EXPECT_EQ("-500,0 500x500",
-            ScreenUtil::GetSecondaryDisplay().bounds().ToString());
-  EXPECT_EQ("0,0 500x500", GetDisplayInfo(ScreenUtil::GetSecondaryDisplay())
-                               .bounds_in_native()
-                               .ToString());
+            display_manager()->GetSecondaryDisplay().bounds().ToString());
+  EXPECT_EQ("0,0 500x500",
+            GetDisplayInfo(display_manager()->GetSecondaryDisplay())
+                .bounds_in_native()
+                .ToString());
   EXPECT_EQ("0,501 400x400",
             GetDisplayInfo(display::Screen::GetScreen()->GetPrimaryDisplay())
                 .bounds_in_native()
                 .ToString());
   EXPECT_EQ(
       "0,0 188x190",
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 
   // Make sure just moving the overscan area should property notify observers.
   UpdateDisplay("0+0-500x500");
@@ skipping 66 matching lines @@
 
 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();
+      test::DisplayManagerTestApi(display_manager())
+          .SetFirstDisplayAsInternalDisplay();
   const int external_id = 10;
   const int mirror_id = 11;
   const int64_t invalid_id = display::Display::kInvalidDisplayID;
   const display::ManagedDisplayInfo internal_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   const display::ManagedDisplayInfo mirroring_display_info =
       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 
@@ skipping 151 matching lines @@
 
 // Make sure crash does not happen if add and remove happens at the same time.
 // 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();
+  const int64_t secondary_id = display_manager()->GetSecondaryDisplay().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;
 
   display::ManagedDisplayInfo third_info =
       CreateDisplayInfo(third_id, gfx::Rect(0, 0, 600, 600));
 
   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(third_id, display_manager()->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.
@@ skipping 15 matching lines @@
                            .size()
                            .ToString());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
 
   const int64_t internal_display_id =
-      test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
+      test::DisplayManagerTestApi(display_manager())
+          .SetFirstDisplayAsInternalDisplay();
   const display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const display::ManagedDisplayInfo secondary_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
 
   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());
@@ skipping 39 matching lines @@
   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));
+  test::SetDisplayResolution(display_manager(), 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));
+  test::SetDisplayResolution(display_manager(), 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 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));
+  test::SetDisplayResolution(display_manager(), 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 display::ManagedDisplayMode(gfx::Size(1000, 500), 0.0f, false, false);
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
@@ skipping 15 matching lines @@
   display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
       gfx::Size(400, 500), 60.0f, false, false)));
 
   display::ManagedDisplayInfo::ManagedDisplayModeList copy = display_modes;
   native_display_info.SetManagedDisplayModes(copy);
 
   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));
+    test::SetDisplayResolution(display_manager(), display_id,
+                               gfx::Size(800, 300));
     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<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<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));
+    test::SetDisplayResolution(display_manager(), display_id,
+                               gfx::Size(800, 300));
     display::ManagedDisplayInfo new_native_display_info =
         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
     display::ManagedDisplayInfo::ManagedDisplayModeList copy = display_modes;
     new_native_display_info.SetManagedDisplayModes(copy);
     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<display::ManagedDisplayMode> mode =
         display_manager()->GetSelectedModeForDisplayId(display_id);
@@ skipping 50 matching lines @@
   EXPECT_EQ("1 0 0", GetCountSummary());
   reset();
 
   UpdateDisplay("200x200/l");
   EXPECT_EQ("1 0 0", GetCountSummary());
 
   // Having the internal display deactivated should restore user rotation. Newly
   // set rotations should be applied.
   UpdateDisplay("200x200, 200x200");
   const int64_t internal_display_id =
-      test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
+      test::DisplayManagerTestApi(display_manager())
+          .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 display::ManagedDisplayInfo info =
       GetDisplayInfoForId(internal_display_id);
   EXPECT_EQ(display::Display::ROTATE_0, info.GetActiveRotation());
 
   // Deactivate internal display to simulate Docked Mode.
   vector<display::ManagedDisplayInfo> secondary_only;
   secondary_only.push_back(GetDisplayInfoAt(1));
   display_manager()->OnNativeDisplaysChanged(secondary_only);
 
-  const display::ManagedDisplayInfo post_removal_info =
-      display_manager()->display_info_[internal_display_id];
+  const display::ManagedDisplayInfo& post_removal_info =
+      test::DisplayManagerTestApi(display_manager())
+          .GetInternalManagedDisplayInfo(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 display::ManagedDisplayInfo post_rotation_info =
-      display_manager()->display_info_[internal_display_id];
+  const display::ManagedDisplayInfo& post_rotation_info =
+      test::DisplayManagerTestApi(display_manager())
+          .GetInternalManagedDisplayInfo(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;
 
   UpdateDisplay("1280x800");
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display_manager()->SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.0, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 
-  test::ScopedSetInternalDisplayId set_internal(display_id);
+  test::ScopedSetInternalDisplayId set_internal(display_manager(), display_id);
 
   display_manager()->SetDisplayUIScale(display_id, 1.5f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.75f);
@@ skipping 81 matching lines @@
   native_display_info.SetManagedDisplayModes(mode_list);
 
   std::vector<display::ManagedDisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   scoped_refptr<display::ManagedDisplayMode> expected_mode = base_mode;
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
-  test::ScopedSetInternalDisplayId set_internal(display_id);
+  test::ScopedSetInternalDisplayId set_internal(display_manager(), display_id);
 
   display_manager()->SetDisplayUIScale(display_id, 1.5f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   display_manager()->SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   display_manager()->SetDisplayUIScale(display_id, 1.125f);
@@ skipping 44 matching lines @@
 
   EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, Use125DSFForUIScaling) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
-  test::ScopedSetInternalDisplayId set_internal(display_id);
+  test::ScopedSetInternalDisplayId set_internal(display_manager(), display_id);
   UpdateDisplay("1920x1080*1.25");
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 
   display_manager()->SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("1536x864", GetDisplayForId(display_id).size().ToString());
 
   display_manager()->SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("960x540", GetDisplayForId(display_id).size().ToString());
 
   display_manager()->SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("2400x1350", GetDisplayForId(display_id).size().ToString());
 }
 #endif  // defined(OS_CHROMEOS)
 
 // 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);
+  test::ScopedSetInternalDisplayId set_internal(display_manager(), display_id);
 
   // Setup the display modes with UI-scale.
   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<display::ManagedDisplayMode>& base_mode(
       new display::ManagedDisplayMode(gfx::Size(1920, 1080), 60.0f, false,
                                       false));
   display::ManagedDisplayInfo::ManagedDisplayModeList mode_list =
@@ skipping 11 matching lines @@
 #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);
+  test::ScopedSetInternalDisplayId set_internal(display_manager(), 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.
   display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
@@ skipping 33 matching lines @@
   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<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_TRUE(test::SetDisplayResolution(display_manager(), unified_id,
+                                         gfx::Size(800, 400)));
   EXPECT_EQ(
       "800x400",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
 
   active_mode = display_manager()->GetActiveModeForDisplayId(unified_id);
   EXPECT_EQ(1.0f, active_mode->ui_scale());
   EXPECT_EQ("800x400", active_mode->size().ToString());
 
   // resolution change will not persist in unified desktop mode.
   UpdateDisplay("600x600, 200x200");
@@ skipping 96 matching lines @@
     return;
 
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(nullptr, test_api.GetHost());
 
   TestDisplayObserver display_observer;
   display::Screen::GetScreen()->AddObserver(&display_observer);
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  display_manager->SetMultiDisplayMode(DisplayManager::MIRRORING);
-  display_manager->UpdateDisplays();
+  display_manager()->SetMultiDisplayMode(DisplayManager::MIRRORING);
+  display_manager()->UpdateDisplays();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(display_observer.changed_and_reset());
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(
       "0,0 300x400",
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
   EXPECT_EQ("400x500", test_api.GetHost()->GetBounds().size().ToString());
   EXPECT_EQ("300x400",
             test_api.GetHost()->window()->bounds().size().ToString());
-  EXPECT_TRUE(display_manager->IsInMirrorMode());
+  EXPECT_TRUE(display_manager()->IsInMirrorMode());
 
-  display_manager->SetMirrorMode(false);
+  display_manager()->SetMirrorMode(false);
   EXPECT_TRUE(display_observer.changed_and_reset());
   EXPECT_EQ(nullptr, test_api.GetHost());
-  EXPECT_EQ(2U, display_manager->GetNumDisplays());
-  EXPECT_FALSE(display_manager->IsInMirrorMode());
+  EXPECT_EQ(2U, display_manager()->GetNumDisplays());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
 
   // Make sure the mirror window has the pixel size of the
   // source display.
-  display_manager->SetMirrorMode(true);
+  display_manager()->SetMirrorMode(true);
   EXPECT_TRUE(display_observer.changed_and_reset());
 
   UpdateDisplay("300x400@0.5,400x500");
   EXPECT_FALSE(display_observer.changed_and_reset());
   EXPECT_EQ("300x400",
             test_api.GetHost()->window()->bounds().size().ToString());
 
   UpdateDisplay("310x410*2,400x500");
   EXPECT_FALSE(display_observer.changed_and_reset());
   EXPECT_EQ("310x410",
@@ skipping 15 matching lines @@
   EXPECT_EQ("400x600",
             test_api.GetHost()->window()->bounds().size().ToString());
 
   display::Screen::GetScreen()->RemoveObserver(&display_observer);
 }
 
 TEST_P(DisplayManagerTest, RotateInSoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   UpdateDisplay("600x400,500x300");
-  display_manager->SetMirrorMode(true);
+  display_manager()->SetMirrorMode(true);
 
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
-  display_manager->SetDisplayRotation(primary_id, display::Display::ROTATE_180,
-                                      display::Display::ROTATION_SOURCE_ACTIVE);
-  display_manager->SetMirrorMode(false);
+  display_manager()->SetDisplayRotation(
+      primary_id, display::Display::ROTATE_180,
+      display::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetMirrorMode(false);
 }
 
 TEST_P(DisplayManagerTest, SingleDisplayToSoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("600x400");
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  display_manager->SetMultiDisplayMode(DisplayManager::MIRRORING);
+  display_manager()->SetMultiDisplayMode(DisplayManager::MIRRORING);
   UpdateDisplay("600x400,600x400");
 
-  EXPECT_TRUE(display_manager->IsInMirrorMode());
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
+  EXPECT_TRUE(display_manager()->IsInMirrorMode());
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   WindowTreeHostManager* window_tree_host_manager =
       ash::Shell::GetInstance()->window_tree_host_manager();
   EXPECT_TRUE(
       window_tree_host_manager->mirror_window_controller()->GetWindow());
 
   UpdateDisplay("600x400");
-  EXPECT_FALSE(display_manager->IsInMirrorMode());
-  EXPECT_EQ(1U, display_manager->GetNumDisplays());
+  EXPECT_FALSE(display_manager()->IsInMirrorMode());
+  EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_FALSE(
       window_tree_host_manager->mirror_window_controller()->GetWindow());
 }
 
 #if defined(OS_CHROMEOS)
 // Make sure this does not cause any crashes. See http://crbug.com/412910
 // This test is limited to OS_CHROMEOS because CursorCompositingEnabled is only
 // for ChromeOS.
 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();
   display::ManagedDisplayInfo secondary_info =
-      display_manager->GetDisplayInfo(ScreenUtil::GetSecondaryDisplay().id());
+      display_manager()->GetDisplayInfo(
+          display_manager()->GetSecondaryDisplay().id());
 
-  display_manager->SetSoftwareMirroring(true);
-  display_manager->UpdateDisplays();
+  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);
+  display_manager()->SetSoftwareMirroring(false);
   std::vector<display::ManagedDisplayInfo> new_info_list;
   new_info_list.push_back(secondary_info);
-  display_manager->OnNativeDisplaysChanged(new_info_list);
+  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
 
 TEST_P(DisplayManagerTest, MirroredLayout) {
   if (!SupportsMultipleDisplays())
     return;
 
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   UpdateDisplay("500x500,400x400");
-  EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
+  EXPECT_FALSE(display_manager()->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
-  EXPECT_EQ(2U, display_manager->num_connected_displays());
+  EXPECT_EQ(2U, display_manager()->num_connected_displays());
 
   UpdateDisplay("1+0-500x500,1+0-500x500");
-  EXPECT_TRUE(display_manager->GetCurrentDisplayLayout().mirrored);
+  EXPECT_TRUE(display_manager()->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());
-  EXPECT_EQ(2U, display_manager->num_connected_displays());
+  EXPECT_EQ(2U, display_manager()->num_connected_displays());
 
   UpdateDisplay("500x500,500x500");
-  EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
+  EXPECT_FALSE(display_manager()->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
-  EXPECT_EQ(2U, display_manager->num_connected_displays());
+  EXPECT_EQ(2U, display_manager()->num_connected_displays());
 }
 
 TEST_P(DisplayManagerTest, InvertLayout) {
   EXPECT_EQ("left, 0",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, 0)
                 .Swap()
                 .ToString());
   EXPECT_EQ("left, -100",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, 100)
                 .Swap()
@@ skipping 40 matching lines @@
   EXPECT_EQ("top, 80",
             display::DisplayPlacement(display::DisplayPlacement::BOTTOM, -80)
                 .Swap()
                 .ToString());
 }
 
 TEST_P(DisplayManagerTest, NotifyPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("500x500,500x500");
-  test::SwapPrimaryDisplay();
+  SwapPrimaryDisplay();
   reset();
   UpdateDisplay("500x500");
   EXPECT_FALSE(changed_metrics() &
                display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_FALSE(changed_metrics() &
                display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 
   UpdateDisplay("500x500,500x500");
-  test::SwapPrimaryDisplay();
+  SwapPrimaryDisplay();
   UpdateDisplay("500x400");
   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);
 }
 
 TEST_P(DisplayManagerTest, NotifyPrimaryChangeUndock) {
@@ skipping 88 matching lines @@
   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<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);
+    test::ScopedSetInternalDisplayId set_internal(display_manager(), 11);
     display_manager()->OnNativeDisplaysChanged(display_info_list);
     // 500 * 500 / 300 + 400 ~= 1233.
     EXPECT_EQ(gfx::Size(1233, 500), screen->GetPrimaryDisplay().size());
   }
 
   // Switch to 3 displays.
   UpdateDisplay("500x300,400x500,500x300");
   EXPECT_EQ(gfx::Size(1239, 300), screen->GetPrimaryDisplay().size());
 
   // Switch back to extended desktop.
   display_manager()->SetUnifiedDesktopEnabled(false);
   EXPECT_EQ(gfx::Size(500, 300), screen->GetPrimaryDisplay().size());
-  EXPECT_EQ(gfx::Size(400, 500), ScreenUtil::GetSecondaryDisplay().size());
-  EXPECT_EQ(gfx::Size(500, 300),
-            display_manager()
-                ->GetDisplayForId(ScreenUtil::GetSecondaryDisplay().id() + 1)
-                .size());
+  EXPECT_EQ(gfx::Size(400, 500),
+            display_manager()->GetSecondaryDisplay().size());
+  EXPECT_EQ(
+      gfx::Size(500, 300),
+      display_manager()
+          ->GetDisplayForId(display_manager()->GetSecondaryDisplay().id() + 1)
+          .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.
   display::ManagedDisplayInfo d1(1, "", false);
@@ skipping 228 matching lines @@
       CreateDisplayInfo(internal_id, gfx::Rect(0, 0, 500, 500));
   const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   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();
+      test::DisplayManagerTestApi(display_manager())
+          .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));
 
@@ skipping 80 matching lines @@
 }
 
 gfx::FontRenderParams::Hinting GetFontHintingParams() {
   gfx::FontRenderParams params =
       gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(), nullptr);
   return params.hinting;
 }
 
 }  // namespace
 
-typedef testing::Test DisplayManagerFontTest;
+using DisplayManagerFontTest = testing::Test;
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf100Internal) {
   FontTestHelper helper(1.0f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.0f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf125Internal) {
   test::ScopedDisable125DSFForUIScaling disable;
   FontTestHelper helper(1.25f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.25f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf200Internal) {
   FontTestHelper helper(2.0f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       2.0f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(
+  helper.display_manager()->SetDisplayUIScale(
       display::Screen::GetScreen()->GetPrimaryDisplay().id(), 2.0f);
 
   ASSERT_DOUBLE_EQ(
       1.0f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf100External) {
@@ skipping 25 matching lines @@
 
 TEST_F(DisplayManagerFontTest,
        TextSubpixelPositioningWithDsf125InternalWithScaling) {
   FontTestHelper helper(1.25f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.0f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 
-  Shell::GetInstance()->display_manager()->SetDisplayUIScale(
+  helper.display_manager()->SetDisplayUIScale(
       display::Screen::GetScreen()->GetPrimaryDisplay().id(), 0.8f);
 
   ASSERT_DOUBLE_EQ(
       1.25f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_P(DisplayManagerTest, CheckInitializationOfRotationProperty) {
@@ skipping 50 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