Fix behavior of WindowEventDispatcher::SynthesizeMouseMoveEvent().

ui/aura/window_event_dispatcher_unittest.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/aura/window_event_dispatcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 413 matching lines @@
   EXPECT_EQ(2, filter->num_scroll_events());
 }
 
 namespace {
 
 // FilterFilter that tracks the types of events it's seen.
 class EventFilterRecorder : public ui::EventHandler {
  public:
   typedef std::vector<ui::EventType> Events;
   typedef std::vector<gfx::Point> EventLocations;
+  typedef std::vector<int> EventFlags;
 
   EventFilterRecorder()
       : wait_until_event_(ui::ET_UNKNOWN) {
   }
 
   const Events& events() const { return events_; }
 
   const EventLocations& mouse_locations() const { return mouse_locations_; }
   gfx::Point mouse_location(int i) const { return mouse_locations_[i]; }
   const EventLocations& touch_locations() const { return touch_locations_; }
+  const EventFlags& mouse_event_flags() const { return mouse_event_flags_; }
 
   void WaitUntilReceivedEvent(ui::EventType type) {
     wait_until_event_ = type;
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
   Events GetAndResetEvents() {
     Events events = events_;
     Reset();
     return events;
   }
 
   void Reset() {
     events_.clear();
     mouse_locations_.clear();
     touch_locations_.clear();
+    mouse_event_flags_.clear();
   }
 
   // ui::EventHandler overrides:
   virtual void OnEvent(ui::Event* event) OVERRIDE {
     ui::EventHandler::OnEvent(event);
     events_.push_back(event->type());
     if (wait_until_event_ == event->type() && run_loop_) {
       run_loop_->Quit();
       wait_until_event_ = ui::ET_UNKNOWN;
     }
   }
 
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     mouse_locations_.push_back(event->location());
+    mouse_event_flags_.push_back(event->flags());
   }
 
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     touch_locations_.push_back(event->location());
   }
 
  private:
   scoped_ptr<base::RunLoop> run_loop_;
   ui::EventType wait_until_event_;
 
   Events events_;
   EventLocations mouse_locations_;
   EventLocations touch_locations_;
+  EventFlags mouse_event_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(EventFilterRecorder);
 };
 
 // Converts an EventType to a string.
 std::string EventTypeToString(ui::EventType type) {
   switch (type) {
     case ui::ET_TOUCH_RELEASED:
       return "TOUCH_RELEASED";
 
@@ skipping 334 matching lines @@
   DispatchEventUsingWindowDispatcher(&mouse2);
   EXPECT_FALSE(filter->events().empty());
   filter->Reset();
 
   // Dispatch a synthetic mouse event when mouse events are disabled.
   cursor_client.DisableMouseEvents();
   DispatchEventUsingWindowDispatcher(&mouse2);
   EXPECT_TRUE(filter->events().empty());
 }
 
+// Tests synthetic mouse events generated when window bounds changes such that
+// the cursor previously outside the window becomes inside, or vice versa.
+// - Synthesize MOVED events when the mouse button is up;
+// - Synthesize DRAGGED events with correct flags when mouse button is down;
+// - Do not synthesize events if the window ignores events or is invisible.
+TEST_F(WindowEventDispatcherTest, SynthesizeMouseEventsOnWindowBoundsChanged) {
+  test::TestWindowDelegate delegate;
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      &delegate, 1234, gfx::Rect(5, 5, 100, 100), root_window()));
+  window->Show();
+  window->SetCapture();
+
+  EventFilterRecorder* filter = new EventFilterRecorder;
+  window->SetEventFilter(filter);  // passes ownership
+
+  // Dispatch a non-synthetic mouse event to place cursor inside window bounds.
+  ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(10, 10),
+                       gfx::Point(10, 10), 0, 0);
+  DispatchEventUsingWindowDispatcher(&mouse);
+  EXPECT_FALSE(filter->events().empty());
+  filter->Reset();
+
+  // Update the window bounds so that cursor is now outside the window.
+  // This should trigger a synthetic MOVED event.
+  gfx::Rect bounds1(20, 20, 100, 100);
+  window->SetBounds(bounds1);
+  RunAllPendingInMessageLoop();
+  ASSERT_FALSE(filter->events().empty());
+  ASSERT_FALSE(filter->mouse_event_flags().empty());
+  EXPECT_EQ(ui::ET_MOUSE_MOVED, filter->events().back());
+  EXPECT_EQ(ui::EF_IS_SYNTHESIZED, filter->mouse_event_flags().back());
+  filter->Reset();
+
+  // Hold down the LEFT mouse button.
+  Env::GetInstance()->set_mouse_button_flags(ui::EF_LEFT_MOUSE_BUTTON);
+
+  // Update the window bounds so that cursor is back inside the window.
+  // This should trigger a synthetic DRAGGED event with the left button flag.
+  gfx::Rect bounds2(5, 5, 100, 100);
+  window->SetBounds(bounds2);
+  RunAllPendingInMessageLoop();
+  ASSERT_FALSE(filter->events().empty());
+  ASSERT_FALSE(filter->mouse_event_flags().empty());
+  EXPECT_EQ(ui::ET_MOUSE_DRAGGED, filter->events().back());
+  EXPECT_EQ(ui::EF_IS_SYNTHESIZED | ui::EF_LEFT_MOUSE_BUTTON,
+            filter->mouse_event_flags().back());
+  filter->Reset();
+
+  // Hold down the RIGHT mouse button.
+  Env::GetInstance()->set_mouse_button_flags(ui::EF_RIGHT_MOUSE_BUTTON);
+
+  // Update the window bounds so that cursor is outside the window.
+  // This should trigger a synthetic DRAGGED event with the right button flag.
+  window->SetBounds(bounds1);
+  RunAllPendingInMessageLoop();
+  ASSERT_FALSE(filter->events().empty());
+  ASSERT_FALSE(filter->mouse_event_flags().empty());
+  EXPECT_EQ(ui::ET_MOUSE_DRAGGED, filter->events().back());
+  EXPECT_EQ(ui::EF_IS_SYNTHESIZED | ui::EF_RIGHT_MOUSE_BUTTON,
+            filter->mouse_event_flags().back());
+  filter->Reset();
+
+  // Release mouse button and set window to ignore events.
+  Env::GetInstance()->set_mouse_button_flags(0);
+  window->set_ignore_events(true);
+
+  // Update the window bounds so that cursor is back inside the window.
+  // This should not trigger a synthetic event.
+  window->SetBounds(bounds2);
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(filter->events().empty());
+  filter->Reset();
+
+  // Set window to accept events but invisible.
+  window->set_ignore_events(false);
+  window->Hide();
+  filter->Reset();
+
+  // Update the window bounds so that cursor is outside the window.
+  // This should not trigger a synthetic event.
+  window->SetBounds(bounds1);
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(filter->events().empty());
+}
+
 // Tests that a mouse exit is dispatched to the last known cursor location
 // when the cursor becomes invisible.
 TEST_F(WindowEventDispatcherTest, DispatchMouseExitWhenCursorHidden) {
   EventFilterRecorder* filter = new EventFilterRecorder;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   test::TestWindowDelegate delegate;
   gfx::Point window_origin(7, 18);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1234, gfx::Rect(window_origin, gfx::Size(100, 100)),
@@ skipping 1175 matching lines @@
   delegate.GetMouseMotionCountsAndReset();
 
   // Notify both hosts that the cursor is now hidden. This should send a single
   // mouse-exit event to |window|.
   host()->OnCursorVisibilityChanged(false);
   second_host->OnCursorVisibilityChanged(false);
   EXPECT_EQ("0 0 1", delegate.GetMouseMotionCountsAndReset());
 }
 
 }  // namespace aura