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() {
+  // Set minimizing_all_ to prevent deactivation of each panel when it
+  // is minimized. See comments in OnPanelExpansionStateChanged.
+  AutoReset<bool> pin(&minimizing_all_, true);
+  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) {
+    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();
 }