Change to update panel positions after panels moved to the new collection when the unstacking happe…

chrome/browser/ui/panels/panel_drag_controller.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 "chrome/browser/ui/panels/panel_drag_controller.h"
 
 #include "base/logging.h"
 #include "chrome/browser/ui/panels/detached_panel_collection.h"
 #include "chrome/browser/ui/panels/detached_panel_drag_handler.h"
 #include "chrome/browser/ui/panels/docked_panel_collection.h"
@@ skipping 428 matching lines @@
   gfx::Rect target_bounds = last_panel_to_unstack->GetBounds();
   target_bounds.Offset(delta);
   gfx::Rect below_panel_bounds = panel_below_last_panel_to_unstack->GetBounds();
   if (GetVerticalDistance(target_bounds, below_panel_bounds) <
           kGluePanelsDistanceThreshold &&
       GetHorizontalOverlap(target_bounds, below_panel_bounds) >
           kGluePanelsOverlapThreshold) {
     return false;
   }
 
-  // Move the panel (and all the panels below if in a stack) to the new
-  // position.
-  for (StackedPanelCollection::Panels::const_iterator iter =
-           dragging_stack->panels().begin();
-       iter != dragging_stack->panels().end(); ++iter) {
-    if (!(*iter)->in_preview_mode())
-      break;
-    (*iter)->MoveByInstantly(delta);
-  }
-
   int num_panels_in_stack = dragging_stack->num_panels();
   DCHECK_GE(num_panels_in_stack, 2);
 
   // When a panel is removed from its stack, we always make it detached. If it
   // indeed should go to the docked collection, the subsequent TryDock will then
   // move it from the detached collection to the docked collection.
   DetachedPanelCollection* detached_collection =
       panel_manager_->detached_collection();
 
   // If there're only 2 panels in the stack, both panels should move out of the
   // stack and the stack should be removed.
   if (num_panels_in_stack == 2) {
     DCHECK_EQ(1, num_panels_to_unstack);
     MovePanelAndBelowToCollection(dragging_panel_,
                                   detached_collection,
                                   PanelCollection::KNOWN_POSITION);
+    dragging_panel_->MoveByInstantly(delta);
     return true;
   }
 
   DCHECK_GE(num_panels_in_stack, 3);
 
   // If only one panel (top panel) needs to unstack, move it out of the stack.
   if (num_panels_to_unstack == 1) {
     panel_manager_->MovePanelToCollection(dragging_panel_,
-                                          panel_manager_->detached_collection(),
+                                          detached_collection,
                                           PanelCollection::KNOWN_POSITION);
+    dragging_panel_->MoveByInstantly(delta);
     return true;
   }
 
   // If all the panels except the bottom panel need to unstack, simply move
   // bottom panel out of the stack.
   if (num_panels_in_stack - num_panels_to_unstack == 1) {
     panel_manager_->MovePanelToCollection(dragging_stack->bottom_panel(),
-                                          panel_manager_->detached_collection(),
+                                          detached_collection,
                                           PanelCollection::KNOWN_POSITION);
+    dragging_panel_->stack()->MoveAllDraggingPanelsInstantly(delta);
     return true;
   }
 
   // Otherwise, move all unstacked panels to a new stack.
   // Note that all the panels to move should be copied to a local list first
   // because the stack collection will be modified during the move.
   std::list<Panel*> panels_to_move;
   for (StackedPanelCollection::Panels::const_iterator iter =
            dragging_stack->panels().begin();
        iter != dragging_stack->panels().end(); ++iter) {
     Panel* panel = *iter;
     if (!panel->in_preview_mode())
       break;
     panels_to_move.push_back(panel);
   }
   StackedPanelCollection* new_stack = panel_manager_->CreateStack();
   for (std::list<Panel*>::const_iterator iter = panels_to_move.begin();
        iter != panels_to_move.end(); ++iter) {
     panel_manager_->MovePanelToCollection(*iter,
                                           new_stack,
                                           PanelCollection::KNOWN_POSITION);
   }
+  dragging_panel_->stack()->MoveAllDraggingPanelsInstantly(delta);
 
   return true;
 }
 
 // Check if a panel or a set of stacked panels (being dragged together from a
 // stack) can be dragged away from the panel above such that the former panel(s)
 // are not in the same stack as the latter panel.
 bool PanelDragController::TryUnstackFromBottom(
     const gfx::Point& target_position) {
   // It has to be stacked.
@@ skipping 13 matching lines @@
   Panel* above_panel = dragging_stack->GetPanelAbove(dragging_panel_);
   DCHECK(above_panel);
   gfx::Rect above_panel_bounds = above_panel->GetBounds();
   if (GetVerticalDistance(above_panel_bounds, target_bounds) <
           kGluePanelsDistanceThreshold &&
       GetHorizontalOverlap(above_panel_bounds, target_bounds) >
           kGluePanelsOverlapThreshold) {
     return false;
   }
 
-  // Move the panel (and all the panels below if in a stack) to the new
-  // position.
   gfx::Vector2d delta = target_position - dragging_panel_->GetBounds().origin();
-  if (dragging_stack)
-    dragging_stack->MoveAllDraggingPanelsInstantly(delta);
-  else
-    dragging_panel_->MoveByInstantly(delta);
 
   // If there're only 2 panels in the stack, both panels should move out the
   // stack and the stack should be removed.
   DetachedPanelCollection* detached_collection =
       panel_manager_->detached_collection();
   if (dragging_stack->num_panels() == 2) {
     MovePanelAndBelowToCollection(dragging_stack->top_panel(),
                                   detached_collection,
                                   PanelCollection::KNOWN_POSITION);
+    dragging_panel_->MoveByInstantly(delta);
     return true;
   }
 
   // There're at least 3 panels.
   DCHECK_GE(dragging_stack->num_panels(), 3);
 
   // If the dragging panel is bottom panel, move it out of the stack.
   if (dragging_panel_ == dragging_stack->bottom_panel()) {
     panel_manager_->MovePanelToCollection(dragging_panel_,
                                           detached_collection,
                                           PanelCollection::KNOWN_POSITION);
+    dragging_panel_->MoveByInstantly(delta);
     return true;
   }
 
   // If the dragging panel is the one below the top panel, move top panel
   // out of the stack.
   if (dragging_stack->GetPanelAbove(dragging_panel_) ==
       dragging_stack->top_panel()) {
     panel_manager_->MovePanelToCollection(dragging_stack->top_panel(),
                                           detached_collection,
                                           PanelCollection::KNOWN_POSITION);
+    dragging_panel_->stack()->MoveAllDraggingPanelsInstantly(delta);
     return true;
   }
 
   // There're at least 4 panels.
   DCHECK_GE(dragging_stack->num_panels(), 4);
 
   // We can split them into 2 stacks by moving the dragging panel and all panels
   // below to a new stack while keeping all panels above in the same stack.
   StackedPanelCollection* new_stack = panel_manager_->CreateStack();
   MovePanelAndBelowToCollection(dragging_panel_,
                                 new_stack,
                                 PanelCollection::KNOWN_POSITION);
+  dragging_panel_->stack()->MoveAllDraggingPanelsInstantly(delta);
 
   return true;
 }
 
 void PanelDragController::TrySnap(gfx::Point* target_position) {
   // Snapping does not apply to docked panels.
   if (dragging_panel_->collection()->type() == PanelCollection::DOCKED)
     return;
 
   // Check if the panel can snap to other panel.
@@ skipping 205 matching lines @@
           panel_manager_->detached_collection(),
           PanelCollection::KNOWN_POSITION);
     }
     // Note that if the stack is the original collection, do not remove it now.
     // This is because the original collection contains the information to
     // restore the dragging panel to the right place when the drag is cancelled.
     if (stack != dragging_panel_original_collection_)
       panel_manager_->RemoveStack(stack);
   }
 }