Move ash::DisplayInfo 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"
@@ skipping 45 matching lines @@
     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 DisplayInfo& info = display_manager->GetDisplayInfo(display.id());
-    scoped_refptr<ManagedDisplayMode> old_mode(
-        new ManagedDisplayMode(info.size_in_pixel(), 60 /* refresh_rate */,
-                               false /* interlaced */, false /* native */));
-    scoped_refptr<ManagedDisplayMode> new_mode(new ManagedDisplayMode(
-        new_resolution, old_mode->refresh_rate(), old_mode->is_interlaced(),
-        old_mode->native(), old_mode->ui_scale(),
-        old_mode->device_scale_factor()));
+    const display::ManagedDisplayInfo& info =
+        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)) {
       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<DisplayInfo> info_list;
+    std::vector<display::ManagedDisplayInfo> info_list;
     for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
       int64_t id = display_manager->GetDisplayAt(i).id();
-      DisplayInfo info = display_manager->GetDisplayInfo(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);
     RunAllPendingInMessageLoop();
   }
@@ skipping 68 matching lines @@
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotify(ScreenUtil::GetSecondaryDisplay(),
                                 gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
   EXPECT_EQ(ExpectedNotificationMessage(id2, gfx::Size(200, 200)),
             GetNotificationMessage());
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(60.0, mode->refresh_rate());
 
   // Click the revert button, which reverts to the best resolution.
   ClickOnNotificationButton(0);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
@@ skipping 12 matching lines @@
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotify(ScreenUtil::GetSecondaryDisplay(),
                                 gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(60.0, mode->refresh_rate());
 
   // Click the revert button, which reverts the resolution.
   ClickOnNotification();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(1, accept_count());
@@ skipping 16 matching lines @@
   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
 
   // If there's a single display only, it will have timeout and the first button
   // becomes accept.
   EXPECT_TRUE(controller()->DoesNotificationTimeout());
   ClickOnNotificationButton(0);
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(1, accept_count());
 
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(display.id());
   EXPECT_TRUE(!!mode);
 
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(60.0f, mode->refresh_rate());
 
   // In that case the second button is revert.
   UpdateDisplay("300x300#300x300%59|200x200%60");
   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
@@ skipping 18 matching lines @@
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotify(ScreenUtil::GetSecondaryDisplay(),
                                 gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(60.0f, mode->refresh_rate());
 
   // Close the notification (imitates clicking [x] button). Also verifies if
   // this does not cause a crash.  See crbug.com/271784
   CloseNotification();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
@@ skipping 12 matching lines @@
   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<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       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(
       "300x300#300x300%56|200x200%57,"
       "200x200#250x250%58|200x200%59|100x100%60");
   int64_t id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   SetDisplayResolutionAndNotify(ScreenUtil::GetSecondaryDisplay(),
                                 gfx::Size(100, 100));
   ASSERT_TRUE(IsNotificationVisible());
 
   // Disconnects the secondary display and verifies it doesn't cause crashes.
   UpdateDisplay("300x300#300x300%56|200x200%57");
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   gfx::Size resolution;
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(59.0f, mode->refresh_rate());
 }
 
 TEST_F(ResolutionNotificationControllerTest, MultipleResolutionChange) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay(
       "300x300#300x300%56|200x200%57,"
       "250x250#250x250%58|200x200%59");
   int64_t id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
   SetDisplayResolutionAndNotify(ScreenUtil::GetSecondaryDisplay(),
                                 gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(59.0f, mode->refresh_rate());
 
   // Invokes SetDisplayResolutionAndNotify during the previous notification is
   // visible.
   SetDisplayResolutionAndNotify(ScreenUtil::GetSecondaryDisplay(),
                                 gfx::Size(250, 250));
   mode = display_manager->GetSelectedModeForDisplayId(id2);
@@ skipping 29 matching lines @@
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotifyWithResolution(ScreenUtil::GetSecondaryDisplay(),
                                               gfx::Size(220, 220),
                                               gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
   EXPECT_EQ(ExpectedFallbackNotificationMessage(id2, gfx::Size(220, 220),
                                                 gfx::Size(200, 200)),
             GetNotificationMessage());
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<display::ManagedDisplayMode> mode =
       display_manager->GetSelectedModeForDisplayId(id2);
   EXPECT_TRUE(!!mode);
   EXPECT_EQ("200x200", mode->size().ToString());
   EXPECT_EQ(60.0f, mode->refresh_rate());
 
   // Click the revert button, which reverts to the best resolution.
   ClickOnNotificationButton(0);
   RunAllPendingInMessageLoop();
   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