Fix behavior of WindowEventDispatcher::SynthesizeMouseMoveEvent().

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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 103 matching lines @@
     DCHECK(event.type() == ui::ET_GESTURE_TAP_DOWN);
     held_repostable_event_.reset();
     // TODO(rbyers): Reposing of gestures is tricky to get
     // right, so it's not yet supported.  crbug.com/170987.
   }
 }
 
 void WindowEventDispatcher::OnMouseEventsEnableStateChanged(bool enabled) {
   // Send entered / exited so that visual state can be updated to match
   // mouse events state.
-  PostSynthesizeMouseMove();
+  PostSynthesizeMouseMove(ui::EF_NONE);
   // TODO(mazda): Add code to disable mouse events when |enabled| == false.
 }
 
 void WindowEventDispatcher::DispatchCancelModeEvent() {
   ui::CancelModeEvent event;
   Window* focused_window = client::GetFocusClient(window())->GetFocusedWindow();
   if (focused_window && !window()->Contains(focused_window))
     focused_window = NULL;
   DispatchDetails details =
       DispatchEvent(focused_window ? focused_window : window(), &event);
@@ skipping 237 matching lines @@
     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())
       mouse_moved_handler_ = new_capture;
   } else {
     // Make sure mouse_moved_handler gets updated.
-    DispatchDetails details = SynthesizeMouseMoveEvent();
+    DispatchDetails details = SynthesizeMouseMoveEvent(ui::EF_NONE);
     if (details.dispatcher_destroyed)
       return;
   }
   mouse_pressed_handler_ = NULL;
 }
 
 void WindowEventDispatcher::OnOtherRootGotCapture() {
   mouse_moved_handler_ = NULL;
   mouse_pressed_handler_ = NULL;
 }
@@ skipping 162 matching lines @@
 
   DispatchMouseExitToHidingWindow(window);
 }
 
 void WindowEventDispatcher::OnWindowVisibilityChanged(Window* window,
                                                       bool visible) {
   if (!host_->window()->Contains(window))
     return;
 
   if (window->ContainsPointInRoot(GetLastMouseLocationInRoot()))
-    PostSynthesizeMouseMove();
+    PostSynthesizeMouseMove(ui::EF_NONE);
 
   // Hiding the window releases capture which can implicitly destroy the window
   // so the window may no longer be valid after this call.
   if (!visible)
     OnWindowHidden(window, WINDOW_HIDDEN);
 }
 
 void WindowEventDispatcher::OnWindowBoundsChanged(Window* window,
                                                   const gfx::Rect& old_bounds,
                                                   const gfx::Rect& new_bounds) {
@@ skipping 11 matching lines @@
     // Constrain the mouse position within the new root Window size.
     gfx::Point point;
     if (host_->QueryMouseLocation(&point)) {
       SetLastMouseLocation(
           host_->window(),
           ui::ConvertPointToDIP(host_->window()->layer(), point));
     }
     synthesize_mouse_move_ = false;
   }
 
-  if (window->IsVisible()) {
+  if (window->IsVisible() && !window->ignore_events()) {
     gfx::Rect old_bounds_in_root = old_bounds, new_bounds_in_root = new_bounds;
     Window::ConvertRectToTarget(window->parent(), host_->window(),
                                 &old_bounds_in_root);
     Window::ConvertRectToTarget(window->parent(), host_->window(),
                                 &new_bounds_in_root);
     gfx::Point last_mouse_location = GetLastMouseLocationInRoot();
     if (old_bounds_in_root.Contains(last_mouse_location) !=
         new_bounds_in_root.Contains(last_mouse_location)) {
-      PostSynthesizeMouseMove();
+      PostSynthesizeMouseMove(Env::GetInstance()->mouse_button_flags());
     }
   }
 }
 
 void WindowEventDispatcher::OnWindowTransforming(Window* window) {
   if (!host_->window()->Contains(window))
     return;
 
   SynthesizeMouseMoveAfterChangeToWindow(window);
 }
@@ skipping 45 matching lines @@
     }
     if (!dispatch_details.dispatcher_destroyed)
       held_move_event_.reset();
   }
 
   if (!dispatch_details.dispatcher_destroyed)
     dispatching_held_event_ = false;
   return dispatch_details;
 }
 
-void WindowEventDispatcher::PostSynthesizeMouseMove() {
+void WindowEventDispatcher::PostSynthesizeMouseMove(int mouse_button_flags) {
   if (synthesize_mouse_move_)
     return;
   synthesize_mouse_move_ = true;
   base::MessageLoop::current()->PostNonNestableTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(
           &WindowEventDispatcher::SynthesizeMouseMoveEvent),
-          held_event_factory_.GetWeakPtr()));
+          held_event_factory_.GetWeakPtr(),
+          mouse_button_flags));
 }
 
 void WindowEventDispatcher::SynthesizeMouseMoveAfterChangeToWindow(
     Window* window) {
   if (window->IsVisible() &&
       window->ContainsPointInRoot(GetLastMouseLocationInRoot())) {
-    PostSynthesizeMouseMove();
+    PostSynthesizeMouseMove(ui::EF_NONE);
   }
 }
 
-ui::EventDispatchDetails WindowEventDispatcher::SynthesizeMouseMoveEvent() {
+ui::EventDispatchDetails WindowEventDispatcher::SynthesizeMouseMoveEvent(
+    int mouse_button_flags) {
   DispatchDetails details;
   if (!synthesize_mouse_move_)
     return details;
   synthesize_mouse_move_ = false;
   gfx::Point root_mouse_location = GetLastMouseLocationInRoot();
   if (!window()->bounds().Contains(root_mouse_location))
     return details;
   gfx::Point host_mouse_location = root_mouse_location;
   host_->ConvertPointToHost(&host_mouse_location);
-  ui::MouseEvent event(ui::ET_MOUSE_MOVED,
-                       host_mouse_location,
-                       host_mouse_location,
-                       ui::EF_IS_SYNTHESIZED,
-                       0);
+  ui::MouseEvent event(
+      mouse_button_flags ? ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED,
+      host_mouse_location,
+      host_mouse_location,
+      ui::EF_IS_SYNTHESIZED | mouse_button_flags,
+      0);
   return OnEventFromSource(&event);
 }
 
 void WindowEventDispatcher::PreDispatchLocatedEvent(Window* target,
                                                     ui::LocatedEvent* event) {
   int flags = event->flags();
   if (IsNonClientLocation(target, event->location()))
     flags |= ui::EF_IS_NON_CLIENT;
   event->set_flags(flags);
 
@@ skipping 137 matching lines @@
       break;
 
     default:
       NOTREACHED();
       break;
   }
   PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura