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

14 files changed, 326 insertions, 436 deletions

diff --git a/ash/accelerators/accelerator_controller_unittest.cc b/ash/accelerators/accelerator_controller_unittest.cc
index 37ab713..ce3476b 100644
--- a/ash/accelerators/accelerator_controller_unittest.cc
+++ b/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
diff --git a/ash/accelerators/nested_dispatcher_controller_unittest.cc b/ash/accelerators/nested_dispatcher_controller_unittest.cc
index 56440ee..445c29c 100644
--- a/ash/accelerators/nested_dispatcher_controller_unittest.cc
+++ b/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.
diff --git a/ash/wm/sticky_keys_unittest.cc b/ash/wm/sticky_keys_unittest.cc
index e05b05e..e8e8975 100644
--- a/ash/wm/sticky_keys_unittest.cc
+++ b/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);
 };
diff --git a/chrome/browser/chromeos/keyboard_driven_event_rewriter_unittest.cc b/chrome/browser/chromeos/keyboard_driven_event_rewriter_unittest.cc
index 657c34e..151bbab 100644
--- a/chrome/browser/chromeos/keyboard_driven_event_rewriter_unittest.cc
+++ b/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);
   }
 
diff --git a/chrome/browser/ui/ash/event_rewriter_unittest.cc b/chrome/browser/ui/ash/event_rewriter_unittest.cc
index 304a9b7..34895b7 100644
--- a/chrome/browser/ui/ash/event_rewriter_unittest.cc
+++ b/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());
 
diff --git a/chrome/browser/ui/views/constrained_window_views_browsertest.cc b/chrome/browser/ui/views/constrained_window_views_browsertest.cc
index 1db6b6e..afc26a4 100644
--- a/chrome/browser/ui/views/constrained_window_views_browsertest.cc
+++ b/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)
diff --git a/content/browser/renderer_host/web_input_event_aura_unittest.cc b/content/browser/renderer_host/web_input_event_aura_unittest.cc
index 9154cfb..d67d0cd 100644
--- a/content/browser/renderer_host/web_input_event_aura_unittest.cc
+++ b/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);
diff --git a/content/renderer/render_view_browsertest.cc b/content/renderer/render_view_browsertest.cc
index 950ee35..40a99ee 100644
--- a/content/renderer/render_view_browsertest.cc
+++ b/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);
 
diff --git a/ui/aura/root_window_host_x11_unittest.cc b/ui/aura/root_window_host_x11_unittest.cc
index 36b6976..871ca68 100644
--- a/ui/aura/root_window_host_x11_unittest.cc
+++ b/ui/aura/root_window_host_x11_unittest.cc
@@ -116,34 +116,35 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToOneRootWindow) {
   EXPECT_EQ(ui::ET_UNKNOWN, delegate->last_touch_type());
   EXPECT_EQ(-1, delegate->last_touch_id());
 
+  ui::ScopedXI2Event scoped_xevent;
 #if defined(OS_CHROMEOS)
   // This touch is out of bounds.
-  ui::ScopedXI2Event event1(ui::CreateTouchEventForTest(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators));
-  root_window_host->Dispatch(event1);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators);
+  root_window_host->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate->last_touch_type());
   EXPECT_EQ(-1, delegate->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate->last_touch_location());
 #endif  // defined(OS_CHROMEOS)
 
   // Following touchs are within bounds and are passed to delegate.
-  ui::ScopedXI2Event event2(ui::CreateTouchEventForTest(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 1500), valuators));
-  root_window_host->Dispatch(event2);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchBegin, 5, gfx::Point(1500, 1500), valuators);
+  root_window_host->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, delegate->last_touch_type());
   EXPECT_EQ(0, delegate->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 1500), delegate->last_touch_location());
 
-  ui::ScopedXI2Event event3(ui::CreateTouchEventForTest(
-      0, XI_TouchUpdate, 5, gfx::Point(1500, 1600), valuators));
-  root_window_host->Dispatch(event3);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchUpdate, 5, gfx::Point(1500, 1600), valuators);
+  root_window_host->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, delegate->last_touch_type());
   EXPECT_EQ(0, delegate->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 1600), delegate->last_touch_location());
 
-  ui::ScopedXI2Event event4(ui::CreateTouchEventForTest(
-      0, XI_TouchEnd, 5, gfx::Point(1500, 1600), valuators));
-  root_window_host->Dispatch(event4);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchEnd, 5, gfx::Point(1500, 1600), valuators);
+  root_window_host->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, delegate->last_touch_type());
   EXPECT_EQ(0, delegate->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 1600), delegate->last_touch_location());
@@ -190,10 +191,11 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(-1, delegate2->last_touch_id());
 
   // 2 Touch events are targeted at the second RootWindowHost.
-  ui::ScopedXI2Event touch1_begin(ui::CreateTouchEventForTest(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators));
-  root_window_host1->Dispatch(touch1_begin);
-  root_window_host2->Dispatch(touch1_begin);
+  ui::ScopedXI2Event scoped_xevent;
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators);
+  root_window_host1->Dispatch(scoped_xevent);
+  root_window_host2->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate1->last_touch_type());
   EXPECT_EQ(-1, delegate1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate1->last_touch_location());
@@ -202,10 +204,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1500, 2500 - host2_y_offset),
             delegate2->last_touch_location());
 
-  ui::ScopedXI2Event touch2_begin(ui::CreateTouchEventForTest(
-      0, XI_TouchBegin, 6, gfx::Point(1600, 2600), valuators));
-  root_window_host1->Dispatch(touch2_begin);
-  root_window_host2->Dispatch(touch2_begin);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchBegin, 6, gfx::Point(1600, 2600), valuators);
+  root_window_host1->Dispatch(scoped_xevent);
+  root_window_host2->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate1->last_touch_type());
   EXPECT_EQ(-1, delegate1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate1->last_touch_location());
@@ -214,10 +216,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1600, 2600 - host2_y_offset),
             delegate2->last_touch_location());
 
-  ui::ScopedXI2Event touch1_move(ui::CreateTouchEventForTest(
-      0, XI_TouchUpdate, 5, gfx::Point(1500, 2550), valuators));
-  root_window_host1->Dispatch(touch1_move);
-  root_window_host2->Dispatch(touch1_move);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchUpdate, 5, gfx::Point(1500, 2550), valuators);
+  root_window_host1->Dispatch(scoped_xevent);
+  root_window_host2->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate1->last_touch_type());
   EXPECT_EQ(-1, delegate1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate1->last_touch_location());
@@ -226,10 +228,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1500, 2550 - host2_y_offset),
             delegate2->last_touch_location());
 
-  ui::ScopedXI2Event touch2_move(ui::CreateTouchEventForTest(
-      0, XI_TouchUpdate, 6, gfx::Point(1600, 2650), valuators));
-  root_window_host1->Dispatch(touch2_move);
-  root_window_host2->Dispatch(touch2_move);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchUpdate, 6, gfx::Point(1600, 2650), valuators);
+  root_window_host1->Dispatch(scoped_xevent);
+  root_window_host2->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate1->last_touch_type());
   EXPECT_EQ(-1, delegate1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate1->last_touch_location());
@@ -238,10 +240,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1600, 2650 - host2_y_offset),
             delegate2->last_touch_location());
 
-  ui::ScopedXI2Event touch1_end(ui::CreateTouchEventForTest(
-      0, XI_TouchEnd, 5, gfx::Point(1500, 2550), valuators));
-  root_window_host1->Dispatch(touch1_end);
-  root_window_host2->Dispatch(touch1_end);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchEnd, 5, gfx::Point(1500, 2550), valuators);
+  root_window_host1->Dispatch(scoped_xevent);
+  root_window_host2->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate1->last_touch_type());
   EXPECT_EQ(-1, delegate1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate1->last_touch_location());
@@ -250,10 +252,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1500, 2550 - host2_y_offset),
             delegate2->last_touch_location());
 
-  ui::ScopedXI2Event touch2_end(ui::CreateTouchEventForTest(
-      0, XI_TouchEnd, 6, gfx::Point(1600, 2650), valuators));
-  root_window_host1->Dispatch(touch2_end);
-  root_window_host2->Dispatch(touch2_end);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchEnd, 6, gfx::Point(1600, 2650), valuators);
+  root_window_host1->Dispatch(scoped_xevent);
+  root_window_host2->Dispatch(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, delegate1->last_touch_type());
   EXPECT_EQ(-1, delegate1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), delegate1->last_touch_location());
diff --git a/ui/base/ime/input_method_ibus_unittest.cc b/ui/base/ime/input_method_ibus_unittest.cc
index 0c28ed4..248270b 100644
--- a/ui/base/ime/input_method_ibus_unittest.cc
+++ b/ui/base/ime/input_method_ibus_unittest.cc
@@ -910,9 +910,9 @@ class InputMethodIBusKeyEventTest : public InputMethodIBusTest {
 TEST_F(InputMethodIBusKeyEventTest, KeyEventDelayResponseTest) {
   const int kXFlags = ShiftMask;
   const unsigned int kIbusFlags = ui::EF_SHIFT_DOWN;
-  XEvent xevent = {};
-  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags, &xevent);
-  const ui::KeyEvent event(&xevent, true);
+  ScopedXI2Event xevent;
+  xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags);
+  const ui::KeyEvent event(xevent, true);
 
   // Do key event.
   input_type_ = TEXT_INPUT_TYPE_TEXT;
@@ -938,7 +938,7 @@ TEST_F(InputMethodIBusKeyEventTest, KeyEventDelayResponseTest) {
   const ui::KeyEvent* stored_event =
       ime_->process_key_event_post_ime_args().event;
   EXPECT_TRUE(stored_event->HasNativeEvent());
-  EXPECT_TRUE(IsEqualXKeyEvent(xevent, *(stored_event->native_event())));
+  EXPECT_TRUE(IsEqualXKeyEvent(*xevent, *(stored_event->native_event())));
   EXPECT_TRUE(ime_->process_key_event_post_ime_args().handled);
 }
 
@@ -949,9 +949,9 @@ TEST_F(InputMethodIBusKeyEventTest, MultiKeyEventDelayResponseTest) {
 
   const int kXFlags = ShiftMask;
   const unsigned int kIbusFlags = ui::EF_SHIFT_DOWN;
-  XEvent xevent = {};
-  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_B, kXFlags, &xevent);
-  const ui::KeyEvent event(&xevent, true);
+  ScopedXI2Event xevent;
+  xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_B, kXFlags);
+  const ui::KeyEvent event(xevent, true);
 
   // Do key event.
   ime_->DispatchKeyEvent(event);
@@ -967,10 +967,9 @@ TEST_F(InputMethodIBusKeyEventTest, MultiKeyEventDelayResponseTest) {
       mock_ime_engine_handler_->last_passed_callback();
 
   // Do key event again.
-  XEvent xevent2 = {};
-  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_C, kXFlags,
-                              &xevent2);
-  const ui::KeyEvent event2(&xevent2, true);
+  ScopedXI2Event xevent2;
+  xevent2.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_C, kXFlags);
+  const ui::KeyEvent event2(xevent2, true);
 
   ime_->DispatchKeyEvent(event2);
   EXPECT_EQ("C",
@@ -994,7 +993,7 @@ TEST_F(InputMethodIBusKeyEventTest, MultiKeyEventDelayResponseTest) {
   const ui::KeyEvent* stored_event =
       ime_->process_key_event_post_ime_args().event;
   EXPECT_TRUE(stored_event->HasNativeEvent());
-  EXPECT_TRUE(IsEqualXKeyEvent(xevent, *(stored_event->native_event())));
+  EXPECT_TRUE(IsEqualXKeyEvent(*xevent, *(stored_event->native_event())));
   EXPECT_TRUE(ime_->process_key_event_post_ime_args().handled);
 
   // Do callback for second key event.
@@ -1004,15 +1003,15 @@ TEST_F(InputMethodIBusKeyEventTest, MultiKeyEventDelayResponseTest) {
   EXPECT_EQ(2, ime_->process_key_event_post_ime_call_count());
   stored_event = ime_->process_key_event_post_ime_args().event;
   EXPECT_TRUE(stored_event->HasNativeEvent());
-  EXPECT_TRUE(IsEqualXKeyEvent(xevent2, *(stored_event->native_event())));
+  EXPECT_TRUE(IsEqualXKeyEvent(*xevent2, *(stored_event->native_event())));
   EXPECT_FALSE(ime_->process_key_event_post_ime_args().handled);
 }
 
 TEST_F(InputMethodIBusKeyEventTest, KeyEventDelayResponseResetTest) {
   const int kXFlags = ShiftMask;
-  XEvent xevent = {};
-  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags, &xevent);
-  const ui::KeyEvent event(&xevent, true);
+  ScopedXI2Event xevent;
+  xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags);
+  const ui::KeyEvent event(xevent, true);
 
   // Do key event.
   input_type_ = TEXT_INPUT_TYPE_TEXT;
diff --git a/ui/events/event_unittest.cc b/ui/events/event_unittest.cc
index e70160b..7fbceca 100644
--- a/ui/events/event_unittest.cc
+++ b/ui/events/event_unittest.cc
@@ -26,9 +26,9 @@ TEST(EventTest, NativeEvent) {
   KeyEvent keyev(native_event, false);
   EXPECT_TRUE(keyev.HasNativeEvent());
 #elif defined(USE_X11)
-  scoped_ptr<XEvent> native_event(new XEvent);
-  InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_A, 0, native_event.get());
-  KeyEvent keyev(native_event.get(), false);
+  ScopedXI2Event event;
+  event.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, 0);
+  KeyEvent keyev(event, false);
   EXPECT_TRUE(keyev.HasNativeEvent());
 #endif
 }
@@ -43,15 +43,13 @@ TEST(EventTest, GetCharacter) {
 
 #if defined(USE_X11)
   // For X11, test the functions with native_event() as well. crbug.com/107837
-  scoped_ptr<XEvent> native_event(new XEvent);
-
-  InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN,
-                          native_event.get());
-  KeyEvent keyev3(native_event.get(), false);
+  ScopedXI2Event event;
+  event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
+  KeyEvent keyev3(event, false);
   EXPECT_EQ(10, keyev3.GetCharacter());
 
-  InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_RETURN, 0, native_event.get());
-  KeyEvent keyev4(native_event.get(), false);
+  event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, 0);
+  KeyEvent keyev4(event, false);
   EXPECT_EQ(13, keyev4.GetCharacter());
 #endif
 }
@@ -195,46 +193,35 @@ TEST(EventTest, KeyEventDirectUnicode) {
 TEST(EventTest, NormalizeKeyEventFlags) {
 #if defined(USE_X11)
   // Normalize flags when KeyEvent is created from XEvent.
+  ScopedXI2Event event;
   {
-    scoped_ptr<XEvent> native_event(new XEvent);
-    InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN,
-                            native_event.get());
-    KeyEvent keyev(native_event.get(), false);
+    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
+    KeyEvent keyev(event, false);
     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
   }
   {
-    scoped_ptr<XEvent> native_event(new XEvent);
-    InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN,
-                            native_event.get());
-    KeyEvent keyev(native_event.get(), false);
+    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
+    KeyEvent keyev(event, false);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
-    scoped_ptr<XEvent> native_event(new XEvent);
-    InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN,
-                            native_event.get());
-    KeyEvent keyev(native_event.get(), false);
+    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
+    KeyEvent keyev(event, false);
     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
   }
   {
-    scoped_ptr<XEvent> native_event(new XEvent);
-    InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN,
-                            native_event.get());
-    KeyEvent keyev(native_event.get(), false);
+    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
+    KeyEvent keyev(event, false);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
-    scoped_ptr<XEvent> native_event(new XEvent);
-    InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN,
-                            native_event.get());
-    KeyEvent keyev(native_event.get(), false);
+    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
+    KeyEvent keyev(event, false);
     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
   }
   {
-    scoped_ptr<XEvent> native_event(new XEvent);
-    InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN,
-                            native_event.get());
-    KeyEvent keyev(native_event.get(), false);
+    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
+    KeyEvent keyev(event, false);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
 #endif
diff --git a/ui/events/test/events_test_utils_x11.cc b/ui/events/test/events_test_utils_x11.cc
index 4849f16..9d5b9dd 100644
--- a/ui/events/test/events_test_utils_x11.cc
+++ b/ui/events/test/events_test_utils_x11.cc
@@ -26,7 +26,6 @@ const int kScrollValuatorMap[kScrollValuatorNum][4] = {
   { 4, ui::DeviceDataManager::DT_CMT_FINGER_COUNT, 0, 3},
 };
 
-#if defined(USE_XI2_MT)
 const int kTouchValuatorNum = 3;
 const int kTouchValuatorMap[kTouchValuatorNum][4] = {
   // { valuator_index, valuator_type, min_val, max_val }
@@ -34,7 +33,6 @@ const int kTouchValuatorMap[kTouchValuatorNum][4] = {
   { 1, ui::DeviceDataManager::DT_TOUCH_ORIENTATION, 0, 1},
   { 2, ui::DeviceDataManager::DT_TOUCH_PRESSURE, 0, 1000},
 };
-#endif
 
 // Converts ui::EventType to state for X*Events.
 unsigned int XEventState(int flags) {
@@ -138,102 +136,121 @@ XEvent* CreateXInput2Event(int deviceid,
 
 namespace ui {
 
-void InitXKeyEventForTesting(EventType type,
-                             KeyboardCode key_code,
-                             int flags,
-                             XEvent* event) {
-  CHECK(event);
-  XDisplay* display = gfx::GetXDisplay();
-  XKeyEvent key_event;
-  key_event.type = XKeyEventType(type);
-  CHECK_NE(0, key_event.type);
-  key_event.serial = 0;
-  key_event.send_event = 0;
-  key_event.display = display;
-  key_event.time = 0;
-  key_event.window = 0;
-  key_event.root = 0;
-  key_event.subwindow = 0;
-  key_event.x = 0;
-  key_event.y = 0;
-  key_event.x_root = 0;
-  key_event.y_root = 0;
-  key_event.state = XEventState(flags);
-  key_event.keycode = XKeyEventKeyCode(key_code, flags, display);
-  key_event.same_screen = 1;
-  event->type = key_event.type;
-  event->xkey = key_event;
+ScopedXI2Event::ScopedXI2Event() {}
+ScopedXI2Event::~ScopedXI2Event() {
+  Cleanup();
 }
 
-void InitXButtonEventForTesting(EventType type,
-                                int flags,
-                                XEvent* event) {
-  CHECK(event);
+void ScopedXI2Event::InitKeyEvent(EventType type,
+                                  KeyboardCode key_code,
+                                  int flags) {
+  Cleanup();
   XDisplay* display = gfx::GetXDisplay();
-  XButtonEvent button_event;
-  button_event.type = XButtonEventType(type);
-  CHECK_NE(0, button_event.type);
-  button_event.serial = 0;
-  button_event.send_event = 0;
-  button_event.display = display;
-  button_event.time = 0;
-  button_event.window = 0;
-  button_event.root = 0;
-  button_event.subwindow = 0;
-  button_event.x = 0;
-  button_event.y = 0;
-  button_event.x_root = 0;
-  button_event.y_root = 0;
-  button_event.state = XEventState(flags);
-  button_event.button = XButtonEventButton(type, flags);
-  button_event.same_screen = 1;
-  event->type = button_event.type;
-  event->xbutton = button_event;
+  event_.reset(new XEvent);
+  event_->type = XKeyEventType(type);
+  CHECK_NE(0, event_->type);
+  event_->xkey.serial = 0;
+  event_->xkey.send_event = 0;
+  event_->xkey.display = display;
+  event_->xkey.time = 0;
+  event_->xkey.window = 0;
+  event_->xkey.root = 0;
+  event_->xkey.subwindow = 0;
+  event_->xkey.x = 0;
+  event_->xkey.y = 0;
+  event_->xkey.x_root = 0;
+  event_->xkey.y_root = 0;
+  event_->xkey.state = XEventState(flags);
+  event_->xkey.keycode = XKeyEventKeyCode(key_code, flags, display);
+  event_->xkey.same_screen = 1;
+}
+
+void ScopedXI2Event::InitButtonEvent(EventType type,
+                                     int flags) {
+  Cleanup();
+  event_.reset(new XEvent);
+  event_->type = XButtonEventType(type);
+  CHECK_NE(0, event_->type);
+  event_->xbutton.serial = 0;
+  event_->xbutton.send_event = 0;
+  event_->xbutton.display = gfx::GetXDisplay();
+  event_->xbutton.time = 0;
+  event_->xbutton.window = 0;
+  event_->xbutton.root = 0;
+  event_->xbutton.subwindow = 0;
+  event_->xbutton.x = 0;
+  event_->xbutton.y = 0;
+  event_->xbutton.x_root = 0;
+  event_->xbutton.y_root = 0;
+  event_->xbutton.state = XEventState(flags);
+  event_->xbutton.button = XButtonEventButton(type, flags);
+  event_->xbutton.same_screen = 1;
 }
 
-void InitXMouseWheelEventForTesting(int wheel_delta,
-                                    int flags,
-                                    XEvent* event) {
-  InitXButtonEventForTesting(ui::ET_MOUSEWHEEL, flags, event);
+void ScopedXI2Event::InitMouseWheelEvent(int wheel_delta,
+                                         int flags) {
+  InitButtonEvent(ui::ET_MOUSEWHEEL, flags);
   // MouseWheelEvents are not taking horizontal scrolls into account
   // at the moment.
-  event->xbutton.button = wheel_delta > 0 ? Button4 : Button5;
+  event_->xbutton.button = wheel_delta > 0 ? Button4 : Button5;
 }
 
-ScopedXI2Event::ScopedXI2Event(XEvent* event) : event_(event) {
-}
+void ScopedXI2Event::InitScrollEvent(int deviceid,
+                                     int x_offset,
+                                     int y_offset,
+                                     int x_offset_ordinal,
+                                     int y_offset_ordinal,
+                                     int finger_count) {
+  Cleanup();
+  event_.reset(CreateXInput2Event(deviceid, XI_Motion, deviceid, gfx::Point()));
 
-ScopedXI2Event::~ScopedXI2Event() {
+  int valuator_data[kScrollValuatorNum] =
+      { x_offset, y_offset, x_offset_ordinal, y_offset_ordinal, finger_count};
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(event_->xcookie.data);
-  if (xiev) {
-    delete[] xiev->valuators.mask;
-    delete[] xiev->valuators.values;
-    delete xiev;
-  }
-}
-
-XEvent* CreateScrollEventForTest(
-    int deviceid,
-    int x_offset,
-    int y_offset,
-    int x_offset_ordinal,
-    int y_offset_ordinal,
-    int finger_count) {
-  XEvent* event = CreateXInput2Event(
-      deviceid, XI_Motion, deviceid, gfx::Point(0, 0));
 
-  int valuator_data[kScrollValuatorNum] =
-      { x_offset, y_offset, x_offset_ordinal, y_offset_ordinal, finger_count };
-  XIDeviceEvent* xiev =
-      static_cast<XIDeviceEvent*>(event->xcookie.data);
   InitValuatorsForXIDeviceEvent(xiev, kScrollValuatorNum);
   for(int i = 0; i < kScrollValuatorNum; i++) {
     XISetMask(xiev->valuators.mask, i);
     xiev->valuators.values[i] = valuator_data[i];
   }
+}
 
-  return event;
+void ScopedXI2Event::InitTouchEvent(int deviceid,
+                                    int evtype,
+                                    int tracking_id,
+                                    const gfx::Point& location,
+                                    const std::vector<Valuator>& valuators) {
+  Cleanup();
+  event_.reset(CreateXInput2Event(
+      deviceid, evtype, tracking_id, location));
+
+  XIDeviceEvent* xiev =
+      static_cast<XIDeviceEvent*>(event_->xcookie.data);
+  InitValuatorsForXIDeviceEvent(xiev, valuators.size());
+  int val_count = 0;
+  for (int i = 0; i < kTouchValuatorNum; i++) {
+    for (size_t j = 0; j < valuators.size(); j++) {
+      if (valuators[j].data_type == kTouchValuatorMap[i][1]) {
+        XISetMask(xiev->valuators.mask, kTouchValuatorMap[i][0]);
+        xiev->valuators.values[val_count++] = valuators[j].value;
+      }
+    }
+  }
+
+}
+
+void ScopedXI2Event::Cleanup() {
+  if (event_.get() && event_->type == GenericEvent) {
+    XIDeviceEvent* xiev =
+        static_cast<XIDeviceEvent*>(event_->xcookie.data);
+    if (xiev) {
+      delete[] xiev->valuators.mask;
+      delete[] xiev->valuators.values;
+      delete xiev;
+    }
+  }
+  event_.reset();
 }
 
  void SetUpScrollDeviceForTest(unsigned int deviceid) {
@@ -254,32 +271,6 @@ XEvent* CreateScrollEventForTest(
   }
 }
 
-#if defined(USE_XI2_MT)
-
-XEvent* CreateTouchEventForTest(int deviceid,
-                                int evtype,
-                                int tracking_id,
-                                const gfx::Point& location,
-                                const std::vector<Valuator>& valuators) {
-  XEvent* event = CreateXInput2Event(
-      deviceid, evtype, tracking_id, location);
-
-  XIDeviceEvent* xiev =
-      static_cast<XIDeviceEvent*>(event->xcookie.data);
-  InitValuatorsForXIDeviceEvent(xiev, valuators.size());
-  int val_count = 0;
-  for (int i = 0; i < kTouchValuatorNum; i++) {
-    for(size_t j = 0; j < valuators.size(); j++) {
-      if (valuators[j].data_type == kTouchValuatorMap[i][1]) {
-        XISetMask(xiev->valuators.mask, kTouchValuatorMap[i][0]);
-        xiev->valuators.values[val_count++] = valuators[j].value;
-      }
-    }
-  }
-
-  return event;
-}
-
 void SetupTouchDevicesForTest(const std::vector<unsigned int>& devices) {
   std::vector<unsigned int> empty_list;
   TouchFactory::GetInstance()->SetTouchDeviceForTest(devices);
@@ -297,6 +288,4 @@ void SetupTouchDevicesForTest(const std::vector<unsigned int>& devices) {
   }
 }
 
-#endif  // defined(USE_XI2_MT)
-
 }  // namespace ui
diff --git a/ui/events/test/events_test_utils_x11.h b/ui/events/test/events_test_utils_x11.h
index 0fffd22..4faa8f4 100644
--- a/ui/events/test/events_test_utils_x11.h
+++ b/ui/events/test/events_test_utils_x11.h
@@ -26,72 +26,50 @@ struct Valuator {
 
 class ScopedXI2Event {
  public:
-  explicit ScopedXI2Event(XEvent* event);
+  ScopedXI2Event();
   ~ScopedXI2Event();
 
   operator XEvent*() { return event_.get(); }
 
+  // Initializes a XEvent with for the appropriate type with the specified data.
+  // Note that ui::EF_ flags should be passed as |flags|, not the native ones in
+  // <X11/X.h>.
+  void InitKeyEvent(EventType type,
+                    KeyboardCode key_code,
+                    int flags);
+
+  void InitButtonEvent(EventType type,
+                       int flags);
+
+  void InitMouseWheelEvent(int wheel_delta,
+                           int flags);
+
+  void InitScrollEvent(int deviceid,
+                       int x_offset,
+                       int y_offset,
+                       int x_offset_ordinal,
+                       int y_offset_ordinal,
+                       int finger_count);
+
+  void InitTouchEvent(int deviceid,
+                      int evtype,
+                      int tracking_id,
+                      const gfx::Point& location,
+                      const std::vector<Valuator>& valuators);
+
  private:
+  void Cleanup();
+
   scoped_ptr<XEvent> event_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedXI2Event);
 };
 
-// Initializes a XEvent that holds XKeyEvent for testing. Note that ui::EF_
-// flags should be passed as |flags|, not the native ones in <X11/X.h>.
-void InitXKeyEventForTesting(EventType type,
-                             KeyboardCode key_code,
-                             int flags,
-                             XEvent* event);
-
-// Initializes a XEvent that holds XButtonEvent for testing. Note that ui::EF_
-// flags should be passed as |flags|, not the native ones in <X11/X.h>.
-void InitXButtonEventForTesting(EventType type,
-                                int flags,
-                                XEvent* event);
-
-// Initializes an XEvent for an Aura MouseWheelEvent. The underlying native
-// event is an XButtonEvent.
-void InitXMouseWheelEventForTesting(int wheel_delta,
-                                    int flags,
-                                    XEvent* event);
-
-// Creates a native scroll event, based on a XInput2Event. The caller is
-// responsible for the ownership of the returned XEvent. Consider wrapping
-// the XEvent in a ScopedXI2Event, as XEvent is purely a struct and simply
-// deleting it will result in dangling pointers.
-XEvent* CreateScrollEventForTest(
-    int deviceid,
-    int x_offset,
-    int y_offset,
-    int x_offset_ordinal,
-    int y_offset_ordinal,
-    int finger_count);
-
-// Creates the native XInput2 based XEvent for an aura scroll event of type
-// ET_SCROLL_FLING_START or ET_SCROLL_FLING_CANCEL. The caller is responsible
-// for the ownership of the returned XEvent.
-XEvent* CreateFlingEventForTest(
-    int deviceid,
-    int x_velocity,
-    int y_velocity,
-    int x_velocity_ordinal,
-    int y_velocity_ordinal,
-    bool is_cancel);
-
 // Initializes a test touchpad device for scroll events.
 void SetUpScrollDeviceForTest(unsigned int deviceid);
 
-#if defined(USE_XI2_MT)
-XEvent* CreateTouchEventForTest(
-    int deviceid,
-    int evtype,
-    int tracking_id,
-    const gfx::Point& location,
-    const std::vector<Valuator>& valuators);
-
+// Initializes a list of touchscreen devices for touch events.
 void SetupTouchDevicesForTest(const std::vector<unsigned int>& devices);
-#endif  // defined(USE_XI2_MT)
 
 }  // namespace ui
 
diff --git a/ui/events/x/events_x_unittest.cc b/ui/events/x/events_x_unittest.cc
index d8ef85e..643454b 100644
--- a/ui/events/x/events_x_unittest.cc
+++ b/ui/events/x/events_x_unittest.cc
@@ -182,66 +182,67 @@ TEST(EventsXTest, TouchEventBasic) {
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_MAJOR, 20));
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.3f));
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_PRESSURE, 100));
-  ui::ScopedXI2Event event1(CreateTouchEventForTest(
-      0, XI_TouchBegin, 5, gfx::Point(10, 10), valuators));
-  EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(event1));
-  EXPECT_EQ("10,10", ui::EventLocationFromNative(event1).ToString());
-  EXPECT_EQ(GetTouchId(event1), 0);
-  EXPECT_EQ(GetTouchRadiusX(event1), 10);
-  EXPECT_FLOAT_EQ(GetTouchAngle(event1), 0.15f);
-  EXPECT_FLOAT_EQ(GetTouchForce(event1), 0.1f);
+  ui::ScopedXI2Event scoped_xevent;
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchBegin, 5, gfx::Point(10, 10), valuators);
+  EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent));
+  EXPECT_EQ("10,10", ui::EventLocationFromNative(scoped_xevent).ToString());
+  EXPECT_EQ(GetTouchId(scoped_xevent), 0);
+  EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
+  EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.15f);
+  EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f);
 
   // Touch update, with new orientation info.
   valuators.clear();
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.5f));
-  ui::ScopedXI2Event event2(CreateTouchEventForTest(
-      0, XI_TouchUpdate, 5, gfx::Point(20, 20), valuators));
-  EXPECT_EQ(ui::ET_TOUCH_MOVED, ui::EventTypeFromNative(event2));
-  EXPECT_EQ("20,20", ui::EventLocationFromNative(event2).ToString());
-  EXPECT_EQ(GetTouchId(event2), 0);
-  EXPECT_EQ(GetTouchRadiusX(event2), 10);
-  EXPECT_FLOAT_EQ(GetTouchAngle(event2), 0.25f);
-  EXPECT_FLOAT_EQ(GetTouchForce(event2), 0.1f);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchUpdate, 5, gfx::Point(20, 20), valuators);
+  EXPECT_EQ(ui::ET_TOUCH_MOVED, ui::EventTypeFromNative(scoped_xevent));
+  EXPECT_EQ("20,20", ui::EventLocationFromNative(scoped_xevent).ToString());
+  EXPECT_EQ(GetTouchId(scoped_xevent), 0);
+  EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
+  EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f);
+  EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f);
 
   // Another touch with tracking id 6, touch id 1.
   valuators.clear();
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_MAJOR, 100));
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.9f));
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_PRESSURE, 500));
-  ui::ScopedXI2Event event3(CreateTouchEventForTest(
-      0, XI_TouchBegin, 6, gfx::Point(200, 200), valuators));
-  EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(event3));
-  EXPECT_EQ("200,200", ui::EventLocationFromNative(event3).ToString());
-  EXPECT_EQ(GetTouchId(event3), 1);
-  EXPECT_EQ(GetTouchRadiusX(event3), 50);
-  EXPECT_FLOAT_EQ(GetTouchAngle(event3), 0.45f);
-  EXPECT_FLOAT_EQ(GetTouchForce(event3), 0.5f);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchBegin, 6, gfx::Point(200, 200), valuators);
+  EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent));
+  EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString());
+  EXPECT_EQ(GetTouchId(scoped_xevent), 1);
+  EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 50);
+  EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f);
+  EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f);
 
   // Touch with tracking id 5 should have old radius/angle value and new pressue
   // value.
   valuators.clear();
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_PRESSURE, 50));
-  ui::ScopedXI2Event event4(CreateTouchEventForTest(
-      0, XI_TouchEnd, 5, gfx::Point(30, 30), valuators));
-  EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(event4));
-  EXPECT_EQ("30,30", ui::EventLocationFromNative(event4).ToString());
-  EXPECT_EQ(GetTouchId(event4), 0);
-  EXPECT_EQ(GetTouchRadiusX(event4), 10);
-  EXPECT_FLOAT_EQ(GetTouchAngle(event4), 0.25f);
-  EXPECT_FLOAT_EQ(GetTouchForce(event4), 0.05f);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchEnd, 5, gfx::Point(30, 30), valuators);
+  EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent));
+  EXPECT_EQ("30,30", ui::EventLocationFromNative(scoped_xevent).ToString());
+  EXPECT_EQ(GetTouchId(scoped_xevent), 0);
+  EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
+  EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f);
+  EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.05f);
 
   // Touch with tracking id 6 should have old angle/pressure value and new
   // radius value.
   valuators.clear();
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_MAJOR, 50));
-  ui::ScopedXI2Event event5(CreateTouchEventForTest(
-      0, XI_TouchEnd, 6, gfx::Point(200, 200), valuators));
-  EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(event5));
-  EXPECT_EQ("200,200", ui::EventLocationFromNative(event5).ToString());
-  EXPECT_EQ(GetTouchId(event5), 1);
-  EXPECT_EQ(GetTouchRadiusX(event5), 25);
-  EXPECT_FLOAT_EQ(GetTouchAngle(event5), 0.45f);
-  EXPECT_FLOAT_EQ(GetTouchForce(event5), 0.5f);
+  scoped_xevent.InitTouchEvent(
+      0, XI_TouchEnd, 6, gfx::Point(200, 200), valuators);
+  EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent));
+  EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString());
+  EXPECT_EQ(GetTouchId(scoped_xevent), 1);
+  EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 25);
+  EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f);
+  EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f);
 }
 #endif
 }  // namespace ui