Prevents panels attached to shelf from docking

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/display_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf.h"
@@ skipping 39 matching lines @@
 }
 
 }  // namespace
 
 DockedWindowResizer::~DockedWindowResizer() {
 }
 
 // static
 DockedWindowResizer*
 DockedWindowResizer::Create(WindowResizer* next_window_resizer,
-                            aura::Window* window,
-                            const gfx::Point& location,
-                            int window_component,
-                            aura::client::WindowMoveSource source) {
-  Details details(window, location, window_component, source);
-  return details.is_resizable ?
-      new DockedWindowResizer(next_window_resizer, details) : NULL;
+                            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_);
   if (!did_move_or_resize_) {
     did_move_or_resize_ = true;
     StartedDragging();
   }
   gfx::Point offset;
-  gfx::Rect bounds(CalculateBoundsForDrag(details_, location));
+  gfx::Rect bounds(CalculateBoundsForDrag(location));
   MaybeSnapToEdge(bounds, &offset);
   gfx::Point modified_location(location);
   modified_location.Offset(offset.x(), offset.y());
 
   base::WeakPtr<DockedWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr());
   next_window_resizer_->Drag(modified_location, event_flags);
   if (!resizer)
     return;
 
   DockedWindowLayoutManager* new_dock_layout =
       GetDockedLayoutManagerAtPoint(last_location_);
   if (new_dock_layout && new_dock_layout != dock_layout_) {
     // The window is being dragged to a new display. If the previous
     // container is the current parent of the window it will be informed of
     // the end of drag when the window is reparented, otherwise let the
     // previous container know the drag is complete. If we told the
     // window's parent that the drag was complete it would begin
     // positioning the window.
     if (is_docked_ && dock_layout_->is_dragged_window_docked())
       dock_layout_->UndockDraggedWindow();
     if (dock_layout_ != initial_dock_layout_)
       dock_layout_->FinishDragging(
           DOCKED_ACTION_NONE,
-          details_.source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
+          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());
   }
   // Window could get docked by the WorkspaceWindowResizer, update the state.
   is_docked_ = dock_layout_->is_dragged_window_docked();
@@ skipping 15 matching lines @@
   if (is_docked_ != was_docked_) {
     is_docked_ = was_docked_;
     if (is_docked_)
       dock_layout_->DockDraggedWindow(GetTarget());
     else
       dock_layout_->UndockDraggedWindow();
   }
   FinishedDragging();
 }
 
-aura::Window* DockedWindowResizer::GetTarget() {
-  return next_window_resizer_->GetTarget();
-}
-
-const gfx::Point& DockedWindowResizer::GetInitialLocation() const {
-  return details_.initial_location_in_parent;
-}
-
 DockedWindowResizer::DockedWindowResizer(WindowResizer* next_window_resizer,
-                                         const Details& details)
-    : details_(details),
+                                         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_(
-          wm::GetWindowState(details.window)->bounds_changed_by_user()),
+      was_bounds_changed_by_user_(window_state->bounds_changed_by_user()),
       weak_ptr_factory_(this) {
-  DCHECK(details_.is_resizable);
+  DCHECK(details().is_resizable);
   aura::Window* dock_container = Shell::GetContainer(
-      details.window->GetRootWindow(),
+      GetTarget()->GetRootWindow(),
       kShellWindowId_DockedContainer);
   dock_layout_ = static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
   initial_dock_layout_ = dock_layout_;
-  was_docked_ = details.window->parent() == dock_container;
+  was_docked_ = GetTarget()->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 = ScreenAsh::ConvertRectFromScreen(
@@ skipping 15 matching lines @@
   if (dock_alignment == DOCKED_ALIGNMENT_RIGHT ||
       dock_alignment == DOCKED_ALIGNMENT_NONE) {
     const int distance = dock_bounds.right() - bounds.right();
     if (distance < kSnapToDockDistance && distance > 0)
       offset->set_x(distance);
   }
 }
 
 void DockedWindowResizer::StartedDragging() {
   // During resizing the window width is preserved by DockedwindowLayoutManager.
-  wm::WindowState* window_state = wm::GetWindowState(GetTarget());
   if (is_docked_ &&
-      (details_.bounds_change & WindowResizer::kBoundsChange_Resizes)) {
-    window_state->set_bounds_changed_by_user(true);
+      (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());
   // 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) {
     // The window is going to be reparented - avoid completing the drag.
-    window_state->set_continue_drag_after_reparent(true);
+    window_state_->set_continue_drag_after_reparent(true);
 
     // 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);
     wm::ReparentChildWithTransientChildren(GetTarget(),
                                            GetTarget()->parent(),
                                            docked_container);
   }
   if (is_docked_)
     dock_layout_->DockDraggedWindow(GetTarget());
 }
 
 void DockedWindowResizer::FinishedDragging() {
   if (!did_move_or_resize_)
     return;
   did_move_or_resize_ = false;
   aura::Window* window = GetTarget();
-  wm::WindowState* window_state = wm::GetWindowState(window);
   const bool is_attached_panel = window->type() == ui::wm::WINDOW_TYPE_PANEL &&
-                                 window_state->panel_attached();
+                                 window_state_->panel_attached();
   const bool is_resized =
-      (details_.bounds_change & WindowResizer::kBoundsChange_Resizes) != 0;
+      (details().bounds_change & WindowResizer::kBoundsChange_Resizes) != 0;
 
   // When drag is completed the dragged docked window is resized to the bounds
   // calculated by the layout manager that conform to other docked windows.
   if (!is_attached_panel && is_docked_ && !is_resized) {
     gfx::Rect bounds = ScreenAsh::ConvertRectFromScreen(
         window->parent(), dock_layout_->dragged_bounds());
     if (!bounds.IsEmpty() && bounds.width() != window->bounds().width()) {
       window->SetBounds(bounds);
     }
   }
   // If a window has restore bounds, update the restore origin and width but not
   // the height (since the height is auto-calculated for the docked windows).
-  if (is_resized && is_docked_ && window_state->HasRestoreBounds()) {
+  if (is_resized && is_docked_ && window_state_->HasRestoreBounds()) {
     gfx::Rect restore_bounds = window->GetBoundsInScreen();
     restore_bounds.set_height(
-        window_state->GetRestoreBoundsInScreen().height());
-    window_state->SetRestoreBoundsInScreen(restore_bounds);
+        window_state_->GetRestoreBoundsInScreen().height());
+    window_state_->SetRestoreBoundsInScreen(restore_bounds);
   }
 
   // Check if the window needs to be docked or returned to workspace.
   DockedAction action = MaybeReparentWindowOnDragCompletion(is_resized,
                                                             is_attached_panel);
   dock_layout_->FinishDragging(
       action,
-      details_.source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
+      details().source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
           DOCKED_ACTION_SOURCE_MOUSE : DOCKED_ACTION_SOURCE_TOUCH);
 
   // If we started the drag in one root window and moved into another root
   // but then canceled the drag we may need to inform the original layout
   // manager that the drag is finished.
   if (initial_dock_layout_ != dock_layout_)
     initial_dock_layout_->FinishDragging(
         DOCKED_ACTION_NONE,
-        details_.source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
+        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();
 
   // Check if the window needs to be docked or returned to workspace.
   DockedAction action = DOCKED_ACTION_NONE;
@@ skipping 42 matching lines @@
   // before.
   if (is_docked_) {
     wm::GetWindowState(window)->set_bounds_changed_by_user(
         was_docked_ && (is_resized || was_bounds_changed_by_user_));
   }
   return action;
 }
 
 }  // namespace internal
 }  // namespace ash