Shuffles and renames ash/common/wm classes

ash/common/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/common/wm/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/default_window_resizer.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/dock/docked_window_resizer.h"
 #include "ash/common/wm/panels/panel_window_resizer.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
-#include "ash/common/wm/wm_globals.h"
-#include "ash/common/wm/wm_lookup.h"
-#include "ash/common/wm/wm_root_window_controller.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm/wm_user_metrics_action.h"
-#include "ash/common/wm/wm_window.h"
 #include "ash/common/wm/workspace/phantom_window_controller.h"
 #include "ash/common/wm/workspace/two_step_edge_cycler.h"
+#include "ash/common/wm_lookup.h"
+#include "ash/common/wm_root_window_controller.h"
+#include "ash/common/wm_shell.h"
+#include "ash/common/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"
 
 namespace ash {
 
 std::unique_ptr<WindowResizer> CreateWindowResizer(
-    wm::WmWindow* window,
+    WmWindow* window,
     const gfx::Point& point_in_parent,
     int window_component,
     aura::client::WindowMoveSource source) {
   DCHECK(window);
   wm::WindowState* window_state = window->GetWindowState();
   // No need to return a resizer when the window cannot get resized or when a
   // resizer already exists for this window.
   if ((!window_state->CanResize() && window_component != HTCAPTION) ||
       window_state->drag_details()) {
     return nullptr;
@@ skipping 23 matching lines @@
   if (bounds_change == WindowResizer::kBoundsChangeDirection_None)
     return std::unique_ptr<WindowResizer>();
 
   window_state->CreateDragDetails(point_in_parent, window_component, source);
   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_DockedContainer ||
        parent_shell_window_id == kShellWindowId_PanelContainer)) {
-    window_resizer.reset(WorkspaceWindowResizer::Create(
-        window_state, std::vector<wm::WmWindow*>()));
+    window_resizer.reset(
+        WorkspaceWindowResizer::Create(window_state, std::vector<WmWindow*>()));
   } else {
     window_resizer.reset(DefaultWindowResizer::Create(window_state));
   }
-  window_resizer = window->GetGlobals()->CreateDragWindowResizer(
+  window_resizer = window->GetShell()->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));
   if (window_resizer && window->GetParent() && !window->GetTransientParent() &&
       (parent_shell_window_id == kShellWindowId_DefaultContainer ||
        parent_shell_window_id == kShellWindowId_DockedContainer ||
        parent_shell_window_id == kShellWindowId_PanelContainer)) {
     window_resizer.reset(
         DockedWindowResizer::Create(window_resizer.release(), window_state));
@@ skipping 209 matching lines @@
   }
 
  private:
   int size_;
   int min_;
   int max_;
 };
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   if (did_lock_cursor_)
-    globals_->UnlockCursor();
+    shell_->UnlockCursor();
 
   if (instance == this)
     instance = NULL;
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     wm::WindowState* window_state,
-    const std::vector<wm::WmWindow*>& attached_windows) {
+    const std::vector<WmWindow*>& attached_windows) {
   return new WorkspaceWindowResizer(window_state, attached_windows);
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location_in_parent,
                                   int event_flags) {
   last_mouse_location_ = location_in_parent;
 
   int sticky_size;
   if (event_flags & ui::EF_CONTROL_DOWN) {
     sticky_size = 0;
@@ skipping 12 matching lines @@
       if (!details().restore_bounds.IsEmpty())
         window_state()->ClearRestoreBounds();
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
   gfx::Point location_in_screen =
       GetTarget()->GetParent()->ConvertPointToScreen(location_in_parent);
 
-  wm::WmWindow* root = nullptr;
+  WmWindow* root = nullptr;
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestPoint(location_in_screen);
   // Track the last screen that the pointer was on to keep the snap phantom
   // window there.
   if (display.bounds().Contains(location_in_screen)) {
-    root = wm::WmLookup::Get()
+    root = WmLookup::Get()
                ->GetRootWindowControllerWithDisplayId(display.id())
                ->GetWindow();
   }
   if (!attached_windows_.empty())
     LayoutAttachedWindows(&bounds);
   if (bounds != GetTarget()->GetBounds()) {
     // SetBounds needs to be called to update the layout which affects where the
     // phantom window is drawn. Keep track if the window was destroyed during
     // the drag and quit early if so.
     base::WeakPtr<WorkspaceWindowResizer> resizer(
@@ skipping 36 matching lines @@
           details().restore_bounds.IsEmpty() ? initial_bounds
                                              : details().restore_bounds);
     }
     if (!dock_layout_->is_dragged_window_docked()) {
       // 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);
-      globals_->RecordUserMetricsAction(
+      shell_->RecordUserMetricsAction(
           snap_type_ == SNAP_LEFT
               ? wm::WmUserMetricsAction::DRAG_MAXIMIZE_LEFT
               : wm::WmUserMetricsAction::DRAG_MAXIMIZE_RIGHT);
       snapped = true;
     }
   }
 
   if (!snapped) {
     if (window_state()->IsSnapped()) {
       // Keep the window snapped if the user resizes the window such that the
@@ skipping 50 matching lines @@
       bounds.set_y(last_y);
       bounds.set_height(initial_size_[i]);
       attached_windows_[i]->SetBounds(bounds);
       last_y = attached_windows_[i]->GetBounds().bottom();
     }
   }
 }
 
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     wm::WindowState* window_state,
-    const std::vector<wm::WmWindow*>& attached_windows)
+    const std::vector<WmWindow*>& attached_windows)
     : WindowResizer(window_state),
       attached_windows_(attached_windows),
-      globals_(window_state->window()->GetGlobals()),
+      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) {
-    globals_->LockCursor();
+    shell_->LockCursor();
     did_lock_cursor_ = true;
   }
 
   dock_layout_ = DockedWindowLayoutManager::Get(GetTarget());
 
   // 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.
@@ skipping 191 matching lines @@
     }
     window_tracker_.Remove(magnetism_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 (wm::WmWindow* root_window : globals_->GetAllRootWindows()) {
+  for (WmWindow* root_window : shell_->GetAllRootWindows()) {
     // Test all children from the desktop in each root window.
-    const std::vector<wm::WmWindow*> children =
+    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()) {
         continue;
       }
@@ skipping 203 matching lines @@
   }
   snap_phantom_window_controller_->Show(
       GetTarget()->GetParent()->ConvertRectToScreen(phantom_bounds));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
-  using IndexToWindowMap = std::map<size_t, wm::WmWindow*>;
+  using IndexToWindowMap = std::map<size_t, WmWindow*>;
   IndexToWindowMap map;
-  wm::WmWindow* parent = GetTarget()->GetParent();
-  const std::vector<wm::WmWindow*> windows(parent->GetChildren());
+  WmWindow* parent = GetTarget()->GetParent();
+  const std::vector<WmWindow*> windows(parent->GetChildren());
   map[std::find(windows.begin(), windows.end(), GetTarget()) -
       windows.begin()] = GetTarget();
   for (auto i = attached_windows_.begin(); i != attached_windows_.end(); ++i) {
     if ((*i)->GetParent() != parent)
       return;
     size_t index =
         std::find(windows.begin(), windows.end(), *i) - windows.begin();
     map[index] = *i;
   }
 
   // Reorder the windows starting at the topmost.
   parent->StackChildAtTop(map.rbegin()->second);
   for (auto i = map.rbegin(); i != map.rend();) {
-    wm::WmWindow* window = i->second;
+    WmWindow* window = i->second;
     ++i;
     if (i != map.rend())
       parent->StackChildBelow(i->second, window);
   }
 }
 
 WorkspaceWindowResizer::SnapType WorkspaceWindowResizer::GetSnapType(
     const gfx::Point& location) const {
   // TODO: this likely only wants total display area, not the area of a single
   // display.
@@ skipping 37 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