Ignores mouse motion events when mouse is pressed or drag and drop is in progress

ui/views/corewm/tooltip_controller.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 "ui/views/corewm/tooltip_controller.h"
 
 #include <vector>
 
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
@@ skipping 10 matching lines @@
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/wm/public/drag_drop_client.h"
 
 namespace views {
 namespace corewm {
 namespace {
 
 const int kTooltipTimeoutMs = 500;
 const int kDefaultTooltipShownTimeoutMs = 10000;
 
+// Delay mouse events so that they are dispatched if there are no mouse location
+// events pending. Even a short delay delays them until the mouse is steady.
+const int kMouseMoveDelay = 10;
+
 // Returns true if |target| is a valid window to get the tooltip from.
 // |event_target| is the original target from the event and |target| the window
 // at the same location.
 bool IsValidTarget(aura::Window* event_target, aura::Window* target) {
   if (!target || (event_target == target))
     return true;
 
   void* event_target_grouping_id = event_target->GetNativeWindowProperty(
       TooltipManager::kGroupingPropertyKey);
   void* target_grouping_id = target->GetNativeWindowProperty(
       TooltipManager::kGroupingPropertyKey);
   return event_target_grouping_id &&
       event_target_grouping_id == target_grouping_id;
 }
 
 // Returns the target (the Window tooltip text comes from) based on the event.
 // If a Window other than event.target() is returned, |location| is adjusted
 // to be in the coordinates of the returned Window.
-aura::Window* GetTooltipTarget(const ui::MouseEvent& event,
+aura::Window* GetTooltipTarget(ui::EventType event_type,
+                               aura::Window* target,
                                gfx::Point* location) {
-  switch (event.type()) {
+  switch (event_type) {
     case ui::ET_MOUSE_CAPTURE_CHANGED:
       // On windows we can get a capture changed without an exit. We need to
       // reset state when this happens else the tooltip may incorrectly show.
       return NULL;
     case ui::ET_MOUSE_EXITED:
       return NULL;
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED: {
-      aura::Window* event_target = static_cast<aura::Window*>(event.target());
+      aura::Window* event_target = target;
       if (!event_target)
         return NULL;
 
       // If a window other than |event_target| has capture, ignore the event.
       // This can happen when RootWindow creates events when showing/hiding, or
       // the system generates an extra event. We have to check
       // GetGlobalCaptureWindow() as Windows does not use a singleton
       // CaptureClient.
       if (!event_target->HasCapture()) {
         aura::Window* root = event_target->GetRootWindow();
         if (root) {
           aura::client::CaptureClient* capture_client =
               aura::client::GetCaptureClient(root);
           if (capture_client) {
             aura::Window* capture_window =
                 capture_client->GetGlobalCaptureWindow();
             if (capture_window && event_target != capture_window)
               return NULL;
           }
         }
         return event_target;
       }
 
       // If |target| has capture all events go to it, even if the mouse is
       // really over another window. Find the real window the mouse is over.
-      gfx::Point screen_loc(event.location());
+      gfx::Point screen_loc(*location);
       aura::client::GetScreenPositionClient(event_target->GetRootWindow())->
           ConvertPointToScreen(event_target, &screen_loc);
       gfx::Screen* screen = gfx::Screen::GetScreenFor(event_target);
       aura::Window* target = screen->GetWindowAtScreenPoint(screen_loc);
       if (!target)
         return NULL;
       gfx::Point target_loc(screen_loc);
       aura::client::GetScreenPositionClient(target->GetRootWindow())->
           ConvertPointFromScreen(target, &target_loc);
       aura::Window* screen_target = target->GetEventHandlerForPoint(target_loc);
       if (!IsValidTarget(event_target, screen_target))

[pkotwicz, 2014/05/07 22:45:08]

Idea: It might be useful to check whether there are any valid targets before
calling GetWindowAtScreenPoint() (I do not think there is a Windows of version
of DesktopWindowTreeHostX11::GetAllOpenWindows() though)

In a separate CL it might also be useful to rename GetWindowAtScreenPoint() to
GetWindowAtScreenPointSlow() (and add a comment in GetWindowAtScreenPointSlow()
as to when it is slow)

[varkha, 2014/05/07 23:08:18]

This may speed this method but with the throttling in place it would not change
much since we are effectively calling this method only once and after the mouse
is steady.
I agree. I'll post that once this gets through review.

         return NULL;
 
       aura::Window::ConvertPointToTarget(screen_target, target, &target_loc);
       *location = target_loc;
       return screen_target;
     }
     default:
       NOTREACHED();
       break;
   }
@@ skipping 70 matching lines @@
     TooltipShownTimerFired();
   }
 }
 
 void TooltipController::OnMouseEvent(ui::MouseEvent* event) {
   switch (event->type()) {
     case ui::ET_MOUSE_CAPTURE_CHANGED:
     case ui::ET_MOUSE_EXITED:
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED: {
-      curr_mouse_loc_ = event->location();
-      aura::Window* target = GetTooltipTarget(*event, &curr_mouse_loc_);
-      SetTooltipWindow(target);
-      if (tooltip_timer_.IsRunning())
-        tooltip_timer_.Reset();
-
-      if (tooltip_->IsVisible())
-        UpdateIfRequired();
+      last_mouse_location_ = event->location();
+      mouse_event_timer_.Start(
+          FROM_HERE,
+          base::TimeDelta::FromMilliseconds(kMouseMoveDelay),
+          base::Bind(&TooltipController::DispatchMouseEvent,

[sky, 2014/05/08 19:05:55]

What happens if we enter some sort of nested message loop that prevents this
from executing?

[varkha, 2014/05/13 19:30:55]

We would need to synchronously process any pending mouse move before going into
a nested loop. We could trigger it in DesktopNativeWidgetAura::RunMoveLoop().

+                     base::Unretained(this),
+                     event->type(),
+                     static_cast<aura::Window*>(event->target())));

[sky, 2014/05/08 19:05:55]

What if window is destroyed between now and when this is processed?

[varkha, 2014/05/13 19:30:55]

We could maintain a set of windows for which we have a pending dispatch, watch
for them being destroyed and check if a window is still in the set when doing
dispatch. I cannot think of a degenerate case where this set would be
significantly long. Does this seem like a right approach to you?

       break;
     }
     case ui::ET_MOUSE_PRESSED:
       if ((event->flags() & ui::EF_IS_NON_CLIENT) == 0) {

[sky, 2014/05/08 19:05:55]

If you process the above async and this (and whell) sync doesn't that lead to
out of order processing?

[varkha, 2014/05/13 19:30:55]

It could. It should be easy to just call a sync dispatch here and stop the timer
if we have mouse_event_timer_ running.

         aura::Window* target = static_cast<aura::Window*>(event->target());
         // We don't get a release for non-client areas.
         tooltip_window_at_mouse_press_ = target;
         if (target)
           tooltip_text_at_mouse_press_ = aura::client::GetTooltipText(target);
       }
       tooltip_->Hide();
       break;
     case ui::ET_MOUSEWHEEL:
       // Hide the tooltip for click, release, drag, wheel events.
@@ skipping 22 matching lines @@
   if (tooltip_window_ == window) {
     tooltip_->Hide();
     tooltip_shown_timeout_map_.erase(tooltip_window_);
     tooltip_window_ = NULL;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TooltipController private:
 
+void TooltipController::DispatchMouseEvent(ui::EventType event_type,
+                                           aura::Window* target) {
+  curr_mouse_loc_ = last_mouse_location_;
+  target = GetTooltipTarget(event_type, target, &curr_mouse_loc_);
+  SetTooltipWindow(target);
+  if (tooltip_timer_.IsRunning())
+    tooltip_timer_.Reset();
+
+  if (tooltip_->IsVisible())
+    UpdateIfRequired();
+}
+
 void TooltipController::TooltipTimerFired() {
   UpdateIfRequired();
 }
 
 void TooltipController::TooltipShownTimerFired() {
   tooltip_->Hide();
 
   // Since the user presumably no longer needs the tooltip, we also stop the
   // tooltip timer so that tooltip does not pop back up. We will restart this
   // timer if the tooltip changes (see UpdateTooltip()).
@@ skipping 92 matching lines @@
     return;
   if (tooltip_window_)
     tooltip_window_->RemoveObserver(this);
   tooltip_window_ = target;
   if (tooltip_window_)
     tooltip_window_->AddObserver(this);
 }
 
 }  // namespace corewm
 }  // namespace views