x11: Clean up XEvent construction code for tests.

There were subtle differences between the event construction code
for various types. So put them all in one place to avoid confusion.
The main changes in this patch are in events_x_utils, where various
Init*EventForTest() functions get replaced by corresponding
ScopedXI2Event::Init*Event() methods. This makes it easier to manage
the lifetime of the created events.

BUG=none
R=jochen@chromium.org, sky@chromium.org

Review URL: https://codereview.chromium.org/82763010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@237199 0039d316-1c4b-4281-b951-d872f2087c98

ash/accelerators/accelerator_controller_unittest.cc

@@ -665,24 +665,18 @@ TEST_F(AcceleratorControllerTest, MAYBE_ProcessOnce) {
   EXPECT_FALSE(dispatcher->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &key_event3));
 #elif defined(USE_X11)
-  XEvent key_event;
-  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                              ui::VKEY_A,
-                              0,
-                              &key_event);
-  ui::TranslatedKeyEvent key_event1(&key_event, false);
+  ui::ScopedXI2Event key_event;
+  key_event.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
+  ui::TranslatedKeyEvent key_event1(key_event, false);
   EXPECT_TRUE(dispatcher->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &key_event1));
 
-  ui::TranslatedKeyEvent key_event2(&key_event, true);
+  ui::TranslatedKeyEvent key_event2(key_event, true);
   EXPECT_FALSE(dispatcher->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &key_event2));
 
-  ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
-                              ui::VKEY_A,
-                              0,
-                              &key_event);
-  ui::TranslatedKeyEvent key_event3(&key_event, false);
+  key_event.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_A, 0);
+  ui::TranslatedKeyEvent key_event3(key_event, false);
   EXPECT_FALSE(dispatcher->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &key_event3));
 #endif

ash/accelerators/nested_dispatcher_controller_unittest.cc

@@ -84,19 +84,13 @@ void DispatchKeyReleaseA() {
   MSG native_event_up = { NULL, WM_KEYUP, ui::VKEY_A, 0 };
   ash::Shell::GetPrimaryRootWindow()->host()->PostNativeEvent(native_event_up);
 #elif defined(USE_X11)
-  XEvent native_event;
-  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                              ui::VKEY_A,
-                              0,
-                              &native_event);
+  ui::ScopedXI2Event native_event;
+  native_event.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
   aura::WindowEventDispatcher* dispatcher =
       ash::Shell::GetPrimaryRootWindow()->GetDispatcher();
-  dispatcher->host()->PostNativeEvent(&native_event);
-  ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
-                              ui::VKEY_A,
-                              0,
-                              &native_event);
-  dispatcher->host()->PostNativeEvent(&native_event);
+  dispatcher->host()->PostNativeEvent(native_event);
+  native_event.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_A, 0);
+  dispatcher->host()->PostNativeEvent(native_event);
 #endif
 
   // Send noop event to signal dispatcher to exit.

ash/wm/sticky_keys_unittest.cc

@@ -161,57 +161,43 @@ class StickyKeysTest : public test::AshTestBase,
     }
   }
 
-  // Generates keyboard event.
   ui::KeyEvent* GenerateKey(bool is_key_press, ui::KeyboardCode code) {
-    XEvent* xev = new XEvent();
-    ui::InitXKeyEventForTesting(
+    scoped_xevent_.InitKeyEvent(
         is_key_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
         code,
-        0,
-        xev);
-    xevs_.push_back(xev);
-    ui::KeyEvent* event =  new ui::KeyEvent(xev, false);
+        0);
+    ui::KeyEvent* event =  new ui::KeyEvent(scoped_xevent_, false);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::MouseEvent* GenerateMouseEvent(bool is_button_press) {
-    XEvent* xev = new XEvent();
-    ui::InitXButtonEventForTesting(
-        is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED,
-        0,
-        xev);
-    xevs_.push_back(xev);
-    ui::MouseEvent* event = new ui::MouseEvent(xev);
+    scoped_xevent_.InitButtonEvent(
+        is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED, 0);
+    ui::MouseEvent* event = new ui::MouseEvent(scoped_xevent_);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::MouseWheelEvent* GenerateMouseWheelEvent(int wheel_delta) {
-    EXPECT_FALSE(wheel_delta == 0);
-    XEvent* xev = new XEvent();
-    ui::InitXMouseWheelEventForTesting(wheel_delta, 0, xev);
-    xevs_.push_back(xev);
-    ui::MouseWheelEvent* event = new ui::MouseWheelEvent(xev);
+    EXPECT_NE(0, wheel_delta);
+    scoped_xevent_.InitMouseWheelEvent(wheel_delta, 0);
+    ui::MouseWheelEvent* event = new ui::MouseWheelEvent(scoped_xevent_);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::ScrollEvent* GenerateScrollEvent(int scroll_delta) {
-    EXPECT_FALSE(scroll_delta == 0);
-    XEvent* xev = ui::CreateScrollEventForTest(
-        kScrollDeviceId, // deviceid
-        0,               // x_offset
-        scroll_delta,    // y_offset
-        0,               // x_offset_ordinal
-        scroll_delta,    // y_offset_ordinal
-        2);              // finger_count
-    xi2_evs_.push_back(new ui::ScopedXI2Event(xev));
-
-    ui::ScrollEvent* event = new ui::ScrollEvent(xev);
+    scoped_xevent_.InitScrollEvent(kScrollDeviceId, // deviceid
+                                   0,               // x_offset
+                                   scroll_delta,    // y_offset
+                                   0,               // x_offset_ordinal
+                                   scroll_delta,    // y_offset_ordinal
+                                   2);              // finger_count
+    ui::ScrollEvent* event = new ui::ScrollEvent(scoped_xevent_);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
@@ -265,12 +251,9 @@ class StickyKeysTest : public test::AshTestBase,
   aura::Window* target_;
   // The root window of |target_|. Not owned.
   aura::Window* root_window_;
-  // Stores all generated XEvents.
-  ScopedVector<XEvent> xevs_;
 
-  // Stores all generated XInput2 XEvents. We use a scoped wrapper class here
-  // to properly delete these events.
-  ScopedVector<ui::ScopedXI2Event> xi2_evs_;
+  // Used to construct the various X events.
+  ui::ScopedXI2Event scoped_xevent_;
 
   DISALLOW_COPY_AND_ASSIGN(StickyKeysTest);
 };

chrome/browser/chromeos/keyboard_driven_event_rewriter_unittest.cc

@@ -16,22 +16,6 @@
 
 namespace chromeos {
 
-// Creates an XKeyEvent to initialize a ui::KeyEvent that is passed to
-// KeyboardDrivenEventRewriter for processing.
-void InitXKeyEvent(ui::KeyboardCode ui_keycode,
-                   int ui_flags,
-                   ui::EventType ui_type,
-                   KeyCode x_keycode,
-                   unsigned int x_state,
-                   XEvent* event) {
-  ui::InitXKeyEventForTesting(ui_type,
-                              ui_keycode,
-                              ui_flags,
-                              event);
-  event->xkey.keycode = x_keycode;
-  event->xkey.state = x_state;
-}
-
 class KeyboardDrivenEventRewriterTest : public testing::Test {
  public:
   KeyboardDrivenEventRewriterTest()
@@ -53,13 +37,16 @@ class KeyboardDrivenEventRewriterTest : public testing::Test {
                                         ui::EventType ui_type,
                                         KeyCode x_keycode,
                                         unsigned int x_state) {
-    XEvent xev;
-    InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
-    ui::KeyEvent keyevent(&xev, false /* is_char */);
+    ui::ScopedXI2Event xev;
+    xev.InitKeyEvent(ui_type, ui_keycode, ui_flags);
+    XEvent* xevent = xev;
+    xevent->xkey.keycode = x_keycode;
+    xevent->xkey.state = x_state;
+    ui::KeyEvent keyevent(xev, false /* is_char */);
     bool changed = rewriter_.RewriteForTesting(&keyevent);
     return base::StringPrintf("ui_flags=%d x_state=%u changed=%d",
                               keyevent.flags(),
-                              xev.xkey.state,
+                              xevent->xkey.state,
                               changed);
   }
 

chrome/browser/ui/ash/event_rewriter_unittest.cc

@@ -33,34 +33,23 @@
 
 namespace {
 
-void InitXKeyEvent(ui::KeyboardCode ui_keycode,
-                   int ui_flags,
-                   ui::EventType ui_type,
-                   KeyCode x_keycode,
-                   unsigned int x_state,
-                   XEvent* event) {
-  ui::InitXKeyEventForTesting(ui_type,
-                              ui_keycode,
-                              ui_flags,
-                              event);
-  event->xkey.keycode = x_keycode;
-  event->xkey.state = x_state;
-}
-
 std::string GetRewrittenEventAsString(EventRewriter* rewriter,
                                       ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type,
                                       KeyCode x_keycode,
                                       unsigned int x_state) {
-  XEvent xev;
-  InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
-  ui::KeyEvent keyevent(&xev, false /* is_char */);
+  ui::ScopedXI2Event xev;
+  xev.InitKeyEvent(ui_type, ui_keycode, ui_flags);
+  XEvent* xevent = xev;
+  xevent->xkey.keycode = x_keycode;
+  xevent->xkey.state = x_state;
+  ui::KeyEvent keyevent(xev, false /* is_char */);
   rewriter->RewriteForTesting(&keyevent);
   return base::StringPrintf(
       "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
       keyevent.key_code(), keyevent.flags(), keyevent.type(),
-      xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
+      xevent->xkey.keycode, xevent->xkey.state, xevent->xkey.type);
 }
 
 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
@@ -2305,17 +2294,18 @@ TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
   // Send left control press.
   std::string rewritten_event;
   {
-    XEvent xev;
-    InitXKeyEvent(ui::VKEY_CONTROL, 0, ui::ET_KEY_PRESSED,
-                  keycode_control_l_, 0U, &xev);
-    xev.xkey.send_event = True;  // XSendEvent() always does this.
-    ui::KeyEvent keyevent(&xev, false /* is_char */);
+    ui::ScopedXI2Event xev;
+    xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
+    XEvent* xevent = xev;
+    xevent->xkey.keycode = keycode_control_l_;
+    xevent->xkey.send_event = True;  // XSendEvent() always does this.
+    ui::KeyEvent keyevent(xev, false /* is_char */);
     rewriter.RewriteForTesting(&keyevent);
     rewritten_event = base::StringPrintf(
         "ui_keycode=%d ui_flags=%d ui_type=%d "
         "x_keycode=%u x_state=%u x_type=%d",
         keyevent.key_code(), keyevent.flags(), keyevent.type(),
-        xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
+        xevent->xkey.keycode, xevent->xkey.state, xevent->xkey.type);
   }
 
   // XK_Control_L (left Control key) should NOT be remapped to Alt if send_event
@@ -2357,10 +2347,12 @@ TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
   window_state->Activate();
 
   // Create a simulated keypress of F1 targetted at the window.
-  XEvent xev_f1;
+  ui::ScopedXI2Event xev_f1;
   KeyCode keycode_f1 = XKeysymToKeycode(gfx::GetXDisplay(), XK_F1);
-  InitXKeyEvent(ui::VKEY_F1, 0, ui::ET_KEY_PRESSED, keycode_f1, 0u, &xev_f1);
-  ui::KeyEvent press_f1(&xev_f1, false);
+  xev_f1.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_F1, 0);
+  XEvent* xevent = xev_f1;
+  xevent->xkey.keycode = keycode_f1;
+  ui::KeyEvent press_f1(xev_f1, false);
   ui::Event::DispatcherApi dispatch_helper(&press_f1);
   dispatch_helper.set_target(window.get());
 

chrome/browser/ui/views/constrained_window_views_browsertest.cc

@@ -365,10 +365,9 @@ void ForwardKeyEvent(content::RenderViewHost* host, ui::KeyboardCode key_code) {
 #if defined(OS_WIN)
   MSG native_key_event = { NULL, WM_KEYDOWN, key_code, 0 };
 #elif defined(USE_X11)
-  XEvent x_event;
-  ui::InitXKeyEventForTesting(
-      ui::ET_KEY_PRESSED, key_code, ui::EF_NONE, &x_event);
-  XEvent* native_key_event = &x_event;
+  ui::ScopedXI2Event x_event;
+  x_event.InitKeyEvent(ui::ET_KEY_PRESSED, key_code, ui::EF_NONE);
+  XEvent* native_key_event = x_event;
 #endif
 
 #if defined(USE_AURA)

content/browser/renderer_host/web_input_event_aura_unittest.cc

@@ -21,25 +21,19 @@ namespace content {
 // crbug.com/127142
 TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) {
 #if defined(USE_X11)
-  XEvent xev;
+  ui::ScopedXI2Event xev;
   {
     // Press Ctrl.
-    ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                                ui::VKEY_CONTROL,
-                                0,  // X does not set ControlMask for KeyPress.
-                                &xev);
-    ui::KeyEvent event(&xev, false /* is_char */);
+    xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
+    ui::KeyEvent event(xev, false /* is_char */);
     blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event);
     // However, modifier bit for Control in |webkit_event| should be set.
     EXPECT_EQ(webkit_event.modifiers, blink::WebInputEvent::ControlKey);
   }
   {
     // Release Ctrl.
-    ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
-                                ui::VKEY_CONTROL,
-                                ControlMask,  // X sets the mask for KeyRelease.
-                                &xev);
-    ui::KeyEvent event(&xev, false /* is_char */);
+    xev.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, ControlMask);
+    ui::KeyEvent event(xev, false /* is_char */);
     blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event);
     // However, modifier bit for Control in |webkit_event| shouldn't be set.
     EXPECT_EQ(webkit_event.modifiers, 0);
@@ -50,27 +44,23 @@ TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) {
 // Checks that MakeWebKeyboardEvent returns a correct windowsKeyCode.
 TEST(WebInputEventAuraTest, TestMakeWebKeyboardEventWindowsKeyCode) {
 #if defined(USE_X11)
-  XEvent xev;
+  ui::ScopedXI2Event xev;
   {
     // Press left Ctrl.
-    ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                                ui::VKEY_CONTROL,
-                                0,  // X does not set ControlMask for KeyPress.
-                                &xev);
-    xev.xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
-    ui::KeyEvent event(&xev, false /* is_char */);
+    xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
+    XEvent* xevent = xev;
+    xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
+    ui::KeyEvent event(xev, false /* is_char */);
     blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event);
     // ui::VKEY_LCONTROL, instead of ui::VKEY_CONTROL, should be filled.
     EXPECT_EQ(ui::VKEY_LCONTROL, webkit_event.windowsKeyCode);
   }
   {
     // Press right Ctrl.
-    ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                                ui::VKEY_CONTROL,
-                                0,  // X does not set ControlMask for KeyPress.
-                                &xev);
-    xev.xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_R);
-    ui::KeyEvent event(&xev, false /* is_char */);
+    xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
+    XEvent* xevent = xev;
+    xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_R);
+    ui::KeyEvent event(xev, false /* is_char */);
     blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event);
     // ui::VKEY_RCONTROL, instead of ui::VKEY_CONTROL, should be filled.
     EXPECT_EQ(ui::VKEY_RCONTROL, webkit_event.windowsKeyCode);

content/renderer/render_view_browsertest.cc

@@ -194,30 +194,25 @@ class RenderViewImplTest : public RenderViewTest {
     CHECK(output);
     const int flags = ConvertMockKeyboardModifier(modifiers);
 
-    XEvent xevent1;
-    InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                            static_cast<ui::KeyboardCode>(key_code),
-                            flags,
-                            &xevent1);
-    ui::KeyEvent event1(&xevent1, false);
+    ui::ScopedXI2Event xevent;
+    xevent.InitKeyEvent(ui::ET_KEY_PRESSED,
+                        static_cast<ui::KeyboardCode>(key_code),
+                        flags);
+    ui::KeyEvent event1(xevent, false);
     NativeWebKeyboardEvent keydown_event(&event1);
     SendNativeKeyEvent(keydown_event);
 
-    XEvent xevent2;
-    InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
-                            static_cast<ui::KeyboardCode>(key_code),
-                            flags,
-                            &xevent2);
-    ui::KeyEvent event2(&xevent2, true);
+    xevent.InitKeyEvent(ui::ET_KEY_PRESSED,
+                        static_cast<ui::KeyboardCode>(key_code),
+                        flags);
+    ui::KeyEvent event2(xevent, true);
     NativeWebKeyboardEvent char_event(&event2);
     SendNativeKeyEvent(char_event);
 
-    XEvent xevent3;
-    InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
-                            static_cast<ui::KeyboardCode>(key_code),
-                            flags,
-                            &xevent3);
-    ui::KeyEvent event3(&xevent3, false);
+    xevent.InitKeyEvent(ui::ET_KEY_RELEASED,
+                        static_cast<ui::KeyboardCode>(key_code),
+                        flags);
+    ui::KeyEvent event3(xevent, false);
     NativeWebKeyboardEvent keyup_event(&event3);
     SendNativeKeyEvent(keyup_event);