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

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 "base/bind.h"
 #include "base/logging.h"
@@ skipping 39 matching lines @@
 #else
 const int kDelayBeforeCollapsingFromTitleOnlyStateMs = 0;
 #endif
 }  // namespace
 
 // static
 const int DockedPanelStrip::kPanelMinWidth = 100;
 const int DockedPanelStrip::kPanelMinHeight = 20;
 
 DockedPanelStrip::DockedPanelStrip(PanelManager* panel_manager)
-    : panel_manager_(panel_manager),
+    : PanelStrip(PanelStrip::DOCKED),
+      panel_manager_(panel_manager),
       minimized_panel_count_(0),
       are_titlebars_up_(false),
       dragging_panel_index_(kInvalidPanelIndex),
       dragging_panel_original_x_(0),
       delayed_titlebar_action_(NO_ACTION),
       titlebar_action_factory_(this) {
 }
 
 DockedPanelStrip::~DockedPanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
   DCHECK(panels_in_temporary_layout_.empty());
   DCHECK_EQ(0, minimized_panel_count_);
 }
 
-void DockedPanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
-  if (display_area_ == new_area)
+void DockedPanelStrip::SetDisplayArea(const gfx::Rect& display_area) {
+  if (display_area_ == display_area)
     return;
 
   gfx::Rect old_area = display_area_;
-  display_area_ = new_area;
+  display_area_ = display_area;
 
   if (panels_.empty())
     return;
 
-  Rearrange();
+  RefreshLayout();
 }
 
 void DockedPanelStrip::AddPanel(Panel* panel) {
   DCHECK_NE(Panel::IN_OVERFLOW, panel->expansion_state());
 
   // Always update limits, even for exiting panels, in case the maximums changed
   // while panel was out of the strip.
   int max_panel_width = GetMaxPanelWidth();
   int max_panel_height = GetMaxPanelHeight();
   panel->SetSizeRange(gfx::Size(kPanelMinWidth, kPanelMinHeight),
@@ skipping 76 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::Remove(Panel* panel) {
+bool DockedPanelStrip::RemovePanel(Panel* panel) {
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
     return true;
   }
 
   if (find(panels_.begin(), panels_.end(), panel) == panels_.end())
     return false;
 
   // If we're in the process of dragging, delay the removal.
   if (dragging_panel_index_ != kInvalidPanelIndex) {
     panels_pending_to_remove_.push_back(panel);
     return true;
   }
 
   DoRemove(panel);
 
   // Don't rearrange the strip if a panel is being moved from the panel strip
   // to the overflow strip.
   if (panel->expansion_state() != Panel::IN_OVERFLOW)
-    Rearrange();
+    RefreshLayout();
 
   return true;
 }
 
 void DockedPanelStrip::DelayedRemove() {
   for (size_t i = 0; i < panels_pending_to_remove_.size(); ++i)
     DoRemove(panels_pending_to_remove_[i]);
   panels_pending_to_remove_.clear();
-  Rearrange();
+  RefreshLayout();
 }
 
 bool DockedPanelStrip::DoRemove(Panel* panel) {
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
     return false;
 
   if (panel->expansion_state() == Panel::TITLE_ONLY ||
       panel->expansion_state() == Panel::MINIMIZED)
     DecrementMinimizedPanels();
 
   panels_.erase(iter);
   panel_manager_->OnPanelRemoved(panel);
   return true;
 }
 
 void DockedPanelStrip::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;
     }
   }
 }
 
-void DockedPanelStrip::Drag(int delta_x) {
+void DockedPanelStrip::Drag(int delta_x, int delta_y) {
   DCHECK(dragging_panel_index_ != kInvalidPanelIndex);
 
   if (!delta_x)
     return;
 
   // Moves this panel to the dragging position.
   Panel* dragging_panel = panels_[dragging_panel_index_];
   gfx::Rect new_bounds(dragging_panel->GetBounds());
   new_bounds.set_x(new_bounds.x() + delta_x);
   dragging_panel->SetPanelBounds(new_bounds);
@@ skipping 88 matching lines @@
     dragging_panel_index_ = current_panel_index + 1;
     panels_[dragging_panel_index_] = dragging_panel;
   }
 }
 
 void DockedPanelStrip::EndDragging(bool cancelled) {
   DCHECK(dragging_panel_index_ != kInvalidPanelIndex);
 
   if (cancelled) {
     Drag(dragging_panel_original_x_ -
-         panels_[dragging_panel_index_]->GetBounds().x());
+         panels_[dragging_panel_index_]->GetBounds().x(),
+         0);  // TODO(jennb): pass delta_y
   } else {
     panels_[dragging_panel_index_]->SetPanelBounds(
         dragging_panel_bounds_);
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
 void DockedPanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
   gfx::Size size = panel->restored_size();
   Panel::ExpansionState expansion_state = panel->expansion_state();
   Panel::ExpansionState old_state = panel->old_expansion_state();
   if (old_state == Panel::IN_OVERFLOW) {
-    panel_manager_->overflow_strip()->Remove(panel);
+    panel_manager_->overflow_strip()->RemovePanel(panel);
     AddPanel(panel);
     panel->SetAppIconVisibility(true);
     panel->set_draggable(true);
   }
   switch (expansion_state) {
     case Panel::EXPANDED:
       if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
         DecrementMinimizedPanels();
       break;
     case Panel::TITLE_ONLY:
@@ skipping 43 matching lines @@
   DCHECK_LE(minimized_panel_count_, num_panels());
 }
 
 void DockedPanelStrip::DecrementMinimizedPanels() {
   minimized_panel_count_--;
   DCHECK_GE(minimized_panel_count_, 0);
   if (minimized_panel_count_ == 0)
     panel_manager_->mouse_watcher()->RemoveObserver(this);
 }
 
-void DockedPanelStrip::OnWindowSizeChanged(
+void DockedPanelStrip::ResizePanelWindow(
     Panel* panel, const gfx::Size& preferred_window_size) {
   // The panel width:
   // * cannot grow or shrink to go beyond [min_width, max_width]
   int new_width = preferred_window_size.width();
   if (new_width > panel->max_size().width())
     new_width = panel->max_size().width();
   if (new_width < panel->min_size().width())
     new_width = panel->min_size().width();
 
   // The panel height:
@@ skipping 23 matching lines @@
   if (delta_x != 0 && expansion_state != Panel::IN_OVERFLOW) {
     bounds.set_width(new_width);
     bounds.set_x(bounds.x() + delta_x);
   }
 
   if (bounds != panel->GetBounds())
     panel->SetPanelBounds(bounds);
 
   // Only need to rearrange if panel's width changed.
   if (delta_x != 0)
-    Rearrange();
+    RefreshLayout();
 }
 
 bool DockedPanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   // We should always bring up the titlebar if the mouse is over the
   // visible auto-hiding bottom bar.
   AutoHidingDesktopBar* desktop_bar = panel_manager_->auto_hiding_desktop_bar();
   if (desktop_bar->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM) &&
       desktop_bar->GetVisibility(AutoHidingDesktopBar::ALIGN_BOTTOM) ==
           AutoHidingDesktopBar::VISIBLE &&
       mouse_y >= display_area_.bottom())
@@ skipping 151 matching lines @@
 
   DoBringUpOrDownTitlebars(delayed_titlebar_action_ == BRING_UP);
   delayed_titlebar_action_ = NO_ACTION;
 }
 
 void DockedPanelStrip::OnFullScreenModeChanged(bool is_full_screen) {
   for (size_t i = 0; i < panels_.size(); ++i)
     panels_[i]->FullScreenModeChanged(is_full_screen);
 }
 
-void DockedPanelStrip::Rearrange() {
+void DockedPanelStrip::RefreshLayout() {
   int rightmost_position = StartingRightPosition();
 
   size_t panel_index = 0;
   for (; panel_index < panels_.size(); ++panel_index) {
     Panel* panel = panels_[panel_index];
     gfx::Rect new_bounds(panel->GetBounds());
     int x = rightmost_position - new_bounds.width();
 
   // TODO(jianli): remove the guard when overflow support is enabled on other
   // platforms. http://crbug.com/105073
@@ skipping 42 matching lines @@
 #endif
 }
 
 void DockedPanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
   if (panels_in_temporary_layout_.erase(panel)) {
       DCHECK(panel->has_temporary_layout());
       panel->SetExpansionState(Panel::IN_OVERFLOW);
   }
 }
 
-void DockedPanelStrip::RemoveAll() {
+void DockedPanelStrip::CloseAll() {
   // This should only be called at the end of tests to clean up.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
   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();
 }
 
 bool DockedPanelStrip::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }