Move even more from WmShell to Shell

ash/common/wm/window_positioner.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/common/wm/window_positioner.h"
 
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_screen_util.h"
@@ skipping 145 matching lines @@
                              const WmWindow* exclude,
                              bool* single_window) {
   if (single_window)
     *single_window = true;
   // Get the active window.
   WmWindow* active = root_window->GetShell()->GetActiveWindow();
   if (active && active->GetRootWindow() != root_window)
     active = NULL;
 
   // Get a list of all windows.
-  const std::vector<WmWindow*> windows = root_window->GetShell()
-                                             ->mru_window_tracker()
-                                             ->BuildWindowListIgnoreModal();
+  const std::vector<WmWindow*> windows =
+      Shell::Get()->mru_window_tracker()->BuildWindowListIgnoreModal();
 
   if (windows.empty())
     return nullptr;
 
   int index = 0;
   // Find the index of the current active window.
   if (active)
     index = std::find(windows.begin(), windows.end(), active) - windows.begin();
 
   // Scan the cycle list backwards to see which is the second topmost window
@@ skipping 190 matching lines @@
   // Remember the current location of the window if it's new and push
   // it also to the opposite location if needed.  Since it is just
   // being shown, we do not need to animate it.
   gfx::Rect added_bounds = added_window->GetBounds();
   if (!added_window_state->pre_auto_manage_window_bounds())
     added_window_state->SetPreAutoManageWindowBounds(added_bounds);
   if (MoveRectToOneSide(work_area, !move_other_right, &added_bounds))
     added_window->SetBounds(added_bounds);
 }
 
-WindowPositioner::WindowPositioner(WmShell* shell)
-    : shell_(shell),
-      pop_position_offset_increment_x(0),
+WindowPositioner::WindowPositioner()
+    : pop_position_offset_increment_x(0),
       pop_position_offset_increment_y(0),
       popup_position_offset_from_screen_corner_x(0),
       popup_position_offset_from_screen_corner_y(0),
       last_popup_position_x_(0),
       last_popup_position_y_(0) {}
 
 WindowPositioner::~WindowPositioner() {}
 
 gfx::Rect WindowPositioner::GetDefaultWindowBounds(
     const display::Display& display) {
@@ skipping 21 matching lines @@
   if (!pop_position_offset_increment_x) {
     // When the popup position increment is 0, the last popup position
     // was not yet initialized.
     last_popup_position_x_ = popup_position_offset_from_screen_corner_x;
     last_popup_position_y_ = popup_position_offset_from_screen_corner_y;
   }
   pop_position_offset_increment_x = grid;
   pop_position_offset_increment_y = grid;
   // We handle the Multi monitor support by retrieving the active window's
   // work area.
-  WmWindow* window = shell_->GetActiveWindow();
+  WmWindow* window = WmShell::Get()->GetActiveWindow();
   const gfx::Rect work_area =
       window && window->IsVisible()
           ? window->GetDisplayNearestWindow().work_area()
           : display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
   // Only try to reposition the popup when it is not spanning the entire
   // screen.
   if ((old_pos.width() + popup_position_offset_from_screen_corner_x >=
        work_area.width()) ||
       (old_pos.height() + popup_position_offset_from_screen_corner_y >=
        work_area.height()))
@@ skipping 38 matching lines @@
     last_popup_position_x_ += pop_position_offset_increment_x;
     last_popup_position_y_ += pop_position_offset_increment_y;
   }
   return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h);
 }
 
 gfx::Rect WindowPositioner::SmartPopupPosition(const gfx::Rect& old_pos,
                                                const gfx::Rect& work_area,
                                                int grid) {
   const std::vector<WmWindow*> windows =
-      shell_->mru_window_tracker()->BuildWindowListIgnoreModal();
+      Shell::Get()->mru_window_tracker()->BuildWindowListIgnoreModal();
 
   std::vector<const gfx::Rect*> regions;
   // Process the window list and check if we can bail immediately.
   for (size_t i = 0; i < windows.size(); i++) {
     // We only include opaque and visible windows.
     if (windows[i] && windows[i]->IsVisible() && windows[i]->GetLayer() &&
         (windows[i]->GetLayer()->fills_bounds_opaquely() ||
          windows[i]->GetLayer()->GetTargetOpacity() == 1.0)) {
       wm::WindowState* window_state = windows[i]->GetWindowState();
       // When any window is maximized we cannot find any free space.
@@ skipping 63 matching lines @@
   // If the alignment was pushing the window out of the screen, we ignore the
   // alignment for that call.
   if (abs(pos.right() - work_area.right()) < grid)
     x = work_area.right() - w;
   if (abs(pos.bottom() - work_area.bottom()) < grid)
     y = work_area.bottom() - h;
   return gfx::Rect(x, y, w, h);
 }
 
 }  // namespace ash