Removes most aura dependencies from WindowResizer

ash/wm/dock/docked_window_resizer.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/wm/dock/docked_window_resizer.h"
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
@@ skipping 48 matching lines @@
 
 // static
 DockedWindowResizer*
 DockedWindowResizer::Create(WindowResizer* next_window_resizer,
                             wm::WindowState* window_state) {
   return new DockedWindowResizer(next_window_resizer, window_state);
 }
 
 void DockedWindowResizer::Drag(const gfx::Point& location, int event_flags) {
   last_location_ = location;
-  ::wm::ConvertPointToScreen(GetTarget()->parent(), &last_location_);
+  ::wm::ConvertPointToScreen(GetAuraTarget()->parent(), &last_location_);
   base::WeakPtr<DockedWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr());
 
   if (!did_move_or_resize_) {
     did_move_or_resize_ = true;
     StartedDragging(resizer);
   }
   if (!resizer)
     return;
 
   gfx::Point offset;
@@ skipping 20 matching lines @@
     if (dock_layout_ != initial_dock_layout_)
       dock_layout_->FinishDragging(
           DOCKED_ACTION_NONE,
           details().source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
               DOCKED_ACTION_SOURCE_MOUSE : DOCKED_ACTION_SOURCE_TOUCH);
     is_docked_ = false;
     dock_layout_ = new_dock_layout;
     // The window's initial layout manager already knows that the drag is
     // in progress for this window.
     if (new_dock_layout != initial_dock_layout_)
-      new_dock_layout->StartDragging(GetTarget());
+      new_dock_layout->StartDragging(GetAuraTarget());
   }
   // Window could get docked by the WorkspaceWindowResizer, update the state.
   is_docked_ = dock_layout_->is_dragged_window_docked();
   // Whenever a window is dragged out of the dock it will be auto-sized
   // in the dock if it gets docked again.
   if (!is_docked_)
     was_bounds_changed_by_user_ = false;
 }
 
 void DockedWindowResizer::CompleteDrag() {
   // The root window can change when dragging into a different screen.
   next_window_resizer_->CompleteDrag();
   FinishedDragging(aura::client::MOVE_SUCCESSFUL);
 }
 
 void DockedWindowResizer::RevertDrag() {
   next_window_resizer_->RevertDrag();
   // Restore docked state to what it was before the drag if necessary.
   if (is_docked_ != was_docked_) {
     is_docked_ = was_docked_;
     if (is_docked_)
-      dock_layout_->DockDraggedWindow(GetTarget());
+      dock_layout_->DockDraggedWindow(GetAuraTarget());
     else
       dock_layout_->UndockDraggedWindow();
   }
   FinishedDragging(aura::client::MOVE_CANCELED);
 }
 
 DockedWindowResizer::DockedWindowResizer(WindowResizer* next_window_resizer,
                                          wm::WindowState* window_state)
     : WindowResizer(window_state),
       next_window_resizer_(next_window_resizer),
       dock_layout_(NULL),
       initial_dock_layout_(NULL),
       did_move_or_resize_(false),
       was_docked_(false),
       is_docked_(false),
       was_bounds_changed_by_user_(window_state->bounds_changed_by_user()),
       weak_ptr_factory_(this) {
   DCHECK(details().is_resizable);
   aura::Window* dock_container = Shell::GetContainer(
-      GetTarget()->GetRootWindow(),
-      kShellWindowId_DockedContainer);
+      GetAuraTarget()->GetRootWindow(), kShellWindowId_DockedContainer);
   dock_layout_ = static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
   initial_dock_layout_ = dock_layout_;
-  was_docked_ = GetTarget()->parent() == dock_container;
+  was_docked_ = GetAuraTarget()->parent() == dock_container;
   is_docked_ = was_docked_;
 }
 
 void DockedWindowResizer::MaybeSnapToEdge(const gfx::Rect& bounds,
                                           gfx::Point* offset) {
   // Windows only snap magnetically when they were previously docked.
   if (!was_docked_)
     return;
   DockedAlignment dock_alignment = dock_layout_->CalculateAlignment();
   gfx::Rect dock_bounds = ScreenUtil::ConvertRectFromScreen(
-      GetTarget()->parent(),
+      GetAuraTarget()->parent(),
       dock_layout_->dock_container()->GetBoundsInScreen());
 
   // Short-range magnetism when retaining docked state. Same constant as in
   // MagnetismMatcher is used for consistency.
   const int kSnapToDockDistance = MagnetismMatcher::kMagneticDistance;
 
   if (dock_alignment == DOCKED_ALIGNMENT_LEFT ||
       dock_alignment == DOCKED_ALIGNMENT_NONE) {
     const int distance = bounds.x() - dock_bounds.x();
     if (distance < kSnapToDockDistance && distance > 0) {
@@ skipping 13 matching lines @@
     base::WeakPtr<DockedWindowResizer>& resizer) {
   // During resizing the window width is preserved by DockedwindowLayoutManager.
   if (is_docked_ &&
       (details().bounds_change & WindowResizer::kBoundsChange_Resizes)) {
     window_state_->set_bounds_changed_by_user(true);
   }
 
   // Tell the dock layout manager that we are dragging this window.
   // At this point we are not yet animating the window as it may not be
   // inside the docked area.
-  dock_layout_->StartDragging(GetTarget());
+  dock_layout_->StartDragging(GetAuraTarget());
   if (!resizer)
     return;
   // Reparent workspace windows during the drag to elevate them above workspace.
   // Other windows for which the DockedWindowResizer is instantiated include
   // panels and windows that are already docked. Those do not need reparenting.
-  if (GetTarget()->type() != ui::wm::WINDOW_TYPE_PANEL &&
-      GetTarget()->parent()->id() == kShellWindowId_DefaultContainer) {
+  if (GetAuraTarget()->type() != ui::wm::WINDOW_TYPE_PANEL &&
+      GetAuraTarget()->parent()->id() == kShellWindowId_DefaultContainer) {
     // Reparent the window into the docked windows container in order to get it
     // on top of other docked windows.
     aura::Window* docked_container = Shell::GetContainer(
-        GetTarget()->GetRootWindow(),
-        kShellWindowId_DockedContainer);
+        GetAuraTarget()->GetRootWindow(), kShellWindowId_DockedContainer);
     ReparentChildWithTransientChildren(
-        ash::wm::WmWindowAura::Get(GetTarget()),
-        ash::wm::WmWindowAura::Get(GetTarget()->parent()),
+        ash::wm::WmWindowAura::Get(GetAuraTarget()),
+        ash::wm::WmWindowAura::Get(GetAuraTarget()->parent()),
         ash::wm::WmWindowAura::Get(docked_container));
     if (!resizer)
       return;
   }
   if (is_docked_)
-    dock_layout_->DockDraggedWindow(GetTarget());
+    dock_layout_->DockDraggedWindow(GetAuraTarget());
 }
 
 void DockedWindowResizer::FinishedDragging(
     aura::client::WindowMoveResult move_result) {
   if (!did_move_or_resize_)
     return;
   did_move_or_resize_ = false;
-  aura::Window* window = GetTarget();
+  aura::Window* window = GetAuraTarget();
   const bool is_attached_panel = window->type() == ui::wm::WINDOW_TYPE_PANEL &&
                                  window_state_->panel_attached();
   const bool is_resized =
       (details().bounds_change & WindowResizer::kBoundsChange_Resizes) != 0;
 
   // Undock the window if it is not in the normal, docked or minimized state
   // type. This happens if a user snaps or maximizes a window using a
   // keyboard shortcut while it is being dragged.
   if (!window_state_->IsMinimized() && !window_state_->IsDocked() &&
       !window_state_->IsNormalStateType())
@@ skipping 30 matching lines @@
   if (initial_dock_layout_ != dock_layout_)
     initial_dock_layout_->FinishDragging(
         DOCKED_ACTION_NONE,
         details().source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
             DOCKED_ACTION_SOURCE_MOUSE : DOCKED_ACTION_SOURCE_TOUCH);
   is_docked_ = false;
 }
 
 DockedAction DockedWindowResizer::MaybeReparentWindowOnDragCompletion(
     bool is_resized, bool is_attached_panel) {
-  aura::Window* window = GetTarget();
+  aura::Window* window = GetAuraTarget();
 
   // Check if the window needs to be docked or returned to workspace.
   DockedAction action = DOCKED_ACTION_NONE;
   aura::Window* dock_container = Shell::GetContainer(
       window->GetRootWindow(),
       kShellWindowId_DockedContainer);
   if ((is_resized || !is_attached_panel) &&
       is_docked_ != (window->parent() == dock_container)) {
     if (is_docked_) {
       wm::ReparentChildWithTransientChildren(
@@ skipping 48 matching lines @@
   } else if (wm::GetWindowState(window)->IsDocked() &&
              action == DOCKED_ACTION_UNDOCK) {
     const wm::WMEvent event(wm::WM_EVENT_NORMAL);
     window_state_->OnWMEvent(&event);
   }
 
   return action;
 }
 
 }  // namespace ash