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 33 matching lines @@
 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;
+// due to lack of space. Arbitrary, should still allow the titlebar's buttons
+// to be somewhat useful. At least Close button should be functional.
+const int kMinPanelWidthForDisplay = 70;

[jennb, 2012/04/28 00:09:49]

Why don't we just make this the same as kPanelMinWidth and avoid a second var?

[Dmitry Titov, 2012/04/28 00:57:40]

Done.

 }  // namespace
 
 // static
 const int DockedPanelStrip::kPanelMinWidth = 100;
 const int DockedPanelStrip::kPanelMinHeight = 20;
 
 DockedPanelStrip::DockedPanelStrip(PanelManager* panel_manager)
     : PanelStrip(PanelStrip::DOCKED),
       panel_manager_(panel_manager),
       minimized_panel_count_(0),
@@ skipping 88 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 275 matching lines @@
   // 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

[jennb, 2012/04/28 00:09:49]

Still want to update the limits here if panel is auto-resizable.

[Dmitry Titov, 2012/04/28 00:57:40]

Done. This leaves the panels that are not auto-resizable because they were sized
by API. But it might be ok to equal those to the user-sizable in this place. 
I thought a bit about having additional flag "was_resized_by_user" but this
seems to create too many permutations of visible behavior that will simply
confuse the user if observed.

-  // 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));
-
   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();
 }