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

ash/wm/dock/docked_window_layout_manager_unittest.cc

 // Copyright (c) 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/wm/common/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf.h"
@@ skipping 16 matching lines @@
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/display/manager/display_layout.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 namespace ash {
 
 class DockedWindowLayoutManagerTest
     : public test::AshTestBase,
       public testing::WithParamInterface<ui::wm::WindowType> {
  public:
   DockedWindowLayoutManagerTest() : window_type_(GetParam()) {}
@@ skipping 126 matching lines @@
 
   // Detach if our window is a panel, then drag it vertically by |dy| and
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragVerticallyAndRelativeToEdge(DockedEdge edge,
                                        aura::Window* window,
                                        int dx, int dy) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
     // avoid snap by clicking away from the border
     ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window, 25, 5));
 
-    gfx::Rect work_area =
-        gfx::Screen::GetScreen()->GetDisplayNearestWindow(window).work_area();
+    gfx::Rect work_area = display::Screen::GetScreen()
+                              ->GetDisplayNearestWindow(window)
+                              .work_area();
     gfx::Point initial_location_in_screen = initial_location_in_parent_;
     ::wm::ConvertPointToScreen(window->parent(), &initial_location_in_screen);
     // Drag the window left or right to the edge (or almost to it).
     if (edge == DOCKED_EDGE_LEFT)
       dx += work_area.x() - initial_location_in_screen.x();
     else if (edge == DOCKED_EDGE_RIGHT)
       dx += work_area.right() - 1 - initial_location_in_screen.x();
     DragMove(dx, dy);
     EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
     // Release the mouse and the panel should be attached to the dock.
@@ skipping 220 matching lines @@
 
   // The windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Test that the gaps differ at most by a single pixel.
-  gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(w1.get())
+                            .work_area();
   int gap1 = w1->GetBoundsInScreen().y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = work_area.bottom() - w2->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_EQ(0, gap3);
 }
 
 // Adds two non-overlapping windows and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsDragging) {
@@ skipping 12 matching lines @@
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Drag w2 above w1.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(w2.get(), 0, 20));
   DragMove(0, -w2->bounds().height() / 2 - min_dock_gap() - 1);
   DragEnd();
 
   // Test the new windows order and that the gaps differ at most by a pixel.
-  gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(w1.get())
+                            .work_area();
   int gap1 = w2->GetBoundsInScreen().y() - work_area.y();
   int gap2 = w1->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap3 = work_area.bottom() - w1->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_EQ(0, gap3);
 }
 
 // Adds three overlapping windows and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsDragging) {
@@ skipping 14 matching lines @@
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(w3->GetRootWindow()->bounds().right(),
             w3->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
   // Test that the top and bottom windows are clamped in work area and
   // that the gaps between the windows differ at most by a pixel.
-  gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(w1.get())
+                            .work_area();
   int gap1 = w1->GetBoundsInScreen().y() - work_area.y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = w3->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap4 = work_area.bottom() - w3->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_NEAR(gap3, min_dock_gap(), 1);
   EXPECT_EQ(0, gap4);
 
   // Drag w1 below the point where w1 and w2 would swap places. This point is
@@ skipping 22 matching lines @@
 }
 
 // Adds three windows in bottom display and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsDraggingSecondScreen) {
   if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
     return;
 
   // Create two screen vertical layout.
   UpdateDisplay("600x1000,600x1000");
   // Layout the secondary display to the bottom of the primary.
-  ASSERT_GT(gfx::Screen::GetScreen()->GetNumDisplays(), 1);
+  ASSERT_GT(display::Screen::GetScreen()->GetNumDisplays(), 1);
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       test::CreateDisplayLayout(display::DisplayPlacement::BOTTOM, 0));
 
   std::unique_ptr<aura::Window> w1(
       CreateTestWindow(gfx::Rect(0, 1000, 201, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 1000 + 20);
   std::unique_ptr<aura::Window> w2(
       CreateTestWindow(gfx::Rect(0, 1000, 210, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 1000 + 500);
   std::unique_ptr<aura::Window> w3(
       CreateTestWindow(gfx::Rect(0, 1000, 220, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 1000 + 600);
 
   // All windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(w3->GetRootWindow()->bounds().right(),
             w3->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
-  gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(w1.get())
+                            .work_area();
   // Test that the top and bottom windows are clamped in work area and
   // that the overlaps between the windows differ at most by a pixel.
   int gap1 = w1->GetBoundsInScreen().y() - work_area.y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = w3->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap4 = work_area.bottom() - w3->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_NEAR(gap3, min_dock_gap(), 1);
   EXPECT_EQ(0, gap4);
@@ skipping 174 matching lines @@
 
   // The two windows should be attached and snapped to the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // The two windows should be same size vertically and almost 1/2 of work area.
-  gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(w1.get())
+                            .work_area();
   EXPECT_NEAR(w1->GetBoundsInScreen().height(),
               w2->GetBoundsInScreen().height(),
               1);
   EXPECT_NEAR(work_area.height() / 2, w1->GetBoundsInScreen().height(),
               min_dock_gap() * 2);
 
   // Create and dock the third window.
   std::unique_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 204)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 300);
 
@@ skipping 40 matching lines @@
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // The two windows should have their heights restricted.
   EXPECT_EQ(300, w1->GetBoundsInScreen().height());
   EXPECT_EQ(100, w2->GetBoundsInScreen().height());
 
   // w1 should be more than half of the work area height (even with a margin).
   // w2 should be less than half of the work area height (even with a margin).
-  gfx::Rect work_area =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(w1.get())
+                            .work_area();
   EXPECT_GT(w1->GetBoundsInScreen().height(), work_area.height() / 2 + 10);
   EXPECT_LT(w2->GetBoundsInScreen().height(), work_area.height() / 2 - 10);
 }
 
 // Tests that a docked window is moved to primary display when secondary display
 // is disconnected and that it stays docked and properly positioned.
 TEST_P(DockedWindowLayoutManagerTest, DisplayDisconnectionMovesDocked) {
   if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
     return;
 
   // Create a dual screen layout.
   UpdateDisplay("600x700,800x600");
 
   gfx::Rect bounds(600, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   // Drag pointer to the right edge of the second screen.
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // Simulate disconnection of the secondary display.
   UpdateDisplay("600x700");
 
   // The window should be still docked at the right edge.
   // Its height should grow to match the new work area.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
   EXPECT_EQ(ideal_width(), window->bounds().width());
-  gfx::Rect work_area = gfx::Screen::GetScreen()
+  gfx::Rect work_area = display::Screen::GetScreen()
                             ->GetDisplayNearestWindow(window.get())
                             .work_area();
   EXPECT_EQ(work_area.height(), window->GetBoundsInScreen().height());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowLayoutManagerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
 
 }  // namespace ash