Add key modifier on minimize/restore button click to minimize/restore all Panels for Mac.

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 459 matching lines @@
   }
 }
 
 void DockedPanelStrip::OnPanelTitlebarClicked(Panel* panel,
                                               panel::ClickModifier modifier) {
   DCHECK_EQ(this, panel->panel_strip());
   if (!IsPanelMinimized(panel))
     return;
 
   if (modifier == panel::APPLY_TO_ALL)
-    ToggleMinimizeAll(panel);
+    RestoreAll();
   else
     RestorePanel(panel);
 }
 
 void DockedPanelStrip::ActivatePanel(Panel* panel) {
   DCHECK_EQ(this, panel->panel_strip());
 
   // Make sure the panel is expanded when activated so the user input
   // does not go into a collapsed window.
   panel->SetExpansionState(Panel::EXPANDED);
@@ skipping 10 matching lines @@
 
   panel->SetExpansionState(panel->IsDrawingAttention() ?
       Panel::TITLE_ONLY : Panel::MINIMIZED);
 }
 
 void DockedPanelStrip::RestorePanel(Panel* panel) {
   DCHECK_EQ(this, panel->panel_strip());
   panel->SetExpansionState(Panel::EXPANDED);
 }
 
+void DockedPanelStrip::MinimizeAll() {
+  AutoReset<bool> pin(&minimizing_all_, true);

[jianli, 2012/04/26 18:06:57]

nit: please add comment for this.

[jennb, 2012/04/27 00:30:11]

Done.

+  Panel* minimized_active_panel = NULL;
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
+    if ((*iter)->IsActive())
+      minimized_active_panel = *iter;
+    MinimizePanel(*iter);
+  }
+
+  // When a single panel is minimized, it is deactivated to ensure that
+  // a minimized panel does not have focus. However, when minimizing all,
+  // the deactivation is only done once after all panels are minimized,
+  // rather than per minimized panel, both for efficiency and to avoid
+  // temporary activations of random not-yet-minimized panels.
+  if (minimized_active_panel) {

[jianli, 2012/04/26 18:06:57]

I think it might be a little bit safer to iterate all the panels again and
deactivate those that are minimized and still active. This is because we might
have the edge case that other panel get activated by the system or the tracking
panel is being closed.

[jennb, 2012/04/27 00:30:11]

If another panel is activated by the system while we are minimizing all, that
active panel will not be any of the minimized panels as minimized panels cannot
be activated. The active panel can only be one that has not yet been minimized,
which means we will eventually find it when we get around to minimizing it.
Thus, there is no need to iterate through again.

[jianli, 2012/04/27 00:39:04]

What if minimized_active_panel is closed before we call Deactivate for it? This
could happen though it is rare.

[jennb, 2012/04/27 16:47:45]

The closure would happen on a separate pass of the message loop. We are
deactivating the panel in the same method where we minimize it so it all gets
processed in one message loop pass.

+    minimized_active_panel->Deactivate();
+    // Layout will be refreshed in response to (de)activation notification.
+  }
+}
+
+void DockedPanelStrip::RestoreAll() {
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
+    RestorePanel(*iter);
+  }
+}
+
 bool DockedPanelStrip::CanMinimizePanel(const Panel* panel) const {
   DCHECK_EQ(this, panel->panel_strip());
   // Docked panels can be minimized.
   return true;
 }
 
 bool DockedPanelStrip::IsPanelMinimized(const Panel* panel) const {
   return panel->expansion_state() != Panel::EXPANDED;
 }
 
 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::ToggleMinimizeAll(Panel* panel) {
-  DCHECK_EQ(this, panel->panel_strip());
-  AutoReset<bool> pin(&minimizing_all_, IsPanelMinimized(panel) ? false : true);
-  Panel* minimized_active_panel = NULL;
-  for (Panels::const_iterator iter = panels_.begin();
-       iter != panels_.end(); ++iter) {
-    if (minimizing_all_) {
-      if ((*iter)->IsActive())
-        minimized_active_panel = *iter;
-      MinimizePanel(*iter);
-    } else {
-      RestorePanel(*iter);
-    }
-  }
-
-  // When a single panel is minimized, it is deactivated to ensure that
-  // a minimized panel does not have focus. However, when minimizing all,
-  // the deactivation is only done once after all panels are minimized,
-  // rather than per minimized panel, both for efficiency and to avoid
-  // temporary activations of random not-yet-minimized panels.
-  if (minimized_active_panel) {
-    minimized_active_panel->Deactivate();
-    // Layout will be refreshed in response to (de)activation notification.
-  }
-}
-
 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);
 
   if (new_size == panel->full_size())
@@ skipping 312 matching lines @@
       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();
 }