Change panel overflow to not close any open panels.

chrome/browser/ui/panels/panel_manager.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_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 62 matching lines @@
   if (work_area == work_area_)
     return;
   work_area_ = work_area;
 
   auto_hiding_desktop_bar_->UpdateWorkArea(work_area_);
   AdjustWorkAreaForAutoHidingDesktopBars();
 
   Rearrange(panels_.begin(), adjusted_work_area_.right());
 }
 
-void PanelManager::FindAndClosePanelOnOverflow(const Extension* extension) {
-  Panel* panel_to_close = NULL;
-
-  // Try to find the left-most panel invoked from the same extension and close
-  // it.
-  for (Panels::reverse_iterator iter = panels_.rbegin();
-       iter != panels_.rend(); ++iter) {
-    if (extension == (*iter)->GetExtension()) {
-      panel_to_close = *iter;
-      break;
-    }
-  }
-
-  // If none is found, just pick the left-most panel.
-  if (!panel_to_close)
-    panel_to_close = panels_.back();
-
-  panel_to_close->Close();
-}
-
 Panel* PanelManager::CreatePanel(Browser* browser) {
   // Adjust the width and height to fit into our constraint.
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
 
   if (width == 0 && height == 0) {
     width = kPanelDefaultWidth;
     height = kPanelDefaultHeight;
   }
 
   int max_panel_width = GetMaxPanelWidth();
   int max_panel_height = GetMaxPanelHeight();
 
   if (width < kPanelMinWidth)
     width = kPanelMinWidth;
   else if (width > max_panel_width)
     width = max_panel_width;
 
   if (height < kPanelMinHeight)
     height = kPanelMinHeight;
   else if (height > max_panel_height)
     height = max_panel_height;
 
-  // Compute the origin. Ensure that it falls within the adjusted work area by
-  // closing other panels if needed.
   int y = adjusted_work_area_.bottom() - height;
-
-  const Extension* extension = NULL;
-  int x;
-  while ((x = GetRightMostAvailablePosition() - width) <
-         adjusted_work_area_.x() ) {
-    if (!extension)
-      extension = Panel::GetExtensionFromBrowser(browser);
-    FindAndClosePanelOnOverflow(extension);
-  }
+  int x = GetRightMostAvailablePosition() - width;
 
   // Now create the panel with the computed bounds.
   Panel* panel = new Panel(browser, gfx::Rect(x, y, width, height));
+  panel->SetMaxSize(gfx::Size(max_panel_width, max_panel_height));
   panels_.push_back(panel);
-
-  UpdateMaxSizeForAllPanels();
-
   return panel;
 }
 
 int PanelManager::GetMaxPanelWidth() const {
   return static_cast<int>(adjusted_work_area_.width() * kPanelMaxWidthFactor);
 }
 
 int PanelManager::GetMaxPanelHeight() const {
   return static_cast<int>(adjusted_work_area_.height() * kPanelMaxHeightFactor);
 }
@@ skipping 195 matching lines @@
 void PanelManager::OnPreferredWindowSizeChanged(
     Panel* panel, const gfx::Size& preferred_window_size) {
   if (!auto_sizing_enabled_)
     return;
 
   gfx::Rect bounds = panel->GetBounds();
   int restored_height = panel->GetRestoredHeight();
 
   // The panel width:
   // * cannot grow or shrink to go beyond [min_width, max_width]
   // * cannot grow to take more than the available space and go beyond the left

[jianli, 2011/10/21 22:37:15]

Please update the comment here.

   //   of the work area.
   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();
 
-  int right_most_available_position = GetRightMostAvailablePosition();
-  if (new_width - bounds.width() > right_most_available_position)
-    new_width = bounds.width() + right_most_available_position;
-
   if (new_width != bounds.width()) {
     int delta = bounds.width() - new_width;
     bounds.set_x(bounds.x() + delta);
     bounds.set_width(new_width);
 
     // Reposition all the panels on the left.
     int panel_index = -1;
     for (int i = 0; i < static_cast<int>(panels_.size()); ++i) {
       if (panels_[i] == panel) {
         panel_index = i;
@@ skipping 20 matching lines @@
   if (new_height != restored_height) {
     panel->SetRestoredHeight(new_height);
     // Only need to adjust bounds height when panel is expanded.
     if (panel->expansion_state() == Panel::EXPANDED) {
       bounds.set_y(bounds.y() - new_height + bounds.height());
       bounds.set_height(new_height);
     }
   }
 
   panel->SetPanelBounds(bounds);
-
-  UpdateMaxSizeForAllPanels();
 }
 
 bool PanelManager::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.
   if (auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM) &&
       auto_hiding_desktop_bar_->GetVisibility(
               AutoHidingDesktopBar::ALIGN_BOTTOM) ==
           AutoHidingDesktopBar::VISIBLE &&
       mouse_y >= adjusted_work_area_.bottom())
@@ skipping 139 matching lines @@
                                            : AutoHidingDesktopBar::HIDDEN;
   if (visibility != expected_visibility)
     return;
 
   DoBringUpOrDownTitlebars(delayed_titlebar_action_ == BRING_UP);
   delayed_titlebar_action_ = NO_ACTION;
 }
 
 void PanelManager::Rearrange(Panels::iterator iter_to_start,
                              int rightmost_position) {
-  if (iter_to_start != panels_.end()) {
-    for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
-      Panel* panel = *iter;
-      gfx::Rect new_bounds(panel->GetBounds());
-      new_bounds.set_x(rightmost_position - new_bounds.width());
-      new_bounds.set_y(adjusted_work_area_.bottom() - new_bounds.height());
-      if (new_bounds != panel->GetBounds())
-        panel->SetPanelBounds(new_bounds);
+  for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
+    Panel* panel = *iter;
+    gfx::Rect new_bounds(panel->GetBounds());
+    new_bounds.set_x(rightmost_position - new_bounds.width());
+    new_bounds.set_y(adjusted_work_area_.bottom() - new_bounds.height());
+    if (new_bounds != panel->GetBounds())
+      panel->SetPanelBounds(new_bounds);
 
-      rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
-    }
+    rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
-
-  UpdateMaxSizeForAllPanels();
 }
 
 void PanelManager::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 PanelManager::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }
 
-void PanelManager::UpdateMaxSizeForAllPanels() {
-  if (!auto_sizing_enabled_)
-    return;
-
-  for (Panels::const_iterator iter = panels_.begin();
-       iter != panels_.end(); ++iter) {
-    Panel* panel = *iter;
-    // A panel can at most grow to take over all the available space that is
-    // returned by GetRightMostAvailablePosition.
-    int width_can_grow_to =
-        panel->GetBounds().width() + GetRightMostAvailablePosition();
-    panel->SetMaxSize(gfx::Size(
-        std::min(width_can_grow_to, GetMaxPanelWidth()),
-        GetMaxPanelHeight()));
-  }
-}