Remove now-unnecessary wrappers around gfx::Screen::GetScreen()

ash/wm/workspace/workspace_layout_manager_unittest.cc

 // Copyright (c) 2012 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/workspace_layout_manager.h"
 
 #include <string>
 #include <utility>
 
 #include "ash/display/display_layout.h"
@@ skipping 371 matching lines @@
 TEST_F(WorkspaceLayoutManagerTest, MaximizeWithEmptySize) {
   scoped_ptr<aura::Window> window(
       aura::test::CreateTestWindowWithBounds(gfx::Rect(0, 0, 0, 0),
                                              NULL));
   wm::GetWindowState(window.get())->Maximize();
   aura::Window* default_container = Shell::GetContainer(
       Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer);
   default_container->AddChild(window.get());
   window->Show();
   gfx::Rect work_area(
-      Shell::GetScreen()->GetPrimaryDisplay().work_area());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area());
   EXPECT_EQ(work_area.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) {
   // Normal window bounds shouldn't be changed.
   gfx::Rect window_bounds(100, 100, 200, 200);
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(window_bounds));
   EXPECT_EQ(window_bounds, window->bounds());
 
@@ skipping 54 matching lines @@
   bounds = window_bigger_than_display->bounds();
   bounds.Intersect(root_window_bounds);
   EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
   EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
 }
 
 // Verifies the size of a window is enforced to be smaller than the work area.
 TEST_F(WorkspaceLayoutManagerTest, SizeToWorkArea) {
   // Normal window bounds shouldn't be changed.
   gfx::Size work_area(
-      Shell::GetScreen()->GetPrimaryDisplay().work_area().size());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area().size());
   const gfx::Rect window_bounds(
       100, 101, work_area.width() + 1, work_area.height() + 2);
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(window_bounds));
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
       window->bounds().ToString());
 
   // Directly setting the bounds triggers a slightly different code path. Verify
   // that too.
   window->SetBounds(window_bounds);
@@ skipping 151 matching lines @@
       initial_work_area_bounds.ToString(),
       ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString());
 }
 
 // Tests normal->fullscreen->normal.
 TEST_F(WorkspaceLayoutManagerSoloTest, Fullscreen) {
   gfx::Rect bounds(100, 100, 200, 200);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   // Fullscreen window fills the whole display.
-  EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
-                window.get()).bounds().ToString(),
+  EXPECT_EQ(gfx::Screen::GetScreen()
+                ->GetDisplayNearestWindow(window.get())
+                .bounds()
+                .ToString(),
             window->bounds().ToString());
   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
 }
 
 // Tests that fullscreen window causes always_on_top windows to stack below.
 TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenSuspendsAlwaysOnTop) {
   gfx::Rect bounds(100, 100, 200, 200);
   scoped_ptr<aura::Window> fullscreen_window(CreateTestWindow(bounds));
   scoped_ptr<aura::Window> always_on_top_window1(CreateTestWindow(bounds));
@@ skipping 19 matching lines @@
   EXPECT_EQ(nullptr, GetRootWindowController(fullscreen_window->GetRootWindow())
                          ->GetWindowForFullscreenMode());
 }
 
 // Tests fullscreen window size during root window resize.
 TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenRootWindowResize) {
   gfx::Rect bounds(100, 100, 200, 200);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
   // Fullscreen window fills the whole display.
   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
-  EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
-                window.get()).bounds().ToString(),
+  EXPECT_EQ(gfx::Screen::GetScreen()
+                ->GetDisplayNearestWindow(window.get())
+                .bounds()
+                .ToString(),
             window->bounds().ToString());
   // Enlarge the root window.  We should still match the display size.
   UpdateDisplay("800x600");
-  EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
-                window.get()).bounds().ToString(),
+  EXPECT_EQ(gfx::Screen::GetScreen()
+                ->GetDisplayNearestWindow(window.get())
+                .bounds()
+                .ToString(),
             window->bounds().ToString());
 }
 
 // Tests that when the screen gets smaller the windows aren't bigger than
 // the screen.
 TEST_F(WorkspaceLayoutManagerSoloTest, RootWindowResizeShrinksWindows) {
   scoped_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(10, 20, 500, 400)));
-  gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
-      window.get()).work_area();
+  gfx::Rect work_area = gfx::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(window.get())
+                            .work_area();
   // Invariant: Window is smaller than work area.
   EXPECT_LE(window->bounds().width(), work_area.width());
   EXPECT_LE(window->bounds().height(), work_area.height());
 
   // Make the root window narrower than our window.
   UpdateDisplay("300x400");
-  work_area = Shell::GetScreen()->GetDisplayNearestWindow(
-      window.get()).work_area();
+  work_area = gfx::Screen::GetScreen()
+                  ->GetDisplayNearestWindow(window.get())
+                  .work_area();
   EXPECT_LE(window->bounds().width(), work_area.width());
   EXPECT_LE(window->bounds().height(), work_area.height());
 
   // Make the root window shorter than our window.
   UpdateDisplay("300x200");
-  work_area = Shell::GetScreen()->GetDisplayNearestWindow(
-      window.get()).work_area();
+  work_area = gfx::Screen::GetScreen()
+                  ->GetDisplayNearestWindow(window.get())
+                  .work_area();
   EXPECT_LE(window->bounds().width(), work_area.width());
   EXPECT_LE(window->bounds().height(), work_area.height());
 
   // Enlarging the root window does not change the window bounds.
   gfx::Rect old_bounds = window->bounds();
   UpdateDisplay("800x600");
   EXPECT_EQ(old_bounds.width(), window->bounds().width());
   EXPECT_EQ(old_bounds.height(), window->bounds().height());
 }
 
@@ skipping 290 matching lines @@
     layout_manager_ = static_cast<WorkspaceLayoutManager*>(
         default_container->layout_manager());
   }
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
   }
 
   void ShowKeyboard() {
     layout_manager_->OnKeyboardBoundsChanging(keyboard_bounds_);
-    restore_work_area_insets_ = Shell::GetScreen()->GetPrimaryDisplay().
-        GetWorkAreaInsets();
+    restore_work_area_insets_ =
+        gfx::Screen::GetScreen()->GetPrimaryDisplay().GetWorkAreaInsets();
     Shell::GetInstance()->SetDisplayWorkAreaInsets(
         Shell::GetPrimaryRootWindow(),
         gfx::Insets(0, 0, keyboard_bounds_.height(), 0));
   }
 
   void HideKeyboard() {
     Shell::GetInstance()->SetDisplayWorkAreaInsets(
         Shell::GetPrimaryRootWindow(),
         restore_work_area_insets_);
     layout_manager_->OnKeyboardBoundsChanging(gfx::Rect());
   }
 
   void SetKeyboardBounds(const gfx::Rect& bounds) {
     keyboard_bounds_ = bounds;
   }
 
  private:
   gfx::Insets restore_work_area_insets_;
   gfx::Rect keyboard_bounds_;
   WorkspaceLayoutManager* layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerKeyboardTest);
 };
 
 // Tests that when a child window gains focus the top level window containing it
 // is resized to fit the remaining workspace area.
 TEST_F(WorkspaceLayoutManagerKeyboardTest, ChildWindowFocused) {
   gfx::Rect work_area(
-      Shell::GetScreen()->GetPrimaryDisplay().work_area());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area());
   gfx::Rect keyboard_bounds(work_area.x(),
                             work_area.y() + work_area.height() / 2,
                             work_area.width(),
                             work_area.height() / 2);
 
   SetKeyboardBounds(keyboard_bounds);
 
   aura::test::TestWindowDelegate delegate1;
   scoped_ptr<aura::Window> parent_window(CreateTestWindowInShellWithDelegate(
       &delegate1, -1, work_area));
   aura::test::TestWindowDelegate delegate2;
   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
       &delegate2, -1, work_area));
   parent_window->AddChild(window.get());
 
   wm::ActivateWindow(window.get());
 
   int available_height =
-      Shell::GetScreen()->GetPrimaryDisplay().bounds().height() -
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().height() -
       keyboard_bounds.height();
 
   gfx::Rect initial_window_bounds(50, 50, 100, 500);
   parent_window->SetBounds(initial_window_bounds);
   EXPECT_EQ(initial_window_bounds.ToString(),
             parent_window->bounds().ToString());
   ShowKeyboard();
   EXPECT_EQ(gfx::Rect(50, 0, 100, available_height).ToString(),
             parent_window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(initial_window_bounds.ToString(),
             parent_window->bounds().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerKeyboardTest, AdjustWindowForA11yKeyboard) {
   gfx::Rect work_area(
-      Shell::GetScreen()->GetPrimaryDisplay().work_area());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().work_area());
   gfx::Rect keyboard_bounds(work_area.x(),
                             work_area.y() + work_area.height() / 2,
                             work_area.width(),
                             work_area.height() / 2);
 
   SetKeyboardBounds(keyboard_bounds);
 
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
       &delegate, -1, work_area));
 
   int available_height =
-      Shell::GetScreen()->GetPrimaryDisplay().bounds().height() -
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().height() -
       keyboard_bounds.height();
 
   wm::ActivateWindow(window.get());
 
   EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString());
   ShowKeyboard();
   EXPECT_EQ(gfx::Rect(work_area.origin(),
             gfx::Size(work_area.width(), available_height)).ToString(),
             window->bounds().ToString());
   HideKeyboard();
@@ skipping 18 matching lines @@
   EXPECT_EQ(gfx::Rect(50,
                       keyboard_bounds.y() - keyboard_bounds.height()/2,
                       occluded_window_bounds.width(),
                       occluded_window_bounds.height()).ToString(),
             window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString());
 }
 
 }  // namespace ash