Revert of 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* 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::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::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* 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::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::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(GenerateSynthesizedMouseMoveEvent(gfx::Point(0, 0)));
+  mev.reset(GenerateSynthesizedMouseEvent(0, 0));
   sticky_key.HandleMouseEvent(mev.get());
-  mev.reset(GenerateSynthesizedMouseMoveEvent(gfx::Point(100, 100)));
+  mev.reset(GenerateSynthesizedMouseEvent(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(GenerateSynthesizedMouseClickEvent(true, gfx::Point(0, 0)));
+  mev.reset(GenerateSynthesizedMouseEvent(true));
   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(GenerateSynthesizedMouseClickEvent(false, gfx::Point(0, 0)));
+  mev.reset(GenerateSynthesizedMouseEvent(false));
   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));
-  dispatcher->OnEventFromSource(kev.get());
-  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));
-  dispatcher->OnEventFromSource(ev.get());
-  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));
-  dispatcher->OnEventFromSource(ev.get());
-  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