[Cleanup] Screen cleanup

ash/wm/workspace/snap_sizer_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/wm/workspace/snap_sizer.h"
 
 #include "ash/ash_switches.h"
-#include "ash/screen_ash.h"
+#include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 
 typedef test::AshTestBase SnapSizerTest;
 
 using internal::SnapSizer;
 
 // Test that a window gets properly snapped to the display's edges in a
 // multi monitor environment.
 TEST_F(SnapSizerTest, MultipleDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("0+0-500x400, 0+500-600x400");
   const gfx::Rect kPrimaryDisplayWorkAreaBounds =
       ash::Shell::GetScreen()->GetPrimaryDisplay().work_area();
   const gfx::Rect kSecondaryDisplayWorkAreaBounds =
-      ScreenAsh::GetSecondaryDisplay().work_area();
+      ScreenUtil::GetSecondaryDisplay().work_area();
 
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(100, 100, 100, 100)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   SnapSizer::SnapWindow(window_state, SnapSizer::LEFT_EDGE);
   gfx::Rect expected = gfx::Rect(
       kPrimaryDisplayWorkAreaBounds.x(),
       kPrimaryDisplayWorkAreaBounds.y(),
       window->bounds().width(), // No expectation for the width.
       kPrimaryDisplayWorkAreaBounds.height());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   SnapSizer::SnapWindow(window_state, SnapSizer::RIGHT_EDGE);
   // The width should not change when a window switches from being snapped to
   // the left edge to being snapped to the right edge.
   expected.set_x(kPrimaryDisplayWorkAreaBounds.right() - expected.width());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   // Move the window to the secondary display.
   window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100),
-                            ScreenAsh::GetSecondaryDisplay());
+                            ScreenUtil::GetSecondaryDisplay());
 
   SnapSizer::SnapWindow(window_state, SnapSizer::RIGHT_EDGE);
   expected = gfx::Rect(
       kSecondaryDisplayWorkAreaBounds.right() - window->bounds().width(),
       kSecondaryDisplayWorkAreaBounds.y(),
       window->bounds().width(),  // No expectation for the width.
       kSecondaryDisplayWorkAreaBounds.height());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   SnapSizer::SnapWindow(window_state, SnapSizer::LEFT_EDGE);
@@ skipping 180 matching lines @@
   // For small workspace widths, we should snap to 90% of the workspace width
   // because it is the largest width the window can snap to.
   UpdateDisplay("0+0-800x600");
   sizer.SelectDefaultSizeAndDisableResize();
 
   gfx::Rect work_area =
       ash::Shell::GetScreen()->GetPrimaryDisplay().work_area();
   gfx::Rect expected(work_area);
   expected.set_width(work_area.width() * 0.9);
   EXPECT_EQ(expected.ToString(),
-            ScreenAsh::ConvertRectToScreen(window->parent(),
-                                           sizer.target_bounds()).ToString());
+            ScreenUtil::ConvertRectToScreen(window->parent(),
+                                            sizer.target_bounds()).ToString());
 
   // If the largest width the window can snap to is between 1024 and 1280, we
   // should snap to 1024.
   UpdateDisplay("0+0-1280x800");
   sizer.SelectDefaultSizeAndDisableResize();
   sizer.SnapWindowToTargetBounds();
   EXPECT_EQ(1024, window->bounds().width());
 
   // We should snap to a width of 50% of the work area if it is the largest
   // width the window can snap to.
@@ skipping 115 matching lines @@
       window->bounds().width(), // No expectation for the width.
       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());
 }
 
 }  // namespace ash