Relocate display_manager from ash to ui

ash/display/resolution_notification_controller_unittest.cc

 // Copyright 2013 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/resolution_notification_controller.h"
 
-#include "ash/display/display_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/display/manager/display_manager.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_list.h"
 
 namespace ash {
 
 class ResolutionNotificationControllerTest : public ash::test::AshTestBase {
  public:
   ResolutionNotificationControllerTest() : accept_count_(0) {}
@@ skipping 22 matching lines @@
  protected:
   void SetUp() override {
     ash::test::AshTestBase::SetUp();
     ResolutionNotificationController::SuppressTimerForTest();
   }
 
   void SetDisplayResolutionAndNotifyWithResolution(
       const display::Display& display,
       const gfx::Size& new_resolution,
       const gfx::Size& actual_new_resolution) {
-    DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-
     const display::ManagedDisplayInfo& info =
-        display_manager->GetDisplayInfo(display.id());
+        display_manager()->GetDisplayInfo(display.id());
     scoped_refptr<display::ManagedDisplayMode> old_mode(
         new display::ManagedDisplayMode(
             info.size_in_pixel(), 60 /* refresh_rate */, false /* interlaced */,
             false /* native */));
     scoped_refptr<display::ManagedDisplayMode> new_mode(
         new display::ManagedDisplayMode(
             new_resolution, old_mode->refresh_rate(), old_mode->is_interlaced(),
             old_mode->native(), old_mode->ui_scale(),
             old_mode->device_scale_factor()));
 
-    if (display_manager->SetDisplayMode(display.id(), new_mode)) {
+    if (display_manager()->SetDisplayMode(display.id(), new_mode)) {
       controller()->PrepareNotification(
           display.id(), old_mode, new_mode,
           base::Bind(&ResolutionNotificationControllerTest::OnAccepted,
                      base::Unretained(this)));
     }
 
     // OnConfigurationChanged event won't be emitted in the test environment,
     // so invoke UpdateDisplay() to emit that event explicitly.
     std::vector<display::ManagedDisplayInfo> info_list;
-    for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
-      int64_t id = display_manager->GetDisplayAt(i).id();
-      display::ManagedDisplayInfo info = display_manager->GetDisplayInfo(id);
+    for (size_t i = 0; i < display_manager()->GetNumDisplays(); ++i) {
+      int64_t id = display_manager()->GetDisplayAt(i).id();
+      display::ManagedDisplayInfo info = display_manager()->GetDisplayInfo(id);
       if (display.id() == id) {
         gfx::Rect bounds = info.bounds_in_native();
         bounds.set_size(actual_new_resolution);
         info.SetBounds(bounds);
       }
       info_list.push_back(info);
     }
-    display_manager->OnNativeDisplaysChanged(info_list);
+    display_manager()->OnNativeDisplaysChanged(info_list);
     RunAllPendingInMessageLoop();
   }
 
   void SetDisplayResolutionAndNotify(const display::Display& display,
                                      const gfx::Size& new_resolution) {
     SetDisplayResolutionAndNotifyWithResolution(display, new_resolution,
                                                 new_resolution);
   }
 
   static base::string16 GetNotificationMessage() {
@@ skipping 191 matching lines @@
   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
 
   for (int i = 0; i < ResolutionNotificationController::kTimeoutInSec; ++i) {
     EXPECT_TRUE(IsNotificationVisible()) << "notification is closed after " << i
                                          << "-th timer tick";
     TickTimer();
     RunAllPendingInMessageLoop();
   }
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
-  ash::DisplayManager* display_manager =
-      ash::Shell::GetInstance()->display_manager();
   scoped_refptr<display::ManagedDisplayMode> mode =
-      display_manager->GetSelectedModeForDisplayId(display.id());
+      display_manager()->GetSelectedModeForDisplayId(display.id());
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("300x300", mode->size().ToString());
   EXPECT_EQ(59.0f, mode->refresh_rate());
 }
 
 TEST_F(ResolutionNotificationControllerTest, DisplayDisconnected) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay(
@@ skipping 90 matching lines @@
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
 
   mode = display_manager()->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("250x250", mode->size().ToString());
   EXPECT_EQ(58.0f, mode->refresh_rate());
 }
 
 }  // namespace ash