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

chrome/browser/ui/panels/docked_panel_strip.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/docked_panel_strip.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/panels/overflow_panel_strip.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 namespace {
 // Width to height ratio is used to compute the default width or height
 // when only one value is provided.
 const double kPanelDefaultWidthToHeightRatio = 1.62;  // golden ratio
@@ skipping 54 matching lines @@
   gfx::Rect old_area = display_area_;
   display_area_ = display_area;
 
   if (panels_.empty())
     return;
 
   RefreshLayout();
 }
 
 void DockedPanelStrip::AddPanel(Panel* panel) {
-  DCHECK_EQ(this, panel->panel_strip());
+  DCHECK_NE(this, panel->panel_strip());
+  panel->set_panel_strip(this);
 
-  // Always update limits, even for exiting panels, in case the maximums changed
+  // Always update limits, even on existing panels, in case the limits changed
   // while panel was out of the strip.
   int max_panel_width = GetMaxPanelWidth();
   int max_panel_height = GetMaxPanelHeight();
   panel->SetSizeRange(gfx::Size(kPanelMinWidth, kPanelMinHeight),
                       gfx::Size(max_panel_width, max_panel_height));
 
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
 
   if (panel->initialized()) {
-    // Bump panels in the strip to make room for this panel.
-    // Prevent layout refresh when panel is removed from this strip.
-    disable_layout_refresh_ = true;
-    PanelStrip* overflow_strip = panel_manager_->overflow_strip();
-    int x;
-    while ((x = GetRightMostAvailablePosition() - width) < display_area_.x()) {
-      DCHECK(!panels_.empty());
-      panels_.back()->MoveToStrip(overflow_strip);
-    }
-    disable_layout_refresh_ = false;
+    EnsureAvailableSpace(width);
+    int x = GetRightMostAvailablePosition() - width;
 
     Panel::ExpansionState expansion_state_to_restore;
     if (panel->expansion_state() == Panel::EXPANDED) {
       expansion_state_to_restore = Panel::EXPANDED;
     } else {
       if (are_titlebars_up_ || panel->IsDrawingAttention()) {
         expansion_state_to_restore = Panel::TITLE_ONLY;
         height = panel->TitleOnlyHeight();
       } else {
         expansion_state_to_restore = Panel::MINIMIZED;
         height = Panel::kMinimizedPanelHeight;
       }
       IncrementMinimizedPanels();
     }
-
     int y =
         GetBottomPositionForExpansionState(expansion_state_to_restore) - height;
     panel->SetPanelBounds(gfx::Rect(x, y, width, height));
 
     // Update the minimized state to reflect current titlebar mode.
     // Do this AFTER setting panel bounds to avoid an extra bounds change.
     if (panel->expansion_state() != Panel::EXPANDED)
       panel->SetExpansionState(expansion_state_to_restore);
 
   } else {
@@ skipping 58 matching lines @@
 
 int DockedPanelStrip::StartingRightPosition() const {
   return display_area_.right();
 }
 
 int DockedPanelStrip::GetRightMostAvailablePosition() const {
   return panels_.empty() ? StartingRightPosition() :
       (panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing);
 }
 
-bool DockedPanelStrip::RemovePanel(Panel* panel) {
+void DockedPanelStrip::RemovePanel(Panel* panel) {
+  DCHECK_EQ(this, panel->panel_strip());
+  panel->set_panel_strip(NULL);
+
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
-    return true;
+    return;
   }
 
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
-  if (iter == panels_.end())
-    return false;
+  DCHECK(iter != panels_.end());
 
   if (panel->expansion_state() != Panel::EXPANDED)
     DecrementMinimizedPanels();
 
   // Removing an element from the list will invalidate the iterator that refers
-  // to it. So we need to check if the dragging panel iterators are affected.
-  bool update_original_dragging_iterator_after_erase = false;
-  if (dragging_panel_original_iterator_ != panels_.end()) {
-    if (dragging_panel_current_iterator_ == iter) {
-      // If the dragging panel is being removed, set both dragging iterators to
-      // the end of the list.
-      dragging_panel_current_iterator_ = dragging_panel_original_iterator_ =
-          panels_.end();
-    } else if (dragging_panel_original_iterator_ == iter) {
-      // If |dragging_panel_original_iterator_| refers to the element being
-      // removed, set the flag so that the iterator can be updated to next
-      // element.
-      update_original_dragging_iterator_after_erase = true;
-    }
-  }
+  // to it. So we need to update the iterator in that case.
+  DCHECK(dragging_panel_current_iterator_ != iter);
+  bool update_iterator_after_erase =
+      (dragging_panel_original_iterator_ == iter);
 
   iter = panels_.erase(iter);
 
-  if (update_original_dragging_iterator_after_erase)
+  if (update_iterator_after_erase)
     dragging_panel_original_iterator_ = iter;
 
   if (!disable_layout_refresh_)
     RefreshLayout();
-
-  return true;
 }
 
 bool DockedPanelStrip::CanShowPanelAsActive(const Panel* panel) const {
   // Panels with temporary layout cannot be shown as active.
   return !panel->has_temporary_layout();
 }
 
 bool DockedPanelStrip::CanDragPanel(const Panel* panel) const {
   // Only the panels having temporary layout can't be dragged.
   return !panel->has_temporary_layout();
@@ skipping 181 matching lines @@
 
   panel->SetExpansionState(panel->IsDrawingAttention() ?
       Panel::TITLE_ONLY : Panel::MINIMIZED);
 }
 
 void DockedPanelStrip::RestorePanel(Panel* panel) {
   DCHECK_EQ(this, panel->panel_strip());
   panel->SetExpansionState(Panel::EXPANDED);
 }
 
+bool DockedPanelStrip::IsPanelMinimized(const Panel* panel) const {
+  return panel->expansion_state() != Panel::EXPANDED;
+}
+
 void DockedPanelStrip::IncrementMinimizedPanels() {
   minimized_panel_count_++;
   if (minimized_panel_count_ == 1)
     panel_manager_->mouse_watcher()->AddObserver(this);
   DCHECK_LE(minimized_panel_count_, num_panels());
 }
 
 void DockedPanelStrip::DecrementMinimizedPanels() {
   minimized_panel_count_--;
   DCHECK_GE(minimized_panel_count_, 0);
@@ skipping 216 matching lines @@
   delayed_titlebar_action_ = NO_ACTION;
 }
 
 void DockedPanelStrip::OnFullScreenModeChanged(bool is_full_screen) {
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     (*iter)->FullScreenModeChanged(is_full_screen);
   }
 }
 
+bool DockedPanelStrip::CanFitPanel(Panel* panel) {
+  int width = panel->GetRestoredBounds().width();
+  return GetRightMostAvailablePosition() - width >= display_area_.x();
+}
+
 void DockedPanelStrip::RefreshLayout() {
   int rightmost_position = StartingRightPosition();
 
   Panels::const_iterator panel_iter = panels_.begin();
   for (; panel_iter != panels_.end(); ++panel_iter) {
     Panel* panel = *panel_iter;
     gfx::Rect new_bounds(panel->GetBounds());
     int x = rightmost_position - new_bounds.width();
 
     if (x < display_area_.x())
       break;
 
     // Don't update the docked panel that is currently dragged.
     if (panel != dragging_panel()) {
       new_bounds.set_x(x);
       new_bounds.set_y(
           GetBottomPositionForExpansionState(panel->expansion_state()) -
               new_bounds.height());
       panel->SetPanelBounds(new_bounds);
     }
 
     rightmost_position = x - kPanelsHorizontalSpacing;
   }
 
   // Add/remove panels from/to overflow. A change in work area or the
   // resize/removal of a panel may affect how many panels fit in the strip.
-  OverflowPanelStrip* overflow_strip = panel_manager_->overflow_strip();
-  if (panel_iter != panels_.end()) {
-    // Prevent layout refresh when panel is removed from this strip.
-    disable_layout_refresh_ = true;
+  if (panel_iter != panels_.end())
+    MovePanelsToOverflow(*panel_iter);
+  else
+    panel_manager_->MovePanelsOutOfOverflowIfCanFit();

[jianli, 2012/03/02 00:11:41]

MovePanelsToOverflow and panel_manager_->MovePanelsOutOfOverflowIfCanFit seem
not to be consistent. It might be better to put both in either PanelManager or
DockedPanelStrip. Also, do we also need to disable  disable_layout_refresh_ for
the latter one?

[jennb, 2012/03/02 01:26:32]

Moved the former to PanelManager as well. Adding panels to the dock does not
cause a layout refresh but I'll disable layout refresh for it anyways so that
all operations that affect multiple panels at once consistently disable
refreshes.

+}
 
-    // Keep track of panels to move to overflow in a separate storage since
-    // removing it from the list will invalidate the iterator.
-    std::vector<Panel*> panels_to_move_to_overflow;
-    for (; panel_iter != panels_.end(); ++panel_iter)
-      panels_to_move_to_overflow.push_back(*panel_iter);
+void DockedPanelStrip::MovePanelsToOverflow(Panel* overflow_point) {
+  // Prevent layout refresh when panels are bumped from the strip as
+  // remaining panels in the strip are not affected.
+  // Move panels to overflow in reverse to maintain their order.
+  disable_layout_refresh_ = true;
+  Panel* bumped_panel;
+  while (!panels_.empty()) {
+    bumped_panel = panels_.back();
+    panel_manager_->ChangePanelLayout(panels_.back(), PanelStrip::IN_OVERFLOW);
+    if (bumped_panel == overflow_point)
+      break;
+  }
+  DCHECK(!panels_.empty());
+  disable_layout_refresh_ = false;
+}
 
-    // Move panels to overflow in reverse to maintain their order.
-    for (std::vector<Panel*>::reverse_iterator iter =
-             panels_to_move_to_overflow.rbegin();
-         iter != panels_to_move_to_overflow.rend(); ++iter) {
-      (*iter)->MoveToStrip(overflow_strip);
-    }
-
-    disable_layout_refresh_ = false;
-  } else {
-    // Attempt to add more panels from overflow to the strip.
-    Panel* overflow_panel;
-    while ((overflow_panel = overflow_strip->first_panel()) &&
-           GetRightMostAvailablePosition() >=
-               display_area_.x() + overflow_panel->restored_size().width()) {
-      overflow_panel->MoveToStrip(this);
-    }
+void DockedPanelStrip::EnsureAvailableSpace(int width) {

[jianli, 2012/03/02 00:11:41]

This seems to be quite similar to MovePanelsToOverflow. Anyway to merge these
two?

[jennb, 2012/03/02 01:26:32]

Not easily. In this one, the stopping point is not known in advance. I moved
this to panel manager as well, with the expectation that drag controller will go
through panel manager to add panels to the dock strip.

+  // Bump panels out of strip to create the requested space.
+  // Prevent layout refresh wile bumping panels from end of strip as
+  // remaining panels in the strip are not affected.
+  disable_layout_refresh_ = true;
+  while (GetRightMostAvailablePosition() - width < display_area_.x()) {
+    DCHECK(!panels_.empty());
+    panel_manager_->ChangePanelLayout(panels_.back(), PanelStrip::IN_OVERFLOW);
   }
+  disable_layout_refresh_ = false;
 }
 
 void DockedPanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
   if (panels_in_temporary_layout_.erase(panel)) {
       DCHECK(panel->has_temporary_layout());
-      panel->MoveToStrip(panel_manager_->overflow_strip());
+      panel_manager_->ChangePanelLayout(panel, PanelStrip::IN_OVERFLOW);
   }
 }
 
 void DockedPanelStrip::CloseAll() {
   // This should only be called at the end of tests to clean up.
   DCHECK(panels_in_temporary_layout_.empty());
 
   // Make a copy of the iterator as closing panels can modify the vector.
   Panels panels_copy = panels_;
 
   // Start from the bottom to avoid reshuffling.
   for (Panels::reverse_iterator iter = panels_copy.rbegin();
        iter != panels_copy.rend(); ++iter)
     (*iter)->Close();
 }