Panel strip refactor cleanup.

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"
@@ skipping 39 matching lines @@
 const int PanelStrip::kPanelMinWidth = 100;
 const int PanelStrip::kPanelMinHeight = 20;
 
 PanelStrip::PanelStrip(PanelManager* panel_manager)
     : 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),
-      remove_delays_for_testing_(false),
       titlebar_action_factory_(this) {
 }
 
 PanelStrip::~PanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
   DCHECK_EQ(0, minimized_panel_count_);
 }
 
 void PanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
   if (display_area_ == new_area)
     return;
 
   gfx::Rect old_area = display_area_;
   display_area_ = new_area;
 
   if (panels_.empty())
     return;
 
   Rearrange();
 }
 
 void PanelStrip::AddPanel(Panel* panel) {
+  DCHECK_EQ(Panel::EXPANDED, 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),
                       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());
-      MovePanelToOverflow(panels_.back(), false);
+      panels_.back()->SetExpansionState(Panel::IN_OVERFLOW);
     }
     int y = display_area_.bottom() - height;
     panel->SetPanelBounds(gfx::Rect(x, y, width, height));
-    panel->SetExpansionState(Panel::EXPANDED);
   } 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 14 matching lines @@
     int x = GetRightMostAvailablePosition() - width;
     int y = display_area_.bottom() - height;
 
     // Keep panel visible in the strip even if overlap would occur.
     // Panel is moved to overflow from the strip after a delay.
     // TODO(jianli): remove the guard when overflow support is enabled on other
     // platforms. http://crbug.com/105073
 #if defined(OS_WIN)
     if (x < display_area_.x()) {
       x = display_area_.x();
-      int delay_ms = remove_delays_for_testing_ ? 0 :
-          kMoveNewPanelToOverflowDelayMilliseconds;
+      panel->set_temporary_layout(true);
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
-          base::Bind(&PanelStrip::MovePanelToOverflow,
+          base::Bind(&PanelStrip::MovePanelToOverflowAfterDelay,
                      base::Unretained(this),
-                     panel,
-                     true),  // new panel
-          delay_ms);
+                     panel),
+          kMoveNewPanelToOverflowDelayMilliseconds);
     }
 #endif
     panel->Initialize(gfx::Rect(x, y, width, height));
   }
 
-  DCHECK(panel->expansion_state() == Panel::EXPANDED);
   panels_.push_back(panel);
 }
 
 int PanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
 int PanelStrip::GetMaxPanelHeight() const {
   return display_area_.height();
 }
@@ skipping 27 matching lines @@
     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::EXPANDED)
+  if (panel->expansion_state() == Panel::TITLE_ONLY ||
+    panel->expansion_state() == Panel::MINIMIZED)
     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 124 matching lines @@
 
   DelayedRemove();
 }
 
 void PanelStrip::OnPanelExpansionStateChanged(
     Panel* panel, Panel::ExpansionState old_state) {
   gfx::Size size = panel->restored_size();
   Panel::ExpansionState expansion_state = panel->expansion_state();
   switch (expansion_state) {
     case Panel::EXPANDED:
-      if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
+      if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED) {
         DecrementMinimizedPanels();
+      } else if (old_state == Panel::IN_OVERFLOW) {
+        panel_manager_->panel_overflow_strip()->Remove(panel);
+        AddPanel(panel);
+        panel->SetAppIconVisibility(true);
+      }
       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();
@@ skipping 75 matching lines @@
 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 &&
       mouse_y >= display_area_.bottom())
     return true;
 
+  // Bring up titlebars if any panel needs the titlebar up.
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
-    if ((*iter)->ShouldBringUpTitlebar(mouse_x, mouse_y))
+    Panel* panel = *iter;
+    Panel::ExpansionState state = panel->expansion_state();
+    // Skip the expanded panel.
+    if (state == Panel::EXPANDED)
+      continue;
+
+    // If the panel is showing titlebar only, we want to keep it up when it is
+    // being dragged.
+    if (state == Panel::TITLE_ONLY && is_dragging_panel())
+      return true;
+
+    // We do not want to bring up other minimized panels if the mouse is over
+    // the panel that pops up the titlebar to attract   attention.
+    if (panel->IsDrawingAttention())
+      continue;
+
+    gfx::Rect bounds = panel->GetBounds();
+    if (bounds.x() <= mouse_x && mouse_x <= bounds.right() &&
+        mouse_y >= bounds.y())
       return true;
   }
   return false;
 }
 
 void PanelStrip::BringUpOrDownTitlebars(bool bring_up) {
   if (are_titlebars_up_ == bring_up)
     return;
   are_titlebars_up_ = bring_up;
 
@@ skipping 28 matching lines @@
   // taskbar will cover the panel in title hover mode, leaving it up for a few
   // seconds would allow the user to be able to click on it.
   //
   // Currently, no platforms use both delays.
   DCHECK(task_delay_milliseconds == 0);
   if (!bring_up)
     task_delay_milliseconds = kMillisecondsBeforeCollapsingFromTitleOnlyState;
 
   // OnAutoHidingDesktopBarVisibilityChanged will handle this.
   delayed_titlebar_action_ = bring_up ? BRING_UP : BRING_DOWN;
-  if (remove_delays_for_testing_)
-    task_delay_milliseconds = 0;
 
   // If user moves the mouse in and out of mouse tracking area, we might have
   // previously posted but not yet dispatched task in the queue. New action
   // should always 'reset' the delays so cancel any tasks that haven't run yet
   // and post a new one.
   titlebar_action_factory_.InvalidateWeakPtrs();
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&PanelStrip::DelayedBringUpOrDownTitlebarsCheck,
                  titlebar_action_factory_.GetWeakPtr()),
@@ skipping 83 matching lines @@
 
   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
 #if defined(OS_WIN)
-    if (x < display_area_.x()) {
-      MovePanelsToOverflow(panel_index);
+    if (x < display_area_.x())
       break;
-    }
 #endif
 
     new_bounds.set_x(x);
     new_bounds.set_y(
         GetBottomPositionForExpansionState(panel->expansion_state()) -
             new_bounds.height());
     panel->SetPanelBounds(new_bounds);
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
 
   // TODO(jianli): remove the guard when overflow support is enabled on other
   // platforms. http://crbug.com/105073
 #if defined(OS_WIN)
-  if (panel_index == panels_.size())
-    MovePanelsFromOverflowIfNeeded();
+  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);
+  } 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() -
+           overflow_panel->restored_size().width() >= display_area_.x()) {
+      overflow_panel->SetExpansionState(Panel::EXPANDED);
+    }
+  }
 #endif
 }
 
-void PanelStrip::MovePanelsToOverflow(size_t overflow_point) {
-  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;
-
-  panel_manager_->panel_overflow_strip()->AddPanel(panel, is_new);
-}
-
-void PanelStrip::MovePanelsFromOverflowIfNeeded() {
-  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::MovePanelToOverflowAfterDelay(Panel* panel) {
+  // Make sure panel still exists in the strip.
+  // Search in reverse as new panels are at the end of the strip.
+  DCHECK(panel->temporary_layout());

[jennb, 2011/12/07 20:04:11]

Oops. will move this  dcheck into the loop in case panel no longer a valid
pointer.

+  for (Panels::reverse_iterator iter = panels_.rbegin();
+       iter != panels_.rend(); ++iter) {
+    if (*iter == panel) {
+      panel->SetExpansionState(Panel::IN_OVERFLOW);
+      break;
+    }
   }
 }
 
 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;
 }