Renames WmShell to ShellPort

ash/wm/workspace/workspace_window_resizer.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_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/metrics/user_metrics_action.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
+#include "ash/shell_port.h"
 #include "ash/wm/default_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.h"
 #include "ash/wm/window_positioning_utils.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/wm_screen_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/two_step_edge_cycler.h"
-#include "ash/wm_shell.h"
 #include "ash/wm_window.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/public/window_types.h"
 
@@ skipping 39 matching lines @@
   const int parent_shell_window_id =
       window->GetParent() ? window->GetParent()->GetShellWindowId() : -1;
   if (window->GetParent() &&
       (parent_shell_window_id == kShellWindowId_DefaultContainer ||
        parent_shell_window_id == kShellWindowId_PanelContainer)) {
     window_resizer.reset(
         WorkspaceWindowResizer::Create(window_state, std::vector<WmWindow*>()));
   } else {
     window_resizer.reset(DefaultWindowResizer::Create(window_state));
   }
-  window_resizer = window->GetShell()->CreateDragWindowResizer(
+  window_resizer = ShellPort::Get()->CreateDragWindowResizer(
       std::move(window_resizer), window_state);
   if (window->GetType() == ui::wm::WINDOW_TYPE_PANEL) {
     window_resizer.reset(
         PanelWindowResizer::Create(window_resizer.release(), window_state));
   }
   return window_resizer;
 }
 
 namespace {
 
@@ skipping 203 matching lines @@
   }
 
  private:
   int size_;
   int min_;
   int max_;
 };
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   if (did_lock_cursor_)
-    shell_->UnlockCursor();
+    ShellPort::Get()->UnlockCursor();
 
   if (instance == this)
     instance = NULL;
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     wm::WindowState* window_state,
     const std::vector<WmWindow*>& attached_windows) {
   return new WorkspaceWindowResizer(window_state, attached_windows);
@@ skipping 80 matching lines @@
           details().initial_bounds_in_parent);
       window_state()->SetRestoreBoundsInScreen(
           details().restore_bounds.IsEmpty() ? initial_bounds
                                              : details().restore_bounds);
     }
     // TODO(oshima): Add event source type to WMEvent and move
     // metrics recording inside WindowState::OnWMEvent.
     const wm::WMEvent event(snap_type_ == SNAP_LEFT ? wm::WM_EVENT_SNAP_LEFT
                                                     : wm::WM_EVENT_SNAP_RIGHT);
     window_state()->OnWMEvent(&event);
-    shell_->RecordUserMetricsAction(snap_type_ == SNAP_LEFT
-                                        ? UMA_DRAG_MAXIMIZE_LEFT
-                                        : UMA_DRAG_MAXIMIZE_RIGHT);
+    ShellPort::Get()->RecordUserMetricsAction(snap_type_ == SNAP_LEFT
+                                                  ? UMA_DRAG_MAXIMIZE_LEFT
+                                                  : UMA_DRAG_MAXIMIZE_RIGHT);
     snapped = true;
   }
 
   if (!snapped) {
     if (window_state()->IsSnapped()) {
       // Keep the window snapped if the user resizes the window such that the
       // window has valid bounds for a snapped window. Always unsnap the window
       // if the user dragged the window via the caption area because doing this
       // is slightly less confusing.
       if (details().window_component == HTCAPTION ||
@@ skipping 44 matching lines @@
       last_y = attached_windows_[i]->GetBounds().bottom();
     }
   }
 }
 
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     wm::WindowState* window_state,
     const std::vector<WmWindow*>& attached_windows)
     : WindowResizer(window_state),
       attached_windows_(attached_windows),
-      shell_(window_state->window()->GetShell()),
       did_lock_cursor_(false),
       did_move_or_resize_(false),
       initial_bounds_changed_by_user_(window_state_->bounds_changed_by_user()),
       total_min_(0),
       total_initial_size_(0),
       snap_type_(SNAP_NONE),
       num_mouse_moves_since_bounds_change_(0),
       magnetism_window_(NULL),
       weak_ptr_factory_(this) {
   DCHECK(details().is_resizable);
 
   // A mousemove should still show the cursor even if the window is
   // being moved or resized with touch, so do not lock the cursor.
   if (details().source != aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
-    shell_->LockCursor();
+    ShellPort::Get()->LockCursor();
     did_lock_cursor_ = true;
   }
 
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() || (details().window_component == HTRIGHT ||
                                        details().window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
   // Calculate sizes so that we can maintain the ratios if we need to resize.
@@ skipping 189 matching lines @@
     }
     window_tracker_.Remove(magnetism_window_->aura_window());
     magnetism_window_ = NULL;
   }
 
   // Avoid magnetically snapping windows that are not resizable.
   // TODO(oshima): change this to window.type() == TYPE_NORMAL.
   if (!window_state()->CanResize())
     return false;
 
-  for (WmWindow* root_window : shell_->GetAllRootWindows()) {
+  for (WmWindow* root_window : ShellPort::Get()->GetAllRootWindows()) {
     // Test all children from the desktop in each root window.
     const std::vector<WmWindow*> children =
         root_window->GetChildByShellWindowId(kShellWindowId_DefaultContainer)
             ->GetChildren();
     for (auto i = children.rbegin();
          i != children.rend() && !matcher.AreEdgesObscured(); ++i) {
       wm::WindowState* other_state = (*i)->GetWindowState();
       if (other_state->window() == GetTarget() ||
           !other_state->window()->IsVisible() ||
           !other_state->IsNormalOrSnapped() || !other_state->CanResize()) {
@@ skipping 237 matching lines @@
   DCHECK(snapped_type == wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ||
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
   gfx::Rect snapped_bounds = wm::GetDisplayWorkAreaBoundsInParent(GetTarget());
   if (snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     snapped_bounds.set_x(snapped_bounds.right() - bounds_in_parent.width());
   snapped_bounds.set_width(bounds_in_parent.width());
   return bounds_in_parent == snapped_bounds;
 }
 
 }  // namespace ash