Fix sticky keys crash when handling synthetic events without a native event.

ash/sticky_keys/sticky_keys_unittest.cc

 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h"
 
 #include <X11/Xlib.h>
 #undef None
 #undef Bool
 #undef RootWindow
@@ skipping 227 matching lines @@
       bool is_key_press, ui::KeyboardCode code) {
     ui::KeyEvent* event = new ui::KeyEvent(
         is_key_press ? ui::ET_KEY_PRESSED : ui::ET_MOUSE_RELEASED,
         code, 0, true);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   // Creates a synthesized MouseEvent that is not backed by a native event.
-  ui::MouseEvent* GenerateSynthesizedMouseEvent(bool is_button_press) {
-    ui::MouseEvent* event = new ui::MouseEvent(
-        is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED,
-        gfx::Point(0, 0),
-        gfx::Point(0, 0),
-        ui::EF_LEFT_MOUSE_BUTTON,
-        ui::EF_LEFT_MOUSE_BUTTON);
+  ui::MouseEvent* GenerateSynthesizedMouseEventAt(ui::EventType event_type,
+                                                  const gfx::Point& location) {
+    ui::MouseEvent* event = new ui::MouseEvent(event_type,
+                                               location,
+                                               location,
+                                               ui::EF_LEFT_MOUSE_BUTTON,
+                                               ui::EF_LEFT_MOUSE_BUTTON);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
+  // Creates a synthesized mouse press or release event.
+  ui::MouseEvent* GenerateSynthesizedMouseClickEvent(
+      bool is_button_press,
+      const gfx::Point& location) {
+    return GenerateSynthesizedMouseEventAt(
+        is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED,
+        location);
+  }
+
   // Creates a synthesized ET_MOUSE_MOVED event.
-  ui::MouseEvent* GenerateSynthesizedMouseEvent(int x, int y) {
-    ui::MouseEvent* event = new ui::MouseEvent(
-        ui::ET_MOUSE_MOVED,
-        gfx::Point(x, y),
-        gfx::Point(x, y),
-        ui::EF_LEFT_MOUSE_BUTTON,
-        ui::EF_LEFT_MOUSE_BUTTON);
+  ui::MouseEvent* GenerateSynthesizedMouseMoveEvent(
+      const gfx::Point& location) {
+    return GenerateSynthesizedMouseEventAt(ui::ET_MOUSE_MOVED, location);
+  }
+
+  // Creates a synthesized MouseWHeel event.
+  ui::MouseWheelEvent* GenerateSynthesizedMouseWheelEvent(int wheel_delta) {
+    scoped_ptr<ui::MouseEvent> mev(
+        GenerateSynthesizedMouseEventAt(ui::ET_MOUSEWHEEL, gfx::Point(0, 0)));
+    ui::MouseWheelEvent* event = new ui::MouseWheelEvent(*mev, 0, wheel_delta);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   void SendActivateStickyKeyPattern(StickyKeysHandler* handler,
                                     ui::KeyboardCode key_code) {
     scoped_ptr<ui::KeyEvent> ev;
     ev.reset(GenerateKey(true, key_code));
     handler->HandleKeyEvent(ev.get());
@@ skipping 206 matching lines @@
   scoped_ptr<ui::MouseEvent> mev;
   MockStickyKeysHandlerDelegate* mock_delegate =
       new MockStickyKeysHandlerDelegate(this);
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate);
 
   EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Press ctrl and handle mouse move events.
   kev.reset(GenerateKey(true, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
-  mev.reset(GenerateSynthesizedMouseEvent(0, 0));
+  mev.reset(GenerateSynthesizedMouseMoveEvent(gfx::Point(0, 0)));
   sticky_key.HandleMouseEvent(mev.get());
-  mev.reset(GenerateSynthesizedMouseEvent(100, 100));
+  mev.reset(GenerateSynthesizedMouseMoveEvent(gfx::Point(100, 100)));
   sticky_key.HandleMouseEvent(mev.get());
 
   // Sticky keys should be enabled afterwards.
   kev.reset(GenerateKey(false, ui::VKEY_CONTROL));
   sticky_key.HandleKeyEvent(kev.get());
   EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, NormalModifiedScrollTest) {
   scoped_ptr<ui::KeyEvent> kev;
@@ skipping 275 matching lines @@
   kev.reset(GenerateSynthesizedKeyEvent(false, ui::VKEY_K));
   sticky_key.HandleKeyEvent(kev.get());
   EXPECT_FALSE(kev->flags() & ui::EF_CONTROL_DOWN);
   EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
   // Test non-native mouse events.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
   EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
   scoped_ptr<ui::MouseEvent> mev;
-  mev.reset(GenerateSynthesizedMouseEvent(true));
+  mev.reset(GenerateSynthesizedMouseClickEvent(true, gfx::Point(0, 0)));
   sticky_key.HandleMouseEvent(mev.get());
   EXPECT_TRUE(mev->flags() & ui::EF_CONTROL_DOWN);
   EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
-  mev.reset(GenerateSynthesizedMouseEvent(false));
+  mev.reset(GenerateSynthesizedMouseClickEvent(false, gfx::Point(0, 0)));
   sticky_key.HandleMouseEvent(mev.get());
   EXPECT_TRUE(mev->flags() & ui::EF_CONTROL_DOWN);
   EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 TEST_F(StickyKeysTest, KeyEventDispatchImpl) {
   // Test the actual key event dispatch implementation.
   EventBuffer buffer;
   ScopedVector<ui::Event> events;
   ui::EventProcessor* dispatcher =
@@ skipping 22 matching lines @@
   ev.reset(GenerateKey(false, ui::VKEY_C));
   details = dispatcher->OnEventFromSource(ev.get());
   ASSERT_FALSE(details.dispatcher_destroyed);
   buffer.PopEvents(&events);
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(ui::ET_KEY_RELEASED, events[0]->type());
   EXPECT_EQ(ui::VKEY_C,
             static_cast<ui::KeyEvent*>(events[0])->key_code());
   EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);
 
+  // Test that synthesized key events are dispatched correctly.
+  SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL);
+  buffer.PopEvents(&events);
+  scoped_ptr<ui::KeyEvent> kev;
+  kev.reset(GenerateSynthesizedKeyEvent(true, ui::VKEY_K));
+  details = dispatcher->OnEventFromSource(kev.get());
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  buffer.PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
+  EXPECT_EQ(ui::VKEY_K, static_cast<ui::KeyEvent*>(events[0])->key_code());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+
   Shell::GetInstance()->RemovePreTargetHandler(&buffer);
 }
 
 class StickyKeysMouseDispatchTest
     : public StickyKeysTest,
       public ::testing::WithParamInterface<int> {
 };
 
 TEST_P(StickyKeysMouseDispatchTest, MouseEventDispatchImpl) {
   int scale_factor = GetParam();
@@ skipping 33 matching lines @@
   buffer.PopEvents(&events);
   EXPECT_EQ(2u, events.size());
   EXPECT_EQ(ui::ET_MOUSE_RELEASED, events[0]->type());
   EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
   EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
   EXPECT_EQ(dip_location.ToString(),
             static_cast<ui::MouseEvent*>(events[0])->location().ToString());
   EXPECT_EQ(ui::VKEY_CONTROL,
             static_cast<ui::KeyEvent*>(events[1])->key_code());
 
+  // Test synthesized mouse events are dispatched correctly.
+  SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL);
+  buffer.PopEvents(&events);
+  ev.reset(GenerateSynthesizedMouseClickEvent(false, physical_location));
+  details = dispatcher->OnEventFromSource(ev.get());
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  buffer.PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_EQ(ui::ET_MOUSE_RELEASED, events[0]->type());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(dip_location.ToString(),
+            static_cast<ui::MouseEvent*>(events[0])->location().ToString());
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+
   Shell::GetInstance()->RemovePreTargetHandler(&buffer);
 }
 
 TEST_P(StickyKeysMouseDispatchTest, MouseWheelEventDispatchImpl) {
   int scale_factor = GetParam();
   std::ostringstream display_specs;
   display_specs << "1280x1024*" << scale_factor;
   UpdateDisplay(display_specs.str());
 
   // Test the actual mouse wheel event dispatch implementation.
@@ skipping 34 matching lines @@
   buffer.PopEvents(&events);
   EXPECT_EQ(2u, events.size());
   EXPECT_TRUE(events[0]->IsMouseWheelEvent());
   EXPECT_EQ(-ui::MouseWheelEvent::kWheelDelta / scale_factor,
             static_cast<ui::MouseWheelEvent*>(events[0])->y_offset());
   EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
   EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
   EXPECT_EQ(ui::VKEY_CONTROL,
             static_cast<ui::KeyEvent*>(events[1])->key_code());
 
+  // Test synthesized mouse wheel events are dispatched correctly.
+  SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL);
+  buffer.PopEvents(&events);
+  ev.reset(
+      GenerateSynthesizedMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta));
+  details = dispatcher->OnEventFromSource(ev.get());
+  ASSERT_FALSE(details.dispatcher_destroyed);
+  buffer.PopEvents(&events);
+  EXPECT_EQ(2u, events.size());
+  EXPECT_TRUE(events[0]->IsMouseWheelEvent());
+  EXPECT_EQ(ui::MouseWheelEvent::kWheelDelta / scale_factor,
+            static_cast<ui::MouseWheelEvent*>(events[0])->y_offset());
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
+  EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
+  EXPECT_EQ(ui::VKEY_CONTROL,
+            static_cast<ui::KeyEvent*>(events[1])->key_code());
+
   Shell::GetInstance()->RemovePreTargetHandler(&buffer);
 }
 
 INSTANTIATE_TEST_CASE_P(DPIScaleFactors,
                         StickyKeysMouseDispatchTest,
                         ::testing::Values(1, 2));
 
 }  // namespace ash