Cleanup to keep panel from manipulating its panel strip assignment directly.

chrome/browser/ui/panels/panel_manager.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_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/fullscreen.h"
@@ skipping 99 matching lines @@
 
   gfx::Rect overflow_area(adjusted_work_area_);
   overflow_area.set_width(kOverflowStripThickness);
   overflow_strip_->SetDisplayArea(overflow_area);
 }
 
 Panel* PanelManager::CreatePanel(Browser* browser) {
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
   Panel* panel = new Panel(browser, gfx::Size(width, height));
-  panel->MoveToStrip(docked_strip_.get());
+  docked_strip_->AddPanel(panel);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_ADDED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 
   if (num_panels() == 1) {
     full_screen_mode_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kFullScreenModeCheckIntervalMs),
         this, &PanelManager::CheckFullScreenMode);
   }
 
   return panel;
 }
 
 int PanelManager::StartingRightPosition() const {
   return docked_strip_->StartingRightPosition();
 }
 
 void PanelManager::CheckFullScreenMode() {
   bool is_full_screen_new = IsFullScreenMode();
   if (is_full_screen_ == is_full_screen_new)
     return;
   is_full_screen_ = is_full_screen_new;
   docked_strip_->OnFullScreenModeChanged(is_full_screen_);
   overflow_strip_->OnFullScreenModeChanged(is_full_screen_);
 }
 
 void PanelManager::OnPanelClosed(Panel* panel) {
-  if (num_panels() == 0)
+  if (num_panels() == 1)
     full_screen_mode_timer_.Stop();
 
   drag_controller_->OnPanelClosed(panel);
+  panel->panel_strip()->RemovePanel(panel);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_CLOSED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }
 
 void PanelManager::StartDragging(Panel* panel) {
   drag_controller_->StartDragging(panel);
 }
@@ skipping 21 matching lines @@
 
 void PanelManager::ResizePanel(Panel* panel, const gfx::Size& new_size) {
   // Explicit resizing is not allowed for auto-resizable panels for now.
   // http://crbug.com/109343
   if (panel->auto_resizable())
     return;
 
   docked_strip_->ResizePanelWindow(panel, new_size);
 }
 
+void PanelManager::MovePanelToStrip(Panel* panel,
+                                    PanelStrip::Type new_layout) {
+  DCHECK(panel);
+  PanelStrip* current_strip = panel->panel_strip();
+  DCHECK(current_strip);
+  DCHECK_NE(current_strip->type(), new_layout);
+  current_strip->RemovePanel(panel);
+
+  PanelStrip* target_strip = NULL;
+  switch (new_layout) {
+    case PanelStrip::DETACHED:
+      target_strip = detached_strip_.get();
+      break;
+    case PanelStrip::DOCKED:
+      EnsurePanelFitsInDock(panel);
+      target_strip = docked_strip_.get();
+      break;
+    case PanelStrip::IN_OVERFLOW:
+      target_strip = overflow_strip_.get();
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  target_strip->AddPanel(panel);
+
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_PANEL_CHANGED_LAYOUT_MODE,
+      content::Source<Panel>(panel),
+      content::NotificationService::NoDetails());
+}
+
+void PanelManager::EnsurePanelFitsInDock(Panel* panel) {

[jianli, 2012/03/02 02:26:09]

nit: EnsurePanelFitsInDockedStrip?

+  // Prevent layout refreshes while adjusting panels.
+  docked_strip_->enable_layout_refresh(false);
+  while (!docked_strip_->CanFitPanel(panel))
+    MovePanelToStrip(docked_strip_->last_panel(), PanelStrip::IN_OVERFLOW);

[jianli, 2012/03/02 02:26:09]

We know that we start from last docked panel and move it into overflow. When
DockedPanelStrip::RemovePanel is called, we still search the whole list to
remove it. Could we be smarter to deal with this more efficiently?

+  docked_strip_->enable_layout_refresh(true);  // Re-enable.
+}
+
+void PanelManager::MovePanelsToOverflow(Panel* last_panel_to_move) {
+  // Prevent layout refreshes while adjusting panels.
+  docked_strip_->enable_layout_refresh(false);
+
+  // Move panels to overflow in reverse to maintain their order.
+  Panel* bumped_panel;
+  while ((bumped_panel = docked_strip_->last_panel())) {
+    MovePanelToStrip(bumped_panel, PanelStrip::IN_OVERFLOW);

[jianli, 2012/03/02 02:26:09]

ditto.

+    if (bumped_panel == last_panel_to_move)
+      break;
+  }
+  DCHECK(!docked_strip_->panels().empty());
+
+  docked_strip_->enable_layout_refresh(true);  // Re-enable.
+}
+
+void PanelManager::MovePanelsOutOfOverflowIfCanFit() {
+  // Prevent layout refreshes while adjusting panels.
+  docked_strip_->enable_layout_refresh(false);
+
+  Panel* overflow_panel;
+  while ((overflow_panel = overflow_strip_->first_panel()) &&
+         docked_strip_->CanFitPanel(overflow_panel))
+    MovePanelToStrip(overflow_panel, PanelStrip::DOCKED);
+
+  docked_strip_->enable_layout_refresh(true);  // Re-enable.
+}
+
 bool PanelManager::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   return docked_strip_->ShouldBringUpTitlebars(mouse_x, mouse_y);
 }
 
 void PanelManager::BringUpOrDownTitlebars(bool bring_up) {
   docked_strip_->BringUpOrDownTitlebars(bring_up);
 }
 
 void PanelManager::AdjustWorkAreaForAutoHidingDesktopBars() {
   // Note that we do not care about the desktop bar aligned to the top edge
@@ skipping 68 matching lines @@
   return panels;
 }
 
 int PanelManager::overflow_strip_width() const {
   return kOverflowStripThickness;
 }
 
 void PanelManager::SetMouseWatcher(PanelMouseWatcher* watcher) {
   panel_mouse_watcher_.reset(watcher);
 }