Move IN_OVERFLOW from Panel::ExpansionState to new enum.

chrome/browser/ui/panels/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/panel_strip.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 63 matching lines @@
   gfx::Rect old_area = display_area_;
   display_area_ = new_area;
 
   if (panels_.empty())
     return;
 
   Rearrange();
 }
 
 void PanelStrip::AddPanel(Panel* panel) {
-  DCHECK_NE(Panel::IN_OVERFLOW, panel->expansion_state());
+  DCHECK_NE(Panel::IN_OVERFLOW, panel->layout_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),
                       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.
     int x;
     while ((x = GetRightMostAvailablePosition() - width) < display_area_.x()) {
       DCHECK(!panels_.empty());
-      panels_.back()->SetExpansionState(Panel::IN_OVERFLOW);
+      panels_.back()->SetLayoutState(Panel::IN_OVERFLOW);
     }
     int y = display_area_.bottom() - height;
     panel->SetPanelBounds(gfx::Rect(x, y, width, height));
+
+    if (panel->expansion_state() != Panel::EXPANDED)
+      IncrementMinimizedPanels();
   } else {
     // Initialize the newly created panel. Does not bump any panels from strip.
     if (height == 0 && width == 0) {
       // Auto resizable is enabled only if no initial size is provided.
       panel->SetAutoResizable(true);
     } else {
       if (height == 0)
         height = width / kPanelDefaultWidthToHeightRatio;
       if (width == 0)
         width = height * kPanelDefaultWidthToHeightRatio;
@@ skipping 70 matching lines @@
   // 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)
+  if (panel->layout_state() == Panel::DOCKED)
     Rearrange();
 
   return true;
 }
 
 void PanelStrip::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();
 }
 
 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::TITLE_ONLY ||
-      panel->expansion_state() == Panel::MINIMIZED)
+  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) {
@@ skipping 118 matching lines @@
   } else {
     panels_[dragging_panel_index_]->SetPanelBounds(
         dragging_panel_bounds_);
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
-void PanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
+void PanelStrip::OnPanelLayoutStateChanged(Panel* panel,
+                                           Panel::LayoutState old_state) {
+  Panel::LayoutState layout_state = panel->layout_state();
+  switch (layout_state) {
+    case Panel::DOCKED:
+      if (old_state == Panel::IN_OVERFLOW) {
+        panel_manager_->panel_overflow_strip()->Remove(panel);
+        AddPanel(panel);
+        panel->SetAppIconVisibility(true);
+        panel->set_draggable(true);
+        UpdateBoundsPerExpansionState(panel);
+      }
+      break;
+    case Panel::DETACHED:
+    case Panel::IN_OVERFLOW:
+      DCHECK_EQ(Panel::DOCKED, old_state);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void PanelStrip::OnPanelExpansionStateChanged(Panel* panel,
+                                              Panel::ExpansionState old_state) {
+  DCHECK_EQ(Panel::DOCKED, panel->layout_state());
+
+  switch (panel->expansion_state()) {
+    case Panel::EXPANDED:
+      DecrementMinimizedPanels();
+      break;
+    case Panel::TITLE_ONLY:
+    case Panel::MINIMIZED:
+      if (old_state == Panel::EXPANDED)
+        IncrementMinimizedPanels();
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+
+  UpdateBoundsPerExpansionState(panel);
+}
+
+void PanelStrip::UpdateBoundsPerExpansionState(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_->panel_overflow_strip()->Remove(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:
       size.set_height(panel->TitleOnlyHeight());
-      if (old_state == Panel::EXPANDED || old_state == Panel::IN_OVERFLOW)
-        IncrementMinimizedPanels();
       break;
     case Panel::MINIMIZED:
       size.set_height(Panel::kMinimizedPanelHeight);
-      if (old_state == Panel::EXPANDED || old_state == Panel::IN_OVERFLOW)
-        IncrementMinimizedPanels();
-      break;
-    case Panel::IN_OVERFLOW:
-      if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
-        DecrementMinimizedPanels();
       break;
     default:
       NOTREACHED();
       break;
   }
 
   int bottom = GetBottomPositionForExpansionState(expansion_state);
   gfx::Rect bounds = panel->GetBounds();
   panel->SetPanelBounds(
       gfx::Rect(bounds.right() - size.width(),
@@ skipping 32 matching lines @@
   if (new_height > panel->max_size().height())
     new_height = panel->max_size().height();
   if (new_height < panel->min_size().height())
     new_height = panel->min_size().height();
 
   // Update restored size.
   gfx::Size new_size(new_width, new_height);
   if (new_size != panel->restored_size())
     panel->set_restored_size(new_size);
 
-  // Only need to adjust bounds height when panel is expanded.
+  Panel::LayoutState layout_state = panel->layout_state();
   gfx::Rect bounds = panel->GetBounds();
-  Panel::ExpansionState expansion_state = panel->expansion_state();
-  if (new_height != bounds.height() &&
-      expansion_state == Panel::EXPANDED) {
-    bounds.set_y(bounds.bottom() - new_height);
-    bounds.set_height(new_height);
+  int delta_x = bounds.width() - new_width;
+
+  // Only need to update bounds when the panel is docked or detached.
+  if (layout_state != Panel::IN_OVERFLOW) {
+    // Height is only affected when panel is expanded.
+    if (new_height != bounds.height() &&
+        panel->expansion_state() == Panel::EXPANDED) {
+      bounds.set_y(bounds.bottom() - new_height);
+      bounds.set_height(new_height);
+    }
+
+    if (delta_x != 0) {
+      bounds.set_width(new_width);
+      bounds.set_x(bounds.x() + delta_x);
+    }
+
+    if (bounds != panel->GetBounds())
+      panel->SetPanelBounds(bounds);
   }
 
-  // Only need to adjust width if panel is in the panel strip.
-  int delta_x = bounds.width() - new_width;
-  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)
+  // If the panel is docked, rearrange if panel's width is changed.
+  // If the panel is in overflow, rearrange if panel's width is smaller because
+  // we might have sufficient space in the docking area to fit the shrunken
+  // overflow panel.
+  if ((layout_state == Panel::DOCKED && delta_x != 0) ||
+      (layout_state == Panel::IN_OVERFLOW && delta_x < 0))
     Rearrange();
 }
 
 bool PanelStrip::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 &&
@@ skipping 185 matching lines @@
 
   // TODO(jianli): remove the guard when overflow support is enabled on other
   // platforms. http://crbug.com/105073
 #if defined(OS_WIN)
   // 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.
   if (panel_index < panels_.size()) {
     // Move panels to overflow in reverse to maintain their order.
     for (size_t overflow_index = panels_.size() - 1;
          overflow_index >= panel_index; --overflow_index)
-      panels_[overflow_index]->SetExpansionState(Panel::IN_OVERFLOW);
+      panels_[overflow_index]->SetLayoutState(Panel::IN_OVERFLOW);
   } else {
     // Attempt to add more panels from overflow to the strip.
     PanelOverflowStrip* overflow_strip = panel_manager_->panel_overflow_strip();
     Panel* overflow_panel;
     while ((overflow_panel = overflow_strip->first_panel()) &&
            GetRightMostAvailablePosition() >=
                display_area_.x() + overflow_panel->restored_size().width()) {
       // We need to get back to the previous expansion state.
       Panel::ExpansionState expansion_state_to_restore =
-          overflow_panel->old_expansion_state();
-      if (expansion_state_to_restore == Panel::MINIMIZED ||
-          expansion_state_to_restore == Panel::TITLE_ONLY) {
+          overflow_panel->expansion_state();
+      if (expansion_state_to_restore != Panel::EXPANDED) {
         expansion_state_to_restore = are_titlebars_up_ ? Panel::TITLE_ONLY
                                                        : Panel::MINIMIZED;
       }
+      overflow_panel->SetLayoutState(Panel::DOCKED);
       overflow_panel->SetExpansionState(expansion_state_to_restore);
     }
   }
 #endif
 }
 
 void PanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
   if (panels_in_temporary_layout_.erase(panel)) {
-      DCHECK(panel->has_temporary_layout());
-      panel->SetExpansionState(Panel::IN_OVERFLOW);
+    DCHECK(panel->has_temporary_layout());
+    panel->SetLayoutState(Panel::IN_OVERFLOW);
   }
 }
 
 void PanelStrip::RemoveAll() {
   // 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 PanelStrip::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }