Created new PanelStrip base class and make DockedPanelStrip and OverflowPanelStrip its subclasses.

chrome/browser/ui/panels/overflow_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/overflow_panel_strip.h"
 
 #include "base/logging.h"
 #include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
@@ skipping 14 matching lines @@
 // The ratio to determine the maximum number of visible overflow panels when the
 // mouse hovers over the overflow area. These panels cannot occupy more than the
 // fixed percentage of the display area height.
 const double kHeightRatioForMaxVisibleOverflowPanelsOnHover = 0.67;
 
 // This value is experimental and subjective.
 const int kOverflowHoverAnimationMs = 180;
 }
 
 OverflowPanelStrip::OverflowPanelStrip(PanelManager* panel_manager)
-    : panel_manager_(panel_manager),
+    : PanelStrip(PanelStrip::IN_OVERFLOW),
+      panel_manager_(panel_manager),
       current_display_width_(0),
       max_visible_panels_(kMaxVisibleOverflowPanels),
       max_visible_panels_on_hover_(0),
       are_overflow_titles_shown_(false),
       overflow_hover_animator_start_width_(0),
       overflow_hover_animator_end_width_(0) {
 }
 
 OverflowPanelStrip::~OverflowPanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(!overflow_indicator_.get());
 }
 
 void OverflowPanelStrip::SetDisplayArea(const gfx::Rect& display_area) {
   if (display_area_ == display_area)
     return;
   display_area_ = display_area;
 
   UpdateCurrentWidth();
 
   max_visible_panels_on_hover_ = 0;  // reset this value for recomputation.
   UpdateMaxVisiblePanelsOnHover();
 
   if (overflow_indicator_.get())
     UpdateOverflowIndicatorCount();
 
-  Refresh();
+  RefreshLayout();
 }
 
 void OverflowPanelStrip::UpdateMaxVisiblePanelsOnHover() {
   // No need to recompute this value.
   if (max_visible_panels_on_hover_ || panels_.empty())
     return;
 
   max_visible_panels_on_hover_ =
       kHeightRatioForMaxVisibleOverflowPanelsOnHover *
       display_area_.height() /
@@ skipping 12 matching lines @@
   // Newly created panels that were temporarily in the panel strip
   // are added to the back of the overflow, whereas panels that are
   // bumped from the panel strip by other panels go to the front
   // of overflow.
   if (panel->has_temporary_layout()) {
     panel->set_has_temporary_layout(false);
     panels_.push_back(panel);
     DoRefresh(panels_.size() - 1, panels_.size() - 1);
   } else {
     panels_.insert(panels_.begin(), panel);
-    Refresh();
+    RefreshLayout();
   }
 
   if (num_panels() == 1) {
     panel_manager_->mouse_watcher()->AddObserver(this);
     UpdateMaxVisiblePanelsOnHover();
   }
 
   // Update the overflow indicator only when the number of overflow panels go
   // beyond the maximum visible limit.
   if (num_panels() > max_visible_panels_) {
     if (!overflow_indicator_.get()) {
       overflow_indicator_.reset(PanelOverflowIndicator::Create());
     }
     UpdateOverflowIndicatorCount();
   }
 }
 
-bool OverflowPanelStrip::Remove(Panel* panel) {
+bool OverflowPanelStrip::RemovePanel(Panel* panel) {
   size_t index = 0;
   Panels::iterator iter = panels_.begin();
   for (; iter != panels_.end(); ++iter, ++index)
     if (*iter == panel)
       break;
   if (iter == panels_.end())
     return false;
 
   panels_.erase(iter);
   DoRefresh(index, panels_.size() - 1);
   panel_manager_->OnPanelRemoved(panel);
 
   if (panels_.empty())
     panel_manager_->mouse_watcher()->RemoveObserver(this);
 
   // Update the overflow indicator. If the number of overflow panels fall below
   // the maximum visible limit, we do not need the overflow indicator any more.
   if (num_panels() < max_visible_panels_)
     overflow_indicator_.reset();
   else
     UpdateOverflowIndicatorCount();
 
   return true;
 }
 
-void OverflowPanelStrip::RemoveAll() {
+void OverflowPanelStrip::CloseAll() {
   // 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();
 }
 
+void OverflowPanelStrip::ResizePanelWindow(
+    Panel* panel, const gfx::Size& preferred_window_size) {
+  // Overflow uses its own panel window sizes.
+}
+
 void OverflowPanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
   // Only care about new state being overflow.
   if (panel->expansion_state() != Panel::IN_OVERFLOW)
     return;
 
-  panel_manager_->docked_strip()->Remove(panel);
+  panel_manager_->docked_strip()->RemovePanel(panel);
   AddPanel(panel);
   panel->SetAppIconVisibility(false);
   panel->set_draggable(false);
 }
 
 void OverflowPanelStrip::OnPanelAttentionStateChanged(Panel* panel) {
   DCHECK(panel->expansion_state() == Panel::IN_OVERFLOW);
   UpdateOverflowIndicatorAttention();
 }
 
-void OverflowPanelStrip::Refresh() {
+void OverflowPanelStrip::RefreshLayout() {
   if (panels_.empty())
     return;
   DoRefresh(0, panels_.size() - 1);
 }
 
 void OverflowPanelStrip::DoRefresh(size_t start_index, size_t end_index) {
   if (panels_.empty() || start_index == panels_.size())
     return;
 
   DCHECK(end_index < panels_.size());
@@ skipping 168 matching lines @@
     bounds.set_width(current_display_width);
     overflow_indicator_->SetBounds(bounds);
     overflow_indicator_->SetCount(num_panels() - max_visible_panels);
   }
 }
 
 void OverflowPanelStrip::OnFullScreenModeChanged(bool is_full_screen) {
   for (size_t i = 0; i < panels_.size(); ++i)
     panels_[i]->FullScreenModeChanged(is_full_screen);
 }