Remove panel size limit when user resizes it.

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/auto_reset.h"
@@ skipping 32 matching lines @@
 #if defined(TOOLKIT_GTK)
 const int kDelayBeforeCollapsingFromTitleOnlyStateMs = 2000;
 #else
 const int kDelayBeforeCollapsingFromTitleOnlyStateMs = 0;
 #endif
 
 // After focus changed, one panel lost active status, another got it,
 // we refresh layout with a delay.
 const int kRefreshLayoutAfterActivePanelChangeDelayMs = 200;  // arbitrary
 
-// The minimum panel width when it is "squeezed" in the docked strip
-// due to lack of space.
-const int kMinPanelWidthForDisplay = 26;
 }  // namespace
 
 // static
-const int DockedPanelStrip::kPanelMinWidth = 100;
+// These numbers are semi-arbitrary.
+// Motivation for 'width' is to make main buttons on the titlebar functional.
+// Motivation for height is to allow autosized tightly-wrapped panel with a
+// single line of text - so the height is set to be likely less then a titlebar,
+// to make sure even small content is tightly wrapped.
+const int DockedPanelStrip::kPanelMinWidth = 80;
 const int DockedPanelStrip::kPanelMinHeight = 20;
 
 DockedPanelStrip::DockedPanelStrip(PanelManager* panel_manager)
     : PanelStrip(PanelStrip::DOCKED),
       panel_manager_(panel_manager),
       minimized_panel_count_(0),
       are_titlebars_up_(false),
       minimizing_all_(false),
       delayed_titlebar_action_(NO_ACTION),
       titlebar_action_factory_(this),
@@ skipping 84 matching lines @@
     height = kPanelMinHeight;
   else if (height > max_panel_height)
     height = max_panel_height;
 
   full_size = gfx::Size(width, height);
   panel->set_full_size(full_size);
   gfx::Point pt = GetDefaultPositionForPanel(full_size);
 
   panel->Initialize(gfx::Rect(pt.x(), pt.y(), width, height));
 
+  panel->SetSizeRange(gfx::Size(kPanelMinWidth, kPanelMinHeight),
+                      gfx::Size(max_panel_width, max_panel_height));
+
   InsertExistingPanelAtDefaultPosition(panel, true /*update_bounds*/);
 }
 
 void DockedPanelStrip::InsertExistingPanelAtKnownPosition(Panel* panel) {
   DCHECK(panel->initialized());
 
   int x = panel->GetBounds().x();
   Panels::iterator iter = panels_.begin();
   for (; iter != panels_.end(); ++iter)
     if (x > (*iter)->GetBounds().x())
@@ skipping 391 matching lines @@
   DCHECK_LE(minimized_panel_count_, num_panels());
 }
 
 void DockedPanelStrip::ResizePanelWindow(
     Panel* panel,
     const gfx::Size& preferred_window_size) {
   DCHECK_EQ(this, panel->panel_strip());
   // Make sure the new size does not violate panel's size restrictions.
   gfx::Size new_size(preferred_window_size.width(),
                      preferred_window_size.height());
-  panel->ClampSize(&new_size);
+  new_size = panel->ClampSize(new_size);
 
   if (new_size == panel->full_size())
     return;
 
   panel->set_full_size(new_size);
 
   RefreshLayout();
 }
 
 bool DockedPanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
@@ skipping 258 matching lines @@
 
     ++num_processed;
   }
 }
 
 int DockedPanelStrip::WidthToDisplayPanelInStrip(bool is_for_active_panel,
                                                  double squeeze_factor,
                                                  int full_width) const {
   if (is_for_active_panel)
     return full_width;
-  return std::max(kMinPanelWidthForDisplay,
+  return std::max(kPanelMinWidth,
       static_cast<int>(floor(full_width * squeeze_factor)));
 }
 
 void DockedPanelStrip::CloseAll() {
   // This should only be called at the end of tests to clean up.
 
   // 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();
 }
 
 void DockedPanelStrip::UpdatePanelOnStripChange(Panel* panel) {
-  // Always update limits, even on existing panels, in case the limits 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));
-
+  // Update limits if the panel is still autosizable, in case the limit has
+  // changed. If the panel is not autoresizable, then it was resized
+  // by the user or by the app via API.
+  if (panel->auto_resizable()) {
+    int max_panel_width = GetMaxPanelWidth();
+    int max_panel_height = GetMaxPanelHeight();
+    panel->SetSizeRange(gfx::Size(kPanelMinWidth, kPanelMinHeight),
+                        gfx::Size(max_panel_width, max_panel_height));
+  }
   panel->set_attention_mode(Panel::USE_PANEL_ATTENTION);
   panel->SetAppIconVisibility(true);
   panel->SetAlwaysOnTop(true);
   panel->EnableResizeByMouse(true);
 }
 
 void DockedPanelStrip::OnPanelActiveStateChanged(Panel* panel) {
   // Refresh layout, but wait till active states settle.
   // This lets us avoid refreshing too many times when one panel loses
   // focus and another gains it.
   refresh_action_factory_.InvalidateWeakPtrs();
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DockedPanelStrip::RefreshLayout,
           refresh_action_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(PanelManager::AdjustTimeInterval(
           kRefreshLayoutAfterActivePanelChangeDelayMs)));
 }
 
 bool DockedPanelStrip::HasPanel(Panel* panel) const {
   return find(panels_.begin(), panels_.end(), panel) != panels_.end();
 }