Add PanelOverflowStrip to handle panel overflow.

chrome/browser/ui/panels/panel_strip.cc

 // Copyright (c) 2011 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_strip.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
+#include "chrome/browser/ui/panels/panel_overflow_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 namespace {
 // Invalid panel index.
 const size_t kInvalidPanelIndex = static_cast<size_t>(-1);
 
 // Width to height ratio is used to compute the default width or height
 // when only one value is provided.
@@ skipping 107 matching lines @@
   // Keep panel visible in the strip even if overlap would occur.
   // Panel is moved to overflow from the strip after a delay.
   if (x < display_area_.x()) {
     x = display_area_.x();
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PanelStrip::MovePanelToOverflow,
                    overflow_action_factory_.GetWeakPtr(),
                    panel,
                    true),  // new panel
-        kMoveNewPanelToOverflowDelayMilliseconds);
+        remove_delays_for_testing_ ?
+            0 : kMoveNewPanelToOverflowDelayMilliseconds);
   }
   panel->Initialize(gfx::Rect(x, y, width, height));
 }
 
 void PanelStrip::AddExistingPanel(Panel* panel) {
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
   int x;
   while ((x = GetRightMostAvailablePosition() - width) < display_area_.x()) {
@@ skipping 45 matching lines @@
 
 bool PanelStrip::DoRemove(Panel* panel) {
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
     return false;
 
   if (panel->expansion_state() != Panel::EXPANDED)
     DecrementMinimizedPanels();
 
   panels_.erase(iter);
+  panel_manager_->OnPanelRemoved(panel);
   return true;
 }
 
 void PanelStrip::StartDragging(Panel* panel) {
   for (size_t i = 0; i < panels_.size(); ++i) {
     if (panels_[i] == panel) {
       dragging_panel_index_ = i;
       dragging_panel_bounds_ = panel->GetBounds();
       dragging_panel_original_x_ = dragging_panel_bounds_.x();
       break;
@@ skipping 115 matching lines @@
     panels_[dragging_panel_index_]->SetPanelBounds(
         dragging_panel_bounds_);
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
 void PanelStrip::OnPanelExpansionStateChanged(
-    Panel::ExpansionState old_state, Panel::ExpansionState new_state) {
-  DCHECK_NE(new_state, old_state);
-  switch (new_state) {
+    Panel* panel, Panel::ExpansionState old_state) {
+  DCHECK(panel->expansion_state() != Panel::IN_OVERFLOW);
+
+  gfx::Size size = panel->restored_size();
+  switch (panel->expansion_state()) {
     case Panel::EXPANDED:
-      DecrementMinimizedPanels();
+      if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
+        DecrementMinimizedPanels();
+      break;
+    case Panel::TITLE_ONLY:
+      size.set_height(panel->TitleOnlyHeight());
+      if (old_state == Panel::EXPANDED)
+        IncrementMinimizedPanels();
       break;
     case Panel::MINIMIZED:
-    case Panel::TITLE_ONLY:
+      size.set_height(Panel::kMinimizedPanelHeight);
       if (old_state == Panel::EXPANDED)
         IncrementMinimizedPanels();
       break;
     default:
+      NOTREACHED();
       break;
   }
+
+  int bottom = GetBottomPositionForExpansionState(panel->expansion_state());
+  gfx::Rect bounds = panel->GetBounds();
+  panel->SetPanelBounds(
+      gfx::Rect(bounds.right() - size.width(),
+                bottom - size.height(),
+                size.width(),
+                size.height()));
 }
 
 void PanelStrip::IncrementMinimizedPanels() {
   minimized_panel_count_++;
   if (minimized_panel_count_ == 1)
     panel_manager_->mouse_watcher()->AddObserver(this);
   DCHECK_LE(minimized_panel_count_, num_panels());
 }
 
 void PanelStrip::DecrementMinimizedPanels() {
@@ skipping 229 matching lines @@
   DCHECK(overflow_point >= 0);
   // Move panels in reverse to maintain their order.
   for (size_t i = panels_.size() - 1; i >= overflow_point; --i)
     MovePanelToOverflow(panels_[i], false);
 }
 
 void PanelStrip::MovePanelToOverflow(Panel* panel, bool is_new) {
   if (!DoRemove(panel))
     return;
 
-  // TODO(jianli): Replace with the real code using overflow strip.
-  // panel_manager_->panel_overflow_strip()->AddPanel(panel, is_new);
+  panel_manager_->panel_overflow_strip()->AddPanel(panel, is_new);
 }
 
 void PanelStrip::MovePanelsFromOverflowIfNeeded() {
-  // TODO(jianli): Replace with the real code using overflow strip.
-  // PanelOverflowStrip* overflow = panel_manager_->panel_overflow_strip();
-  // Panel* candidate;
-  // while (candidate = overflow->FirstPanel() &&
-  //     GetRightMostAvailablePosition -
-  //         candidate->GetRestoredSize().width() >= display_area_.x()) {
-  //   overflow->Remove(candidate);
-  //   AddPanel(candidate);
-  // }
+  PanelOverflowStrip* overflow_strip = panel_manager_->panel_overflow_strip();
+  Panel* overflow_panel;
+  while ((overflow_panel = overflow_strip->first_panel()) &&
+          GetRightMostAvailablePosition() -
+              overflow_panel->restored_size().width() >= display_area_.x()) {
+    overflow_strip->Remove(overflow_panel);
+    AddPanel(overflow_panel);
+  }
 }
 
 void PanelStrip::RemoveAll() {
   // This should not be called when we're in the process of dragging.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
 
   // 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();
 }
 
 bool PanelStrip::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }