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

ash/wm/dock/docked_window_layout_manager.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_layout_manager.h"
 
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 596 matching lines @@
   // See http://crbug.com/307792.
   if (window->bounds().width() > kMaxDockWidth &&
       (!window_state->CanResize() ||
        (window->delegate() &&
         window->delegate()->GetMinimumSize().width() != 0 &&
         window->delegate()->GetMinimumSize().width() > kMaxDockWidth))) {
     return false;
   }
   // If a window is tall and cannot be resized down to maximum height allowed
   // then it cannot be docked.
-  const gfx::Rect work_area =
-      Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
+  const gfx::Rect work_area = gfx::Screen::GetScreen()
+                                  ->GetDisplayNearestWindow(dock_container_)
+                                  .work_area();
   if (GetWindowHeightCloseTo(window, work_area.height()) > work_area.height())
     return false;
   // Cannot dock on the other size from an existing dock.
   const DockedAlignment alignment = CalculateAlignmentExcept(window);
   if (desired_alignment != DOCKED_ALIGNMENT_NONE &&
       alignment != DOCKED_ALIGNMENT_NONE &&
       alignment != desired_alignment) {
     return false;
   }
   // Do not allow docking on the same side as shelf.
@@ skipping 296 matching lines @@
   if (ancestor)
     UpdateStacking(ancestor);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager private implementation:
 
 void DockedWindowLayoutManager::MaybeMinimizeChildrenExcept(
     aura::Window* child) {
   // Minimize any windows that don't fit without overlap.
-  const gfx::Rect work_area =
-      Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
+  const gfx::Rect work_area = gfx::Screen::GetScreen()
+                                  ->GetDisplayNearestWindow(dock_container_)
+                                  .work_area();
   int available_room = work_area.height();
   bool gap_needed = !!child;
   if (child)
     available_room -= GetWindowHeightCloseTo(child, 0);
   // Use a copy of children array because a call to Minimize can change order.
   aura::Window::Windows children(dock_container_->children());
   aura::Window::Windows::const_reverse_iterator iter = children.rbegin();
   while (iter != children.rend()) {
     aura::Window* window(*iter++);
     if (window == child || !IsWindowDocked(window))
@@ skipping 24 matching lines @@
   RecordUmaAction(DOCKED_ACTION_MINIMIZE, event_source_);
 }
 
 void DockedWindowLayoutManager::RestoreDockedWindow(
     wm::WindowState* window_state) {
   aura::Window* window = window_state->window();
   DCHECK(!IsPopupOrTransient(window));
   // Always place restored window at the bottom shuffling the other windows up.
   // TODO(varkha): add a separate container for docked windows to keep track
   // of ordering.
-  gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
-      dock_container_);
+  gfx::Display display =
+      gfx::Screen::GetScreen()->GetDisplayNearestWindow(dock_container_);
   const gfx::Rect work_area = display.work_area();
 
   // Evict the window if it can no longer be docked because of its height.
   if (!CanDockWindow(window, DOCKED_ALIGNMENT_NONE)) {
     window_state->Restore();
     RecordUmaAction(DOCKED_ACTION_EVICT, event_source_);
     return;
   }
   gfx::Rect bounds(window->bounds());
   bounds.set_y(work_area.bottom());
@@ skipping 112 matching lines @@
     visible_windows.push_back(WindowWithHeight(window));
   }
   // Consider docked dragged_window_ when fanning out other child windows.
   if (is_dragged_window_docked_) {
     visible_windows.push_back(WindowWithHeight(dragged_window_));
     DCHECK(!active_window);
     active_window = dragged_window_;
   }
 
   // Position docked windows as well as the window being dragged.
-  gfx::Rect work_area =
-      Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
+  gfx::Rect work_area = gfx::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(dock_container_)
+                            .work_area();
   if (shelf_observer_)
     work_area.Subtract(shelf_observer_->shelf_bounds_in_screen());
   int available_room = CalculateWindowHeightsAndRemainingRoom(work_area,
                                                               &visible_windows);
   FanOutChildren(work_area,
                  CalculateIdealWidth(visible_windows),
                  available_room,
                  &visible_windows);
 
   // After the first Relayout allow the windows to change their order easier
@@ skipping 142 matching lines @@
       slide_settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kSlideDurationMs));
       SetChildBoundsDirect(window, bounds);
     }
   }
 }
 
 void DockedWindowLayoutManager::UpdateDockBounds(
     DockedWindowLayoutManagerObserver::Reason reason) {
   int dock_inset = docked_width_ + (docked_width_ > 0 ? kMinDockGap : 0);
-  const gfx::Rect work_area =
-      Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
+  const gfx::Rect work_area = gfx::Screen::GetScreen()
+                                  ->GetDisplayNearestWindow(dock_container_)
+                                  .work_area();
   gfx::Rect bounds = gfx::Rect(
       alignment_ == DOCKED_ALIGNMENT_RIGHT && dock_inset > 0 ?
           dock_container_->bounds().right() - dock_inset:
           dock_container_->bounds().x(),
       dock_container_->bounds().y(),
       dock_inset,
       work_area.height());
   docked_bounds_ = bounds +
       dock_container_->GetBoundsInScreen().OffsetFromOrigin();
   FOR_EACH_OBSERVER(
@@ skipping 71 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace ash