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

ash/wm/default_state.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/default_state.h"
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
@@ skipping 36 matching lines @@
   if (!window_state->HasRestoreBounds())
     return;
   const gfx::Rect& restore_bounds = window_state->GetRestoreBoundsInScreen();
 
   // Move only if the restore bounds is outside of
   // the display. There is no information about in which
   // display it should be restored, so this is best guess.
   // TODO(oshima): Restore information should contain the
   // work area information like WindowResizer does for the
   // last window location.
-  gfx::Rect display_area = Shell::GetScreen()->GetDisplayNearestWindow(
-      window_state->window()).bounds();
+  gfx::Rect display_area = gfx::Screen::GetScreen()
+                               ->GetDisplayNearestWindow(window_state->window())
+                               .bounds();
 
   if (!display_area.Intersects(restore_bounds)) {
     const gfx::Display& display =
-        Shell::GetScreen()->GetDisplayMatching(restore_bounds);
+        gfx::Screen::GetScreen()->GetDisplayMatching(restore_bounds);
     WindowTreeHostManager* window_tree_host_manager =
         Shell::GetInstance()->window_tree_host_manager();
     aura::Window* new_root =
         window_tree_host_manager->GetRootWindowForDisplayId(display.id());
     if (new_root != window_state->window()->GetRootWindow()) {
       aura::Window* new_container =
           Shell::GetContainer(new_root, window_state->window()->parent()->id());
       new_container->AddChild(window_state->window());
     }
   }
@@ skipping 180 matching lines @@
 
 void DefaultState::AttachState(
     WindowState* window_state,
     WindowState::State* state_in_previous_mode) {
   DCHECK_EQ(stored_window_state_, window_state);
 
   ReenterToCurrentState(window_state, state_in_previous_mode);
 
   // If the display has changed while in the another mode,
   // we need to let windows know the change.
-  gfx::Display current_display = Shell::GetScreen()->
-      GetDisplayNearestWindow(window_state->window());
+  gfx::Display current_display =
+      gfx::Screen::GetScreen()->GetDisplayNearestWindow(window_state->window());
   if (stored_display_state_.bounds() != current_display.bounds()) {
     const WMEvent event(wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED);
     window_state->OnWMEvent(&event);
   } else if (stored_display_state_.work_area() != current_display.work_area()) {
     const WMEvent event(wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
     window_state->OnWMEvent(&event);
   }
 }
 
 void DefaultState::DetachState(WindowState* window_state) {
   stored_window_state_ = window_state;
   aura::Window* window = window_state->window();
   stored_bounds_ = window->bounds();
   stored_restore_bounds_ = window_state->HasRestoreBounds() ?
       window_state->GetRestoreBoundsInParent() : gfx::Rect();
   // Remember the display state so that in case of the display change
   // while in the other mode, we can perform necessary action to
   // restore the window state to the proper state for the current
   // display.
-  stored_display_state_ = Shell::GetScreen()->
-      GetDisplayNearestWindow(window_state->window());
+  stored_display_state_ =
+      gfx::Screen::GetScreen()->GetDisplayNearestWindow(window_state->window());
 }
 
 // static
 bool DefaultState::ProcessCompoundEvents(WindowState* window_state,
                                          const WMEvent* event) {
   aura::Window* window = window_state->window();
 
   switch (event->type()) {
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
       if (window_state->IsFullscreen()) {
@@ skipping 436 matching lines @@
   }
 }
 
 // static
 void DefaultState::CenterWindow(WindowState* window_state) {
   if (!window_state->IsNormalOrSnapped())
     return;
   aura::Window* window = window_state->window();
   if (window_state->IsSnapped()) {
     gfx::Rect center_in_screen =
-        Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
+        gfx::Screen::GetScreen()->GetDisplayNearestWindow(window).work_area();
     gfx::Size size = window_state->HasRestoreBounds() ?
         window_state->GetRestoreBoundsInScreen().size() :
         window->bounds().size();
     center_in_screen.ClampToCenteredSize(size);
     window_state->SetRestoreBoundsInScreen(center_in_screen);
     window_state->Restore();
   } else {
     gfx::Rect center_in_parent =
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->bounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash