Mac: Added a delay before panels go to minimized state from title-only state.

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 14 matching lines @@
 // area.
 const double kPanelMaxWidthFactor = 1.0;
 const double kPanelMaxHeightFactor = 0.5;
 
 // Occasionally some system, like Windows, might not bring up or down the bottom
 // bar when the mouse enters or leaves the bottom screen area. This is the
 // maximum time we will wait for the bottom bar visibility change notification.
 // After the time expires, we bring up/down the titlebars as planned.
 const int kMaxMillisecondsWaitForBottomBarVisibilityChange = 1000;
 
+// See usage below.
+#if defined(OS_MACOSX)
+const int kMillisecondsBeforeCollapsingFromTitleonlyState = 3000;

[jennb, 2011/10/29 00:16:51]

TitleOnly ?

[Dmitry Titov, 2011/10/29 00:41:58]

Done.

+#else
+const int kMillisecondsBeforeCollapsingFromTitleonlyState = 0;
+#endif
+
 // Single instance of PanelManager.
 scoped_refptr<PanelManager> panel_manager_instance;
 }  // namespace
 
 // static
 PanelManager* PanelManager::GetInstance() {
   if (!panel_manager_instance.get())
     panel_manager_instance = new PanelManager();
   return panel_manager_instance.get();
 }
 
 PanelManager::PanelManager()
     : minimized_panel_count_(0),
       are_titlebars_up_(false),
       dragging_panel_index_(kInvalidPanelIndex),
       dragging_panel_original_x_(0),
       delayed_titlebar_action_(NO_ACTION),
+      remove_delays_for_testing_(false),
+      bring_up_down_task_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       auto_sizing_enabled_(true),
       mouse_watching_disabled_(false) {
   panel_mouse_watcher_.reset(PanelMouseWatcher::Create(this));
   auto_hiding_desktop_bar_ = AutoHidingDesktopBar::Create(this);
   OnDisplayChanged();
 }
 
 PanelManager::~PanelManager() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
   DCHECK_EQ(0, minimized_panel_count_);
+  if (bring_up_down_task_) {
+     bring_up_down_task_->Cancel();
+     bring_up_down_task_ = NULL;
+  }
 }
 
 void PanelManager::OnDisplayChanged() {
   scoped_ptr<WindowSizer::MonitorInfoProvider> info_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
   SetWorkArea(info_provider->GetPrimaryMonitorWorkArea());
 }
 
 void PanelManager::SetWorkArea(const gfx::Rect& work_area) {
   if (work_area == work_area_)
@@ skipping 311 matching lines @@
 
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     if ((*iter)->ShouldBringUpTitlebar(mouse_x, mouse_y))
       return true;
   }
   return false;
 }
 
 void PanelManager::BringUpOrDownTitlebars(bool bring_up) {
+  int task_delay_milliseconds = 0;
+
   // If the auto-hiding bottom bar exists, delay the action until the bottom
   // bar is fully visible or hidden. We do not want both bottom bar and panel
   // titlebar to move at the same time but with different speeds.
   if (auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM)) {
     AutoHidingDesktopBar::Visibility visibility = auto_hiding_desktop_bar_->
         GetVisibility(AutoHidingDesktopBar::ALIGN_BOTTOM);
     if (visibility != (bring_up ? AutoHidingDesktopBar::VISIBLE
                                 : AutoHidingDesktopBar::HIDDEN)) {
-      // OnAutoHidingDesktopBarVisibilityChanged will handle this.
-      delayed_titlebar_action_ = bring_up ? BRING_UP : BRING_DOWN;
-
       // Occasionally some system, like Windows, might not bring up or down the
       // bottom bar when the mouse enters or leaves the bottom screen area.
       // Thus, we schedule a delayed task to do the work if we do not receive
       // the bottom bar visibility change notification within a certain period
       // of time.
-      MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &PanelManager::DelayedBringUpOrDownTitlebarsCheck),
-          kMaxMillisecondsWaitForBottomBarVisibilityChange);
-
-      return;
+      task_delay_milliseconds =
+          kMaxMillisecondsWaitForBottomBarVisibilityChange;
     }
   }
 
-  DoBringUpOrDownTitlebars(bring_up);
+  // On some OSes, the interaction with native Taskbars/Docks may be improved
+  // if the panels do not go back to minimized state too fast. For example,
+  // it makes it possible to hit the titlebar on OSX if Dock has Magnifying
+  // enabled - the panels stay up for a while after Dock magnification effect
+  // stops covering the panels.
+  if (!bring_up &&
+      task_delay_milliseconds < kMillisecondsBeforeCollapsingFromTitleonlyState)
+    task_delay_milliseconds = kMillisecondsBeforeCollapsingFromTitleonlyState;

[jennb, 2011/10/29 00:16:51]

Should this be += in case we also need to wait for
kMaxMillisecondsWaitForBottomBarVisibilityChange?

[Dmitry Titov, 2011/10/29 00:41:58]

Not sure (there is no TitleonlyStata delay for Windows and no autohide support
for Mac, so it's hard to tell, since both delays are empirical. Added TODO.

+
+  // OnAutoHidingDesktopBarVisibilityChanged will handle this.
+  delayed_titlebar_action_ = bring_up ? BRING_UP : BRING_DOWN;
+  if (remove_delays_for_testing_)
+    task_delay_milliseconds = 0;
+
+ if (bring_up_down_task_)

[jianli, 2011/10/29 00:19:18]

Please comment why we need to cancel the task.

[Dmitry Titov, 2011/10/29 00:41:58]

Done.

+    bring_up_down_task_->Cancel();
+
+  bring_up_down_task_ = NewRunnableMethod(

[jennb, 2011/10/29 00:16:51]

Why the change from method_factor_? Just asking for my own educational purposes.

[Dmitry Titov, 2011/10/29 00:41:58]

metod_factory does not give the task back. it manages them inside, making sure
they are cancelled in destruction time. I need to call Cancel() explicitly  so I
need to use CancelableTask directly and Cancel it also in the ~PanelManager.

+      this, &PanelManager::DelayedBringUpOrDownTitlebarsCheck);
+
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                          bring_up_down_task_,
+                                          task_delay_milliseconds);
 }
 
 void PanelManager::DelayedBringUpOrDownTitlebarsCheck() {
+  bring_up_down_task_ = NULL;
+
+  // Task was already processed or cancelled - bail out.
   if (delayed_titlebar_action_ == NO_ACTION)
     return;
 
-  DoBringUpOrDownTitlebars(delayed_titlebar_action_ == BRING_UP);
+  bool need_to_bring_up_titlebars = (delayed_titlebar_action_ == BRING_UP);
+
   delayed_titlebar_action_ = NO_ACTION;
+
+  // Check if the action is still needed based on the latest mouse position. The
+  // user could move the mouse into the tracking area and then quickly move it
+  // out of the area. In case of this, cancel the action.
+  if (are_titlebars_up_ != need_to_bring_up_titlebars)
+    return;
+
+  DoBringUpOrDownTitlebars(need_to_bring_up_titlebars);
 }
 
 void PanelManager::DoBringUpOrDownTitlebars(bool bring_up) {
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
 
     // Skip any panel that is drawing the attention.
     if (panel->IsDrawingAttention())
       continue;
@@ skipping 112 matching lines @@
   // 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;
 }