Fix handling of minimized panel count

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"
@@ skipping 162 matching lines @@
   DCHECK(panel->initialized());
 
   FitPanelWithWidth(panel->GetBounds().width());
 
   int x = panel->GetBounds().x();
   Panels::iterator iter = panels_.begin();
   for (; iter != panels_.end(); ++iter)
     if (x > (*iter)->GetBounds().x())
       break;
   panels_.insert(iter, panel);
+  UpdateMinimizedPanelCount();
 
   // This will automatically update all affected panels due to the insertion.
   if (iter != panels_.end())
     RefreshLayout();
 }
 
 void DockedPanelStrip::InsertExistingPanelAtDefaultPosition(
     Panel* panel, bool update_bounds) {
   DCHECK(panel->initialized());
 
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
 
   int x = FitPanelWithWidth(width);
-
   if (update_bounds) {
     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);
   }
 
   panels_.push_back(panel);
+  UpdateMinimizedPanelCount();
 }
 
 int DockedPanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
 int DockedPanelStrip::GetMaxPanelHeight() const {
   return display_area_.height();
 }
 
 int DockedPanelStrip::StartingRightPosition() const {
   return display_area_.right();
 }
 
 int DockedPanelStrip::GetRightMostAvailablePosition() const {
   return panels_.empty() ? StartingRightPosition() :
       (panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing);
 }
 
 void DockedPanelStrip::RemovePanel(Panel* panel) {
   DCHECK_EQ(this, panel->panel_strip());
   panel->SetPanelStrip(NULL);
 
-  if (panel->expansion_state() != Panel::EXPANDED)
-    DecrementMinimizedPanels();
-
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
     return;
   }
 
   // Removing an element from the list will invalidate the iterator that refers
   // to it. We need to update the iterator in that case.
   DCHECK(dragging_panel_current_iterator_ == panels_.end() ||
          *dragging_panel_current_iterator_ != panel);
 
@@ skipping 20 matching lines @@
     iter = panels_.erase(iter);
 
   // Update the saved panel placement if needed. This is because we might remove
   // |saved_panel_placement_.left_panel|.
   if (saved_panel_placement_.panel &&
       saved_panel_placement_.left_panel == panel)
     saved_panel_placement_.left_panel = *iter;
 
     RefreshLayout();
   }
+
+  if (panel->expansion_state() != Panel::EXPANDED)
+    UpdateMinimizedPanelCount();
 }
 
 bool DockedPanelStrip::CanShowPanelAsActive(const Panel* panel) const {
   // Panels with temporary layout cannot be shown as active.
   return !panel->has_temporary_layout();
 }
 
 void DockedPanelStrip::SavePanelPlacement(Panel* panel) {
   DCHECK(!saved_panel_placement_.panel);
 
@@ skipping 140 matching lines @@
   // aborted because either the drag enters other strip or the drag is
   // cancelled. Either way, we don't need to do anything here and let the drag
   // controller handle the inter-strip transition or the drag cancellation.
   if (!aborted)
     RefreshLayout();
 }
 
 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();
   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)
-        IncrementMinimizedPanels();
+
       break;
     case Panel::MINIMIZED:
       size.set_height(Panel::kMinimizedPanelHeight);
-      if (old_state == Panel::EXPANDED)
-        IncrementMinimizedPanels();
+
       break;
     default:
       NOTREACHED();
       break;
   }
+  UpdateMinimizedPanelCount();
 
   int bottom = GetBottomPositionForExpansionState(expansion_state);
   gfx::Rect bounds = panel->GetBounds();
   panel->SetPanelBounds(
       gfx::Rect(bounds.right() - size.width(),
                 bottom - size.height(),
                 size.width(),
                 size.height()));
 }
 
@@ skipping 30 matching lines @@
 
 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)
+void DockedPanelStrip::UpdateMinimizedPanelCount() {
+  int prev_minimized_panel_count = minimized_panel_count_;
+  minimized_panel_count_ = 0;
+  for (Panels::const_iterator panel_iter = panels_.begin();
+        panel_iter != panels_.end(); ++panel_iter) {
+    if ((*panel_iter)->expansion_state() != Panel::EXPANDED)
+      minimized_panel_count_++;
+    }
+
+  if (prev_minimized_panel_count == 0 && minimized_panel_count_ > 0)
     panel_manager_->mouse_watcher()->AddObserver(this);
+  else if (prev_minimized_panel_count > 0 &&  minimized_panel_count_ == 0)
+    panel_manager_->mouse_watcher()->RemoveObserver(this);
+
   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::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();
@@ skipping 294 matching lines @@
   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();
 }