Prevents panels attached to shelf from docking

ash/wm/panels/panel_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/panels/panel_window_resizer.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_types.h"
@@ skipping 29 matching lines @@
 }
 
 }  // namespace
 
 PanelWindowResizer::~PanelWindowResizer() {
 }
 
 // static
 PanelWindowResizer*
 PanelWindowResizer::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 PanelWindowResizer(next_window_resizer, details) : NULL;
+                           wm::WindowState* window_state) {
+  return new PanelWindowResizer(next_window_resizer, window_state);
 }
 
 void PanelWindowResizer::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();
   }
 
@@ skipping 14 matching lines @@
         GetRootWindowForDisplayId(dst_display.id());
     panel_container_ = Shell::GetContainer(
         dst_root, internal::kShellWindowId_PanelContainer);
 
     // The panel's parent already knows that the drag is in progress for this
     // panel.
     if (panel_container_ && GetTarget()->parent() != panel_container_)
       GetPanelLayoutManager(panel_container_)->StartDragging(GetTarget());
   }
   gfx::Point offset;
-  gfx::Rect bounds(CalculateBoundsForDrag(details_, location));
-  should_attach_ = AttachToLauncher(bounds, &offset);
+  gfx::Rect bounds(CalculateBoundsForDrag(location));
+  if (!(details().bounds_change & WindowResizer::kBoundsChange_Resizes)) {
+    window_state_->drag_details()->should_attach_to_shelf =
+        AttachToLauncher(bounds, &offset);
+  }
   gfx::Point modified_location(location.x() + offset.x(),
                                location.y() + offset.y());
 
   base::WeakPtr<PanelWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr());
   next_window_resizer_->Drag(modified_location, event_flags);
   if (!resizer)
     return;
 
-  if (should_attach_ &&
-      !(details_.bounds_change & WindowResizer::kBoundsChange_Resizes)) {
+  if (details().should_attach_to_shelf &&
+      !(details().bounds_change & WindowResizer::kBoundsChange_Resizes)) {
     UpdateLauncherPosition();
   }
 }
 
 void PanelWindowResizer::CompleteDrag() {
   // The root window can change when dragging into a different screen.
   next_window_resizer_->CompleteDrag();
   FinishDragging();
 }
 
 void PanelWindowResizer::RevertDrag() {
   next_window_resizer_->RevertDrag();
-  should_attach_ = was_attached_;
+  window_state_->drag_details()->should_attach_to_shelf = was_attached_;
   FinishDragging();
 }
 
-aura::Window* PanelWindowResizer::GetTarget() {
-  return next_window_resizer_->GetTarget();
-}
-
-const gfx::Point& PanelWindowResizer::GetInitialLocation() const {
-  return details_.initial_location_in_parent;
-}
-
 PanelWindowResizer::PanelWindowResizer(WindowResizer* next_window_resizer,
-                                       const Details& details)
-    : details_(details),
+                                       wm::WindowState* window_state)
+    : WindowResizer(window_state),
       next_window_resizer_(next_window_resizer),
       panel_container_(NULL),
       initial_panel_container_(NULL),
       did_move_or_resize_(false),
-      was_attached_(wm::GetWindowState(GetTarget())->panel_attached()),
-      should_attach_(was_attached_),
+      was_attached_(window_state->panel_attached()),
       weak_ptr_factory_(this) {
-  DCHECK(details_.is_resizable);
+  DCHECK(details().is_resizable);
   panel_container_ = Shell::GetContainer(
-      details.window->GetRootWindow(),
+      GetTarget()->GetRootWindow(),
       internal::kShellWindowId_PanelContainer);
   initial_panel_container_ = panel_container_;
 }
 
 bool PanelWindowResizer::AttachToLauncher(const gfx::Rect& bounds,
                                           gfx::Point* offset) {
   bool should_attach = false;
   if (panel_container_) {
     internal::PanelLayoutManager* panel_layout_manager =
         GetPanelLayoutManager(panel_container_);
@@ skipping 35 matching lines @@
   return should_attach;
 }
 
 void PanelWindowResizer::StartedDragging() {
   // Tell the panel layout manager that we are dragging this panel before
   // attaching it so that it does not get repositioned.
   if (panel_container_)
     GetPanelLayoutManager(panel_container_)->StartDragging(GetTarget());
   if (!was_attached_) {
     // Attach the panel while dragging placing it in front of other panels.
-    wm::GetWindowState(GetTarget())->set_continue_drag_after_reparent(true);
-    wm::GetWindowState(GetTarget())->set_panel_attached(true);
+    window_state_->set_continue_drag_after_reparent(true);
+    window_state_->set_panel_attached(true);
     // We use root window coordinates to ensure that during the drag the panel
     // is reparented to a container in the root window that has that window.
     aura::Window* target = GetTarget();
     aura::Window* target_root = target->GetRootWindow();
     aura::Window* old_parent = target->parent();
     aura::client::ParentWindowWithContext(
         target, target_root, target_root->GetBoundsInScreen());
     wm::ReparentTransientChildrenOfChild(target, old_parent, target->parent());
   }
 }
 
 void PanelWindowResizer::FinishDragging() {
   if (!did_move_or_resize_)
     return;
-  if (details_.bounds_change & WindowResizer::kBoundsChange_Resizes)
-    should_attach_ = was_attached_;
-  if (wm::GetWindowState(GetTarget())->panel_attached() != should_attach_) {
-    wm::GetWindowState(GetTarget())->set_panel_attached(should_attach_);
+  if (window_state_->panel_attached() != details().should_attach_to_shelf) {
+    window_state_->set_panel_attached(details().should_attach_to_shelf);
     // We use last known location to ensure that after the drag the panel
     // is reparented to a container in the root window that has that location.
     aura::Window* target = GetTarget();
     aura::Window* target_root = target->GetRootWindow();
     aura::Window* old_parent = target->parent();
     aura::client::ParentWindowWithContext(
         target, target_root, gfx::Rect(last_location_, gfx::Size()));
     wm::ReparentTransientChildrenOfChild(target, old_parent, target->parent());
   }
 
   // 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_panel_container_ != panel_container_)
      GetPanelLayoutManager(initial_panel_container_)->FinishDragging();
   if (panel_container_)
     GetPanelLayoutManager(panel_container_)->FinishDragging();
 }
 
 void PanelWindowResizer::UpdateLauncherPosition() {
   if (panel_container_) {
     GetPanelLayoutManager(panel_container_)->shelf()->
         UpdateIconPositionForWindow(GetTarget());
   }
 }
 
 }  // namespace aura