Mark the ET_MOUSE_MOVED created from a pointer grab as synthesized.

ui/aura/window_event_dispatcher.cc

 // Copyright 2014 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/aura/window_event_dispatcher.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 208 matching lines @@
   gfx::Point location = Env::GetInstance()->last_mouse_location();
   client::ScreenPositionClient* client =
       client::GetScreenPositionClient(window());
   if (client)
     client->ConvertPointFromScreen(window(), &location);
   return location;
 }
 
 void WindowEventDispatcher::OnHostLostMouseGrab() {
   mouse_pressed_handler_ = NULL;
+  LOG(ERROR) << "mouse_moved_handler_ = NULL (was " << mouse_moved_handler_
+             << ")";
   mouse_moved_handler_ = NULL;
 }
 
 void WindowEventDispatcher::OnCursorMovedToRootLocation(
     const gfx::Point& root_location) {
   Env::GetInstance()->env_controller()->SetLastMouseLocation(window(),
                                                              root_location);
 
   // Synthesize a mouse move in case the cursor's location in root coordinates
   // changed but its position in WindowTreeHost coordinates did not.
@@ skipping 81 matching lines @@
   }
   return details;
 }
 
 void WindowEventDispatcher::OnWindowHidden(Window* invisible,
                                            WindowHiddenReason reason) {
   // If the window the mouse was pressed in becomes invisible, it should no
   // longer receive mouse events.
   if (invisible->Contains(mouse_pressed_handler_))
     mouse_pressed_handler_ = NULL;
-  if (invisible->Contains(mouse_moved_handler_))
+  if (invisible->Contains(mouse_moved_handler_)) {
+    LOG(ERROR) << "mouse_moved_handler_ = NULL (was " << mouse_moved_handler_
+               << ")";
     mouse_moved_handler_ = NULL;
+  }
 
   // If events are being dispatched from a nested message-loop, and the target
   // of the outer loop is hidden or moved to another dispatcher during
   // dispatching events in the inner loop, then reset the target for the outer
   // loop.
   if (invisible->Contains(old_dispatch_target_))
     old_dispatch_target_ = NULL;
 
   invisible->CleanupGestureState();
 
@@ skipping 27 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, aura::client::CaptureDelegate implementation:
 
 void WindowEventDispatcher::UpdateCapture(Window* old_capture,
                                           Window* new_capture) {
   // |mouse_moved_handler_| may have been set to a Window in a different root
   // (see below). Clear it here to ensure we don't end up referencing a stale
   // Window.
-  if (mouse_moved_handler_ && !window()->Contains(mouse_moved_handler_))
+  if (mouse_moved_handler_ && !window()->Contains(mouse_moved_handler_)) {
+    LOG(ERROR) << "mouse_moved_handler_ = NULL (was " << mouse_moved_handler_
+               << ")";
     mouse_moved_handler_ = NULL;
+  }
 
   if (old_capture && old_capture->GetRootWindow() == window() &&
       old_capture->delegate()) {
     // Send a capture changed event with bogus location data.
     ui::MouseEvent event(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(),
                          gfx::Point(), ui::EventTimeForNow(), 0, 0);
 
     DispatchDetails details = DispatchEvent(old_capture, &event);
     if (details.dispatcher_destroyed)
       return;
 
     if (!details.target_destroyed)
       old_capture->delegate()->OnCaptureLost();
   }
 
   if (new_capture) {
     // Make all subsequent mouse events go to the capture window. We shouldn't
     // need to send an event here as OnCaptureLost() should take care of that.
-    if (mouse_moved_handler_ || Env::GetInstance()->IsMouseButtonDown())
+    if (mouse_moved_handler_ || Env::GetInstance()->IsMouseButtonDown()) {
+      LOG(ERROR) << "mouse_moved_handler_ = " << new_capture << " (was "
+                 << mouse_moved_handler_ << ")";
       mouse_moved_handler_ = new_capture;
+    }
   } else {
     // Make sure mouse_moved_handler gets updated.
     DispatchDetails details = SynthesizeMouseMoveEvent();
     if (details.dispatcher_destroyed)
       return;
   }
   mouse_pressed_handler_ = NULL;
 }
 
 void WindowEventDispatcher::OnOtherRootGotCapture() {
   // Windows provides the TrackMouseEvents API which allows us to rely on the
   // OS to send us the mouse exit events (WM_MOUSELEAVE). Additionally on
   // desktop Windows, every top level window could potentially have its own
   // root window, in which case this function will get called whenever those
   // windows grab mouse capture. Sending mouse exit messages in these cases
   // causes subtle bugs like (crbug.com/394672).
 #if !defined(OS_WIN)
   if (mouse_moved_handler_) {
     // Dispatch a mouse exit to reset any state associated with hover. This is
     // important when going from no window having capture to a window having
     // capture because we do not dispatch ET_MOUSE_CAPTURE_CHANGED in this case.
     DispatchDetails details =
         DispatchMouseExitAtPoint(nullptr, GetLastMouseLocationInRoot());
     if (details.dispatcher_destroyed)
       return;
   }
 #endif
 
+  LOG(ERROR) << "mouse_moved_handler_ = NULL (was " << mouse_moved_handler_
+             << ")";
   mouse_moved_handler_ = NULL;
   mouse_pressed_handler_ = NULL;
 }
 
 void WindowEventDispatcher::SetNativeCapture() {
   host_->SetCapture();
 }
 
 void WindowEventDispatcher::ReleaseNativeCapture() {
   host_->ReleaseCapture();
@@ skipping 364 matching lines @@
   return DispatchDetails();
 }
 
 DispatchDetails WindowEventDispatcher::PreDispatchMouseEvent(
     Window* target,
     ui::MouseEvent* event) {
   client::CursorClient* cursor_client = client::GetCursorClient(window());
   // We allow synthesized mouse exit events through even if mouse events are
   // disabled. This ensures that hover state, etc on controls like buttons is
   // cleared.
+  if (cursor_client)
+    LOG(ERROR) << cursor_client->IsMouseEventsEnabled();
   if (cursor_client &&
       !cursor_client->IsMouseEventsEnabled() &&
       (event->flags() & ui::EF_IS_SYNTHESIZED) &&
       (event->type() != ui::ET_MOUSE_EXITED)) {
+    LOG(ERROR) << "drop";
     event->SetHandled();
     return DispatchDetails();
   }
 
   Env::GetInstance()->env_controller()->UpdateStateForMouseEvent(window(),
                                                                  *event);
 
   if (IsEventCandidateForHold(*event) && !dispatching_held_event_) {
     if (move_hold_count_) {
       held_move_event_.reset(new ui::MouseEvent(*event, target, window()));
+      LOG(ERROR) << "drop";
       event->SetHandled();
       return DispatchDetails();
     } else {
       // We may have a held event for a period between the time move_hold_count_
       // fell to 0 and the DispatchHeldEvents executes. Since we're going to
       // dispatch the new event directly below, we can reset the old one.
       held_move_event_.reset();
     }
   }
 
   switch (event->type()) {
     case ui::ET_MOUSE_EXITED:
       if (!target || target == window()) {
         DispatchDetails details =
             DispatchMouseEnterOrExit(target, *event, ui::ET_MOUSE_EXITED);
         if (details.dispatcher_destroyed) {
           event->SetHandled();
           return details;
         }
+        LOG(ERROR) << "mouse_moved_handler_ = NULL (was "
+                   << mouse_moved_handler_ << ")";
         mouse_moved_handler_ = NULL;
       }
       break;
     case ui::ET_MOUSE_MOVED:
       // Send an exit to the current |mouse_moved_handler_| and an enter to
       // |target|. Take care that both us and |target| aren't destroyed during
       // dispatch.
       if (target != mouse_moved_handler_) {
         aura::Window* old_mouse_moved_handler = mouse_moved_handler_;
         WindowTracker live_window;
         live_window.Add(target);
         DispatchDetails details =
             DispatchMouseEnterOrExit(target, *event, ui::ET_MOUSE_EXITED);
         // |details| contains information about |mouse_moved_handler_| being
         // destroyed which is not our |target|. Return value of this function
         // should be about our |target|.
         DispatchDetails target_details = details;
         target_details.target_destroyed = !live_window.Contains(target);
         if (details.dispatcher_destroyed) {
+          LOG(ERROR) << "drop";
           event->SetHandled();
           return target_details;
         }
         // If the |mouse_moved_handler_| changes out from under us, assume a
         // nested run loop ran and we don't need to do anything.
         if (mouse_moved_handler_ != old_mouse_moved_handler) {
+          LOG(ERROR) << "drop";
           event->SetHandled();
           return target_details;
         }
         if (details.target_destroyed || target_details.target_destroyed) {
+          LOG(ERROR) << "mouse_moved_handler_ = NULL (was "
+                     << mouse_moved_handler_ << ")";
           mouse_moved_handler_ = NULL;
           event->SetHandled();
           return target_details;
         }
         live_window.Remove(target);
 
+        LOG(ERROR) << "mouse_moved_handler_ = " << target << " (was "
+                   << mouse_moved_handler_ << ")";
         mouse_moved_handler_ = target;
         details =
             DispatchMouseEnterOrExit(target, *event, ui::ET_MOUSE_ENTERED);
         if (details.dispatcher_destroyed || details.target_destroyed) {
           event->SetHandled();
           return details;
         }
       }
       break;
     case ui::ET_MOUSE_PRESSED:
@@ skipping 46 matching lines @@
     ui::KeyEvent* event) {
   if (skip_ime_ || !host_->has_input_method() ||
       (event->flags() & ui::EF_IS_SYNTHESIZED))
     return ui::EventDispatchDetails();
   host_->GetInputMethod()->DispatchKeyEvent(event);
   event->StopPropagation();
   return ui::EventDispatchDetails();
 }
 
 }  // namespace aura