Rename gfx::Display/Screen to display::Display/Screen in ash

ash/wm/window_state_unittest.cc

 // Copyright 2014 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/wm/common/window_state.h"
 
 #include <utility>
 
 #include "ash/screen_util.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_event.h"
 #include "ash/wm/window_state_aura.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 class AlwaysMaximizeTestState : public WindowState::State {
  public:
   explicit AlwaysMaximizeTestState(WindowStateType initial_state_type)
       : state_type_(initial_state_type) {}
   ~AlwaysMaximizeTestState() override {}
@@ skipping 24 matching lines @@
 typedef test::AshTestBase WindowStateTest;
 
 // Test that a window gets properly snapped to the display's edges in a
 // multi monitor environment.
 TEST_F(WindowStateTest, SnapWindowBasic) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("0+0-500x400, 0+500-600x400");
   const gfx::Rect kPrimaryDisplayWorkAreaBounds =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area();
+      display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
   const gfx::Rect kSecondaryDisplayWorkAreaBounds =
       ScreenUtil::GetSecondaryDisplay().work_area();
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(100, 100, 100, 100)));
   WindowState* window_state = GetWindowState(window.get());
   const WMEvent snap_left(WM_EVENT_SNAP_LEFT);
   window_state->OnWMEvent(&snap_left);
   gfx::Rect expected = gfx::Rect(
       kPrimaryDisplayWorkAreaBounds.x(),
@@ skipping 26 matching lines @@
 }
 
 // Test how the minimum and maximum size specified by the aura::WindowDelegate
 // affect snapping.
 TEST_F(WindowStateTest, SnapWindowMinimumSize) {
   if (!SupportsHostWindowResize())
     return;
 
   UpdateDisplay("0+0-600x900");
   const gfx::Rect kWorkAreaBounds =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area();
+      display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
 
   aura::test::TestWindowDelegate delegate;
   std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
       &delegate, -1, gfx::Rect(0, 100, kWorkAreaBounds.width() - 1, 100)));
 
   // It should be possible to snap a window with a minimum size.
   delegate.set_minimum_size(gfx::Size(kWorkAreaBounds.width() - 1, 0));
   WindowState* window_state = GetWindowState(window.get());
   EXPECT_TRUE(window_state->CanSnap());
   const WMEvent snap_right(WM_EVENT_SNAP_RIGHT);
@@ skipping 45 matching lines @@
 }
 
 // Test that the minimum window size specified by aura::WindowDelegate does not
 // exceed the screen size.
 TEST_F(WindowStateTest, TestIgnoreTooBigMinimumSize) {
   if (!SupportsHostWindowResize())
     return;
 
   UpdateDisplay("0+0-1024x768");
   const gfx::Size work_area_size =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area().size();
+      display::Screen::GetScreen()->GetPrimaryDisplay().work_area().size();
   const gfx::Size illegal_size(1280, 960);
   const gfx::Rect illegal_bounds(gfx::Point(0, 0), illegal_size);
 
   aura::test::TestWindowDelegate delegate;
   const gfx::Size minimum_size(illegal_size);
   delegate.set_minimum_size(minimum_size);
 
   // The creation should force the window to respect the screen size.
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithDelegate(&delegate, -1, illegal_bounds));
@@ skipping 10 matching lines @@
   EXPECT_EQ(work_area_size.ToString(), window->bounds().size().ToString());
 }
 
 // Test that setting the bounds of a snapped window keeps its snapped.
 TEST_F(WindowStateTest, SnapWindowSetBounds) {
   if (!SupportsHostWindowResize())
     return;
 
   UpdateDisplay("0+0-900x600");
   const gfx::Rect kWorkAreaBounds =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area();
+      display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(100, 100, 100, 100)));
   WindowState* window_state = GetWindowState(window.get());
   const WMEvent snap_left(WM_EVENT_SNAP_LEFT);
   window_state->OnWMEvent(&snap_left);
   EXPECT_EQ(WINDOW_STATE_TYPE_LEFT_SNAPPED, window_state->GetStateType());
   gfx::Rect expected = gfx::Rect(kWorkAreaBounds.x(),
                                  kWorkAreaBounds.y(),
                                  kWorkAreaBounds.width() / 2,
@@ skipping 55 matching lines @@
   window_state->set_window_position_managed(true);
   window->Hide();
   window->SetBounds(gfx::Rect(100, 100, 100, 100));
   window->Show();
 
   window_state->Maximize();
   const WMEvent snap_right(WM_EVENT_SNAP_RIGHT);
   window_state->OnWMEvent(&snap_right);
 
   const gfx::Rect kWorkAreaBounds =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area();
+      display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
   gfx::Rect expected_snapped_bounds(
       kWorkAreaBounds.x() + kWorkAreaBounds.width() / 2,
       kWorkAreaBounds.y(),
       kWorkAreaBounds.width() / 2,
       kWorkAreaBounds.height());
   EXPECT_EQ(expected_snapped_bounds.ToString(),
             window->GetBoundsInScreen().ToString());
 
   // The window should still be auto managed despite being right maximized.
   EXPECT_TRUE(window_state->window_position_managed());
@@ skipping 23 matching lines @@
   EXPECT_FALSE(window_state->IsMaximized());
 }
 
 // Tests that a window that had same bounds as the work area shrinks after the
 // window is maximized and then restored.
 TEST_F(WindowStateTest, RestoredWindowBoundsShrink) {
   std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithId(0));
   WindowState* window_state = GetWindowState(window.get());
   EXPECT_FALSE(window_state->IsMaximized());
   gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area();
+      display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
 
   window->SetBounds(work_area);
   window_state->Maximize();
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_EQ(work_area.ToString(), window->bounds().ToString());
 
   window_state->Restore();
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_NE(work_area.ToString(), window->bounds().ToString());
   EXPECT_TRUE(work_area.Contains(window->bounds()));
@@ skipping 26 matching lines @@
 
   // Exitting fullscreen will update the maximized widnow to the work area.
   EXPECT_EQ("0,0 900x653", maximized->GetBoundsInScreen().ToString());
 }
 
 // TODO(skuhne): Add more unit test to verify the correctness for the restore
 // operation.
 
 }  // namespace wm
 }  // namespace ash