Removes most aura dependencies from WindowResizer

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>
@@ skipping 349 matching lines @@
   } else if ((details().bounds_change & kBoundsChange_Resizes) &&
       details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchDrag;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |GetTarget()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(location_in_parent);
   AdjustBoundsForMainWindow(sticky_size, &bounds);
 
-  if (bounds != GetTarget()->bounds()) {
+  if (bounds != GetAuraTarget()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details().restore_bounds.IsEmpty())
         window_state()->ClearRestoreBounds();
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
   gfx::Point location_in_screen = location_in_parent;
-  ::wm::ConvertPointToScreen(GetTarget()->parent(), &location_in_screen);
+  ::wm::ConvertPointToScreen(GetAuraTarget()->parent(), &location_in_screen);
 
   aura::Window* root = NULL;
   gfx::Display display =
       ScreenUtil::FindDisplayContainingPoint(location_in_screen);
   // Track the last screen that the pointer was on to keep the snap phantom
   // window there.
   if (display.is_valid()) {
     root = Shell::GetInstance()
                ->window_tree_host_manager()
                ->GetRootWindowForDisplayId(display.id());
   }
   if (!attached_windows_.empty())
     LayoutAttachedWindows(&bounds);
-  if (bounds != GetTarget()->bounds()) {
+  if (bounds != GetAuraTarget()->bounds()) {
     // 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(
         weak_ptr_factory_.GetWeakPtr());
-    GetTarget()->SetBounds(bounds);
+    GetAuraTarget()->SetBounds(bounds);
     if (!resizer)
       return;
   }
-  const bool in_original_root = !root || root == GetTarget()->GetRootWindow();
+  const bool in_original_root =
+      !root || root == GetAuraTarget()->GetRootWindow();
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root) {
     UpdateSnapPhantomWindow(location_in_parent, bounds);
   } else {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     edge_cycler_.reset();
     SetDraggedWindowDocked(false);
   }
 }
 
 void WorkspaceWindowResizer::CompleteDrag() {
   if (!did_move_or_resize_)
     return;
 
   window_state()->set_bounds_changed_by_user(true);
   snap_phantom_window_controller_.reset();
 
   // If the window's state type changed over the course of the drag do not snap
   // the window. This happens when the user minimizes or maximizes the window
   // using a keyboard shortcut while dragging it.
   if (window_state()->GetStateType() != details().initial_state_type)
     return;
 
   bool snapped = false;
   if (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT) {
     if (!window_state()->HasRestoreBounds()) {
       gfx::Rect initial_bounds = ScreenUtil::ConvertRectToScreen(
-          GetTarget()->parent(), details().initial_bounds_in_parent);
+          GetAuraTarget()->parent(), details().initial_bounds_in_parent);
       window_state()->SetRestoreBoundsInScreen(
           details().restore_bounds.IsEmpty() ?
           initial_bounds :
           details().restore_bounds);
     }
     if (!dock_layout_->is_dragged_window_docked()) {
       UserMetricsRecorder* metrics = Shell::GetInstance()->metrics();
       // 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);
       metrics->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 ||
           !AreBoundsValidSnappedBounds(window_state()->GetStateType(),
-                                       GetTarget()->bounds())) {
+                                       GetAuraTarget()->bounds())) {
         // Set the window to WINDOW_STATE_TYPE_NORMAL but keep the
         // window at the bounds that the user has moved/resized the
         // window to. ClearRestoreBounds() is used instead of
         // SaveCurrentBoundsForRestore() because most of the restore
         // logic is skipped because we are still in the middle of a
         // drag.  TODO(pkotwicz): Fix this and use
         // SaveCurrentBoundsForRestore().
         window_state()->ClearRestoreBounds();
         window_state()->Restore();
       }
     } else if (!dock_layout_->is_dragged_window_docked()) {
       // The window was not snapped and is not snapped. This is a user
       // resize/drag and so the current bounds should be maintained, clearing
       // any prior restore bounds. When the window is docked the restore bound
       // must be kept so the docked state can be reverted properly.
       window_state()->ClearRestoreBounds();
     }
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   window_state()->set_bounds_changed_by_user(initial_bounds_changed_by_user_);
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
-  GetTarget()->SetBounds(details().initial_bounds_in_parent);
+  GetAuraTarget()->SetBounds(details().initial_bounds_in_parent);
   if (!details().restore_bounds.IsEmpty()) {
     window_state()->SetRestoreBoundsInScreen(details().restore_bounds);
   }
 
   if (details().window_component == HTRIGHT) {
     int last_x = details().initial_bounds_in_parent.right();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
       gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_x(last_x);
       bounds.set_width(initial_size_[i]);
@@ skipping 30 matching lines @@
 
   // 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* shell = Shell::GetInstance();
     shell->cursor_manager()->LockCursor();
     did_lock_cursor_ = true;
   }
 
   aura::Window* dock_container = Shell::GetContainer(
-      GetTarget()->GetRootWindow(), kShellWindowId_DockedContainer);
+      GetAuraTarget()->GetRootWindow(), kShellWindowId_DockedContainer);
   dock_layout_ = static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
 
   // 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.
   int total_available = 0;
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Size min(attached_windows_[i]->delegate()->GetMinimumSize());
     int initial_size = PrimaryAxisSize(attached_windows_[i]->bounds().size());
     initial_size_.push_back(initial_size);
     // If current size is smaller than the min, use the current size as the min.
     // This way we don't snap on resize.
     int min_size = std::min(initial_size,
                             std::max(PrimaryAxisSize(min), kMinOnscreenSize));
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
   instance = this;
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(
     gfx::Rect* bounds) {
-  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      GetTarget()));
+  gfx::Rect work_area(
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetAuraTarget()));
   int initial_size = PrimaryAxisSize(details().initial_bounds_in_parent.size());
   int current_size = PrimaryAxisSize(bounds->size());
   int start = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
   int end = PrimaryAxisCoordinate(work_area.right(), work_area.bottom());
 
   int delta = current_size - initial_size;
   int available_size = end - start;
   std::vector<int> sizes;
   int leftovers = CalculateAttachedSizes(delta, available_size, &sizes);
 
@@ skipping 119 matching lines @@
     int min = PrimaryAxisSize(delegate->GetMinimumSize());
     int max = PrimaryAxisSize(delegate->GetMaximumSize());
 
     sizes->push_back(WindowSize(initial_size, min, max));
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapToOtherWindows(gfx::Rect* bounds) {
   if (UpdateMagnetismWindow(*bounds, kAllMagnetismEdges)) {
     gfx::Point point = OriginForMagneticAttach(
-        ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), *bounds),
-        magnetism_window_->GetBoundsInScreen(),
-        magnetism_edge_);
-    aura::client::GetScreenPositionClient(GetTarget()->GetRootWindow())->
-        ConvertPointFromScreen(GetTarget()->parent(), &point);
+        ScreenUtil::ConvertRectToScreen(GetAuraTarget()->parent(), *bounds),
+        magnetism_window_->GetBoundsInScreen(), magnetism_edge_);
+    aura::client::GetScreenPositionClient(GetAuraTarget()->GetRootWindow())
+        ->ConvertPointFromScreen(GetAuraTarget()->parent(), &point);
     bounds->set_origin(point);
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
     gfx::Rect* bounds) {
   const uint32_t edges =
       WindowComponentToMagneticEdge(details().window_component);
   if (UpdateMagnetismWindow(*bounds, edges)) {
     *bounds = ScreenUtil::ConvertRectFromScreen(
-        GetTarget()->parent(),
+        GetAuraTarget()->parent(),
         BoundsForMagneticResizeAttach(
-            ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), *bounds),
-            magnetism_window_->GetBoundsInScreen(),
-            magnetism_edge_));
+            ScreenUtil::ConvertRectToScreen(GetAuraTarget()->parent(), *bounds),
+            magnetism_window_->GetBoundsInScreen(), magnetism_edge_));
   }
 }
 
 bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
                                                    uint32_t edges) {
   // |bounds| are in coordinates of original window's parent.
   gfx::Rect bounds_in_screen =
-      ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), bounds);
+      ScreenUtil::ConvertRectToScreen(GetAuraTarget()->parent(), bounds);
   MagnetismMatcher matcher(bounds_in_screen, edges);
 
   // If we snapped to a window then check it first. That way we don't bounce
   // around when close to multiple edges.
   if (magnetism_window_) {
     if (window_tracker_.Contains(magnetism_window_) &&
         matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
                              &magnetism_edge_)) {
       return true;
     }
     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;
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     const aura::Window* root_window = *iter;
     // Test all children from the desktop in each root window.
     const aura::Window::Windows& children = Shell::GetContainer(
         root_window, kShellWindowId_DefaultContainer)->children();
     for (aura::Window::Windows::const_reverse_iterator i = children.rbegin();
          i != children.rend() && !matcher.AreEdgesObscured(); ++i) {
       wm::WindowState* other_state = wm::GetWindowState(*i);
-      if (other_state->aura_window() == GetTarget() ||
+      if (other_state->aura_window() == GetAuraTarget() ||
           !other_state->window()->IsVisible() ||
           !other_state->IsNormalOrSnapped() || !other_state->CanResize()) {
         continue;
       }
       if (matcher.ShouldAttach(
               other_state->window()->GetBoundsInScreen(), &magnetism_edge_)) {
         magnetism_window_ = other_state->aura_window();
         window_tracker_.Add(magnetism_window_);
         return true;
       }
     }
   }
   return false;
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
     int sticky_size,
     gfx::Rect* bounds) {
   gfx::Point last_mouse_location_in_screen = last_mouse_location_;
-  ::wm::ConvertPointToScreen(GetTarget()->parent(),
+  ::wm::ConvertPointToScreen(GetAuraTarget()->parent(),
                              &last_mouse_location_in_screen);
   gfx::Display display = gfx::Screen::GetScreen()->GetDisplayNearestPoint(
       last_mouse_location_in_screen);
-  gfx::Rect work_area =
-      ScreenUtil::ConvertRectFromScreen(GetTarget()->parent(),
-                                       display.work_area());
+  gfx::Rect work_area = ScreenUtil::ConvertRectFromScreen(
+      GetAuraTarget()->parent(), display.work_area());
   if (details().window_component == HTCAPTION) {
     // Adjust the bounds to the work area where the mouse cursor is located.
     // Always keep kMinOnscreenHeight or the window height (whichever is less)
     // on the bottom.
     int max_y = work_area.bottom() - std::min(kMinOnscreenHeight,
                                               bounds->height());
     if (bounds->y() > max_y) {
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
       // Don't allow dragging above the top of the display until the mouse
@@ skipping 116 matching lines @@
     if (snap_type_ == SNAP_NONE) {
       SetDraggedWindowDocked(false);
       return;
     }
   }
 
   DCHECK(snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT);
   DockedAlignment desired_alignment = (snap_type_ == SNAP_LEFT) ?
       DOCKED_ALIGNMENT_LEFT : DOCKED_ALIGNMENT_RIGHT;
   const bool can_dock =
-      dock_layout_->CanDockWindow(GetTarget(), desired_alignment) &&
-      dock_layout_->GetAlignmentOfWindow(GetTarget()) != DOCKED_ALIGNMENT_NONE;
+      dock_layout_->CanDockWindow(GetAuraTarget(), desired_alignment) &&
+      dock_layout_->GetAlignmentOfWindow(GetAuraTarget()) !=
+          DOCKED_ALIGNMENT_NONE;
   if (!can_dock) {
     // If the window cannot be docked, undock the window. This may change the
     // workspace bounds and hence |snap_type_|.
     SetDraggedWindowDocked(false);
     snap_type_ = GetSnapType(location);
   }
   const bool can_snap = snap_type_ != SNAP_NONE && window_state()->CanSnap();
   if (!can_snap && !can_dock) {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     edge_cycler_.reset();
     return;
   }
   if (!edge_cycler_) {
     edge_cycler_.reset(new TwoStepEdgeCycler(
         location, snap_type_ == SNAP_LEFT
                       ? TwoStepEdgeCycler::DIRECTION_LEFT
                       : TwoStepEdgeCycler::DIRECTION_RIGHT));
   } else {
     edge_cycler_->OnMove(location);
   }
 
   // Update phantom window with snapped or docked guide bounds.
   // Windows that cannot be snapped or are less wide than kMaxDockWidth can get
   // docked without going through a snapping sequence.
   gfx::Rect phantom_bounds;
-  const bool should_dock = can_dock &&
-      (!can_snap ||
-       GetTarget()->bounds().width() <=
-           DockedWindowLayoutManager::kMaxDockWidth ||
-       edge_cycler_->use_second_mode() ||
-       dock_layout_->is_dragged_window_docked());
+  const bool should_dock =
+      can_dock && (!can_snap ||
+                   GetAuraTarget()->bounds().width() <=
+                       DockedWindowLayoutManager::kMaxDockWidth ||
+                   edge_cycler_->use_second_mode() ||
+                   dock_layout_->is_dragged_window_docked());
   if (should_dock) {
     SetDraggedWindowDocked(true);
     phantom_bounds = ScreenUtil::ConvertRectFromScreen(
-        GetTarget()->parent(), dock_layout_->dragged_bounds());
+        GetAuraTarget()->parent(), dock_layout_->dragged_bounds());
   } else {
     phantom_bounds = (snap_type_ == SNAP_LEFT)
                          ? wm::GetDefaultLeftSnappedWindowBoundsInParent(
-                               wm::WmWindowAura::Get(GetTarget()))
+                               wm::WmWindowAura::Get(GetAuraTarget()))
                          : wm::GetDefaultRightSnappedWindowBoundsInParent(
-                               wm::WmWindowAura::Get(GetTarget()));
+                               wm::WmWindowAura::Get(GetAuraTarget()));
   }
 
   if (!snap_phantom_window_controller_) {
     snap_phantom_window_controller_.reset(
-        new PhantomWindowController(GetTarget()));
+        new PhantomWindowController(GetAuraTarget()));
   }
   snap_phantom_window_controller_->Show(ScreenUtil::ConvertRectToScreen(
-      GetTarget()->parent(), phantom_bounds));
+      GetAuraTarget()->parent(), 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.
   typedef std::map<size_t, aura::Window*> IndexToWindowMap;
   IndexToWindowMap map;
-  aura::Window* parent = GetTarget()->parent();
+  aura::Window* parent = GetAuraTarget()->parent();
   const aura::Window::Windows& windows(parent->children());
-  map[std::find(windows.begin(), windows.end(), GetTarget()) -
-      windows.begin()] = GetTarget();
+  map[std::find(windows.begin(), windows.end(), GetAuraTarget()) -
+      windows.begin()] = GetAuraTarget();
   for (std::vector<aura::Window*>::const_iterator i =
            attached_windows_.begin(); i != attached_windows_.end(); ++i) {
     if ((*i)->parent() != 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 (IndexToWindowMap::const_reverse_iterator i = map.rbegin();
        i != map.rend(); ) {
     aura::Window* 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.
-  gfx::Rect area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()));
+  gfx::Rect area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetAuraTarget()));
   if (details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     // Increase tolerance for touch-snapping near the screen edges. This is only
     // necessary when the work area left or right edge is same as screen edge.
-    gfx::Rect display_bounds(ScreenUtil::GetDisplayBoundsInParent(GetTarget()));
+    gfx::Rect display_bounds(
+        ScreenUtil::GetDisplayBoundsInParent(GetAuraTarget()));
     int inset_left = 0;
     if (area.x() == display_bounds.x())
       inset_left = kScreenEdgeInsetForTouchDrag;
     int inset_right = 0;
     if (area.right() == display_bounds.right())
       inset_right = kScreenEdgeInsetForTouchDrag;
     area.Inset(inset_left, 0, inset_right, 0);
   }
   if (location.x() <= area.x())
     return SNAP_LEFT;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT;
   return SNAP_NONE;
 }
 
 void WorkspaceWindowResizer::SetDraggedWindowDocked(bool should_dock) {
   if (should_dock) {
     if (!dock_layout_->is_dragged_window_docked()) {
       window_state()->set_bounds_changed_by_user(false);
-      dock_layout_->DockDraggedWindow(GetTarget());
+      dock_layout_->DockDraggedWindow(GetAuraTarget());
     }
   } else {
     if (dock_layout_->is_dragged_window_docked()) {
       dock_layout_->UndockDraggedWindow();
       window_state()->set_bounds_changed_by_user(true);
     }
   }
 }
 
 bool WorkspaceWindowResizer::AreBoundsValidSnappedBounds(
     wm::WindowStateType snapped_type,
     const gfx::Rect& bounds_in_parent) const {
   DCHECK(snapped_type == wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ||
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
-  gfx::Rect snapped_bounds = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      GetTarget());
+  gfx::Rect snapped_bounds =
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetAuraTarget());
   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