[Cleanup] Screen cleanup

ash/wm/dock/docked_window_resizer_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/dock/docked_window_resizer.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
-#include "ash/screen_ash.h"
+#include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ash/test/shell_test_api.h"
@@ skipping 680 matching lines @@
 // Dock two windows, undock one.
 // Test the docked windows area size and default container resizing.
 TEST_P(DockedWindowResizerTest, AttachTwoWindowsDetachOne) {
   if (!SupportsHostWindowResize())
     return;
   UpdateDisplay("600x600");
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201)));
   // Work area should cover the whole screen.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
@@ skipping 50 matching lines @@
 }
 
 // Dock one of the windows. Maximize other testing desktop resizing.
 TEST_P(DockedWindowResizerTest, AttachWindowMaximizeOther) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201)));
   // Work area should cover the whole screen.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
@@ skipping 13 matching lines @@
   // The second window should be floating on the desktop.
   EXPECT_EQ(w2->GetRootWindow()->bounds().right() -
             (w2->bounds().width()/2 + 20),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to remaining single docked window.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should now shrink.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Maximize the second window - Maximized area should be shrunk.
   const gfx::Rect restored_bounds = w2->bounds();
   wm::WindowState* w2_state = wm::GetWindowState(w2.get());
   w2_state->Maximize();
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
             w2->bounds().width());
 
   // Detach the first window (this should require very little drag).
   ASSERT_NO_FATAL_FAILURE(DragStart(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   DragMove(-35, 10);
   // Alignment is set to "NONE" when drag starts.
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   // Dock should get shrunk and desktop should get expanded.
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   EXPECT_EQ(0, docked_width(manager));
   // The second window should now get resized and take up the whole screen.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
             w2->bounds().width());
 
   // Dock the first window to the left edge.
   // Click at an offset from origin to prevent snapping.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w1.get(), 10, 0));
   // Drag left to get pointer touching the screen edge.
   DragMove(-w1->bounds().x() - 10, 0);
   // Alignment set to "NONE" during the drag of the window when none are docked.
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   // Release the mouse and the window should be now attached to the edge.
   DragEnd();
   // Dock should get expanded and desktop should get shrunk.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Second window should still be in the desktop.
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
   // Maximized window should be shrunk.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
             w2->bounds().width());
 
   // Unmaximize the second window.
   w2_state->Restore();
   // Its bounds should get restored.
   EXPECT_EQ(restored_bounds, w2->bounds());
 }
 
 // Dock one window. Test the sticky behavior near screen or desktop edge.
 TEST_P(DockedWindowResizerTest, AttachOneTestSticky) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201)));
   // Work area should cover the whole screen.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w1.get(), 20);
   // A window should be docked at the left edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().x(),
             w1->GetBoundsInScreen().x());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   // The first window should be docked.
   EXPECT_EQ(w1->GetRootWindow()->bounds().x(),
@@ skipping 61 matching lines @@
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // Both windows are docked now.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
   // Dock should get expanded and desktop should get shrunk.
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(std::max(w1->bounds().width(), w2->bounds().width()),
             docked_width(manager));
   // Desktop work area should now shrink by dock width.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 }
 
 // Dock two windows, resize one.
 // Test the docked windows area size and remaining desktop resizing.
 TEST_P(DockedWindowResizerTest, ResizeOneOfTwoWindows) {
   if (!SupportsHostWindowResize())
     return;
 
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201)));
   // Work area should cover the whole screen.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
@@ skipping 22 matching lines @@
   // Dock should still have both windows in it.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 is now wider than before. The dock should expand and be as wide as w1.
   EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should shrink.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window left by more than the dock maximum width.
   // This should cause the window width to be restricted by maximum dock width.
   previous_width = w1->bounds().width();
   const int kResizeSpan2 = 250;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
                                                               0, 20,
                                                               HTLEFT));
   DragMove(-kResizeSpan2, 0);
   // Alignment set to "RIGHT" during the drag because dock has a window in it.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // Dock should still have both windows in it.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 is now as wide as the maximum dock width and the dock should get
   // resized to the maximum width.
   EXPECT_EQ(max_width(), w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should shrink.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window right to get it completely inside the docked area.
   previous_width = w1->bounds().width();
   const int kResizeSpan3 = 100;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
                                                               0, 20,
                                                               HTLEFT));
   DragMove(kResizeSpan3, 0);
   // Alignment set to "RIGHT" during the drag because dock has a window in it.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be docked.
   DragEnd();
   // Dock should still have both windows in it.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 should be narrower than before by the length of the drag.
   EXPECT_EQ(previous_width - kResizeSpan3, w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   // The dock should be as wide as w1 or w2.
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should shrink.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
             docked_width(manager) - min_dock_gap(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window left to be overhang again.
   previous_width = w1->bounds().width();
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
                                                               0, 20,
                                                               HTLEFT));
   DragMove(-kResizeSpan3, 0);
   DragEnd();
   EXPECT_EQ(previous_width + kResizeSpan3, w1->bounds().width());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
@@ skipping 10 matching lines @@
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w1->parent()->id());
   // Dock should be as wide as w2 (and same as ideal width).
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(ideal_width(), docked_width(manager));
   EXPECT_EQ(w2->bounds().width(), docked_width(manager));
   // The second window should be still docked.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
   // Desktop work area should be inset.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w1.get()).width() -
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width() -
             docked_width(manager) - min_dock_gap(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
 }
 
 // Dock a window, resize it and test that undocking it preserves the width.
 TEST_P(DockedWindowResizerTest, ResizingKeepsWidth) {
   if (!SupportsHostWindowResize())
     return;
 
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
@@ skipping 175 matching lines @@
 }
 
 // Tests that dragging a window down to shelf attaches a panel but does not
 // attach a regular window.
 TEST_P(DockedWindowResizerTest, DragToShelf) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   // Work area should cover the whole screen.
-  EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w1.get()).width(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
+  EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width(),
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
@@ skipping 124 matching lines @@
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   EXPECT_TRUE(window_state->IsDocked());
   EXPECT_FALSE(window_state->IsSnapped());
 
   // Side snap at right edge.
   internal::SnapSizer::SnapWindow(window_state,
                                   internal::SnapSizer::RIGHT_EDGE);
   // The window should be snapped at the right edge and the dock should close.
-  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(w1.get()));
+  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()));
   EXPECT_EQ(0, docked_width(manager));
   EXPECT_EQ(work_area.height(), w1->bounds().height());
   EXPECT_EQ(work_area.right(), w1->bounds().right());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w1->parent()->id());
   EXPECT_FALSE(window_state->IsDocked());
   EXPECT_TRUE(window_state->IsSnapped());
 
   // Dock again.
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   EXPECT_TRUE(window_state->IsDocked());
   EXPECT_FALSE(window_state->IsSnapped());
 
   // Side snap at left edge.
   internal::SnapSizer::SnapWindow(window_state,
                                   internal::SnapSizer::LEFT_EDGE);
   // The window should be snapped at the right edge and the dock should close.
   EXPECT_EQ(work_area.ToString(),
-            ScreenAsh::GetDisplayWorkAreaBoundsInParent(w1.get()).ToString());
+            ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).ToString());
   EXPECT_EQ(0, docked_width(manager));
   EXPECT_EQ(work_area.height(), w1->bounds().height());
   EXPECT_EQ(work_area.x(), w1->bounds().x());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w1->parent()->id());
   EXPECT_FALSE(window_state->IsDocked());
   EXPECT_TRUE(window_state->IsSnapped());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowResizerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
 }  // namespace internal
 }  // namespace ash