Converts DockedWindowLayoutManager to common ash/wm types

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/shell_window_ids.h"
 #include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/common/window_parenting_utils.h"
 #include "ash/wm/common/wm_event.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/common/wm_window.h"
 #include "ash/wm/dock/docked_window_layout_manager.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/workspace/magnetism_matcher.h"
-#include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace {
 
-DockedWindowLayoutManager* GetDockedLayoutManagerInRoot(wm::WmWindow* root) {
-  wm::WmWindow* dock_container =
-      root->GetChildByShellWindowId(kShellWindowId_DockedContainer);
-  return static_cast<DockedWindowLayoutManager*>(
-      wm::WmWindowAura::GetAuraWindow(dock_container)->layout_manager());
-}
-
 DockedWindowLayoutManager* GetDockedLayoutManagerAtPoint(
     const gfx::Point& point) {
   gfx::Display display =
       gfx::Screen::GetScreen()->GetDisplayNearestPoint(point);
   if (!display.bounds().Contains(point))
     return nullptr;
 
-  return GetDockedLayoutManagerInRoot(
+  return DockedWindowLayoutManager::Get(
       wm::WmRootWindowController::GetWithDisplayId(display.id())->GetWindow());
 }
 
 }  // namespace
 
 DockedWindowResizer::~DockedWindowResizer() {
 }
 
 // static
 DockedWindowResizer*
@@ skipping 37 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(GetAuraTarget());
+      new_dock_layout->StartDragging(GetTarget());
   }
   // 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(GetAuraTarget());
+      dock_layout_->DockDraggedWindow(GetTarget());
     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);
-  wm::WmWindow* dock_container =
-      GetTarget()->GetRootWindow()->GetChildByShellWindowId(
-          kShellWindowId_DockedContainer);
-  dock_layout_ = GetDockedLayoutManagerInRoot(GetTarget()->GetRootWindow());
+  dock_layout_ = DockedWindowLayoutManager::Get(GetTarget()->GetRootWindow());
   initial_dock_layout_ = dock_layout_;
-  was_docked_ = GetTarget()->GetParent() == dock_container;
+  was_docked_ = GetTarget()->GetParent() == dock_layout_->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 = GetTarget()->GetParent()->ConvertRectFromScreen(
@@ skipping 23 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(GetAuraTarget());
+  dock_layout_->StartDragging(GetTarget());
   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()->GetType() != ui::wm::WINDOW_TYPE_PANEL &&
       GetTarget()->GetParent()->GetShellWindowId() ==
           kShellWindowId_DefaultContainer) {
     // Reparent the window into the docked windows container in order to get it
     // on top of other docked windows.
     wm::WmWindow* docked_container =
         GetTarget()->GetRootWindow()->GetChildByShellWindowId(
             kShellWindowId_DockedContainer);
     ReparentChildWithTransientChildren(GetTarget(), GetTarget()->GetParent(),
                                        docked_container);
     if (!resizer)
       return;
   }
   if (is_docked_)
-    dock_layout_->DockDraggedWindow(GetAuraTarget());
+    dock_layout_->DockDraggedWindow(GetTarget());
 }
 
 void DockedWindowResizer::FinishedDragging(
     aura::client::WindowMoveResult move_result) {
   if (!did_move_or_resize_)
     return;
   did_move_or_resize_ = false;
   wm::WmWindow* window = GetTarget();
   const bool is_attached_panel =
       window->GetType() == ui::wm::WINDOW_TYPE_PANEL &&
@@ skipping 105 matching lines @@
   } else if (window->GetWindowState()->IsDocked() &&
              action == DOCKED_ACTION_UNDOCK) {
     const wm::WMEvent event(wm::WM_EVENT_NORMAL);
     window_state_->OnWMEvent(&event);
   }
 
   return action;
 }
 
 }  // namespace ash