Revert of https://codereview.chromium.org/82763010/

Reason for revert: Unitialized memory access (see issue 323372)

ISSUE=323372
TBR=sky@chromium.org,jochen@chromium.org,sadrul@chromium.org
NOTREECHECKS=true
NOTRY=true

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

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

14 files changed, 436 insertions, 326 deletions

diff --git a/ash/accelerators/accelerator_controller_unittest.cc b/ash/accelerators/accelerator_controller_unittest.cc
index ce3476b..37ab713 100644
--- a/ash/accelerators/accelerator_controller_unittest.cc
+++ b/ash/accelerators/accelerator_controller_unittest.cc
@@ -665,18 +665,24 @@ TEST_F(AcceleratorControllerTest, MAYBE_ProcessOnce) {
   EXPECT_FALSE(dispatcher->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &key_event3));
 #elif defined(USE_X11)
-  ui::ScopedXI2Event key_event;
-  key_event.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
-  ui::TranslatedKeyEvent key_event1(key_event, false);
+  XEvent key_event;
+  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
+                              ui::VKEY_A,
+                              0,
+                              &key_event);
+  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));
 
-  key_event.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_A, 0);
-  ui::TranslatedKeyEvent key_event3(key_event, false);
+  ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
+                              ui::VKEY_A,
+                              0,
+                              &key_event);
+  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 445c29c..56440ee 100644
--- a/ash/accelerators/nested_dispatcher_controller_unittest.cc
+++ b/ash/accelerators/nested_dispatcher_controller_unittest.cc
@@ -84,13 +84,19 @@ 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)
-  ui::ScopedXI2Event native_event;
-  native_event.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
+  XEvent native_event;
+  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
+                              ui::VKEY_A,
+                              0,
+                              &native_event);
   aura::WindowEventDispatcher* dispatcher =
       ash::Shell::GetPrimaryRootWindow()->GetDispatcher();
-  dispatcher->host()->PostNativeEvent(native_event);
-  native_event.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_A, 0);
-  dispatcher->host()->PostNativeEvent(native_event);
+  dispatcher->host()->PostNativeEvent(&native_event);
+  ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
+                              ui::VKEY_A,
+                              0,
+                              &native_event);
+  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 e8e8975..e05b05e 100644
--- a/ash/wm/sticky_keys_unittest.cc
+++ b/ash/wm/sticky_keys_unittest.cc
@@ -161,43 +161,57 @@ class StickyKeysTest : public test::AshTestBase,
     }
   }
 
+  // Generates keyboard event.
   ui::KeyEvent* GenerateKey(bool is_key_press, ui::KeyboardCode code) {
-    scoped_xevent_.InitKeyEvent(
+    XEvent* xev = new XEvent();
+    ui::InitXKeyEventForTesting(
         is_key_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
         code,
-        0);
-    ui::KeyEvent* event =  new ui::KeyEvent(scoped_xevent_, false);
+        0,
+        xev);
+    xevs_.push_back(xev);
+    ui::KeyEvent* event =  new ui::KeyEvent(xev, false);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::MouseEvent* GenerateMouseEvent(bool is_button_press) {
-    scoped_xevent_.InitButtonEvent(
-        is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED, 0);
-    ui::MouseEvent* event = new ui::MouseEvent(scoped_xevent_);
+    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);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::MouseWheelEvent* GenerateMouseWheelEvent(int wheel_delta) {
-    EXPECT_NE(0, wheel_delta);
-    scoped_xevent_.InitMouseWheelEvent(wheel_delta, 0);
-    ui::MouseWheelEvent* event = new ui::MouseWheelEvent(scoped_xevent_);
+    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);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
   }
 
   ui::ScrollEvent* GenerateScrollEvent(int scroll_delta) {
-    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_);
+    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);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
@@ -251,9 +265,12 @@ 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_;
 
-  // Used to construct the various X events.
-  ui::ScopedXI2Event scoped_xevent_;
+  // Stores all generated XInput2 XEvents. We use a scoped wrapper class here
+  // to properly delete these events.
+  ScopedVector<ui::ScopedXI2Event> xi2_evs_;
 
   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 151bbab..657c34e 100644
--- a/chrome/browser/chromeos/keyboard_driven_event_rewriter_unittest.cc
+++ b/chrome/browser/chromeos/keyboard_driven_event_rewriter_unittest.cc
@@ -16,6 +16,22 @@
 
 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()
@@ -37,16 +53,13 @@ class KeyboardDrivenEventRewriterTest : public testing::Test {
                                         ui::EventType ui_type,
                                         KeyCode x_keycode,
                                         unsigned int x_state) {
-    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 */);
+    XEvent xev;
+    InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
+    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(),
-                              xevent->xkey.state,
+                              xev.xkey.state,
                               changed);
   }
 
diff --git a/chrome/browser/ui/ash/event_rewriter_unittest.cc b/chrome/browser/ui/ash/event_rewriter_unittest.cc
index 34895b7..304a9b7 100644
--- a/chrome/browser/ui/ash/event_rewriter_unittest.cc
+++ b/chrome/browser/ui/ash/event_rewriter_unittest.cc
@@ -33,23 +33,34 @@
 
 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) {
-  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 */);
+  XEvent xev;
+  InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
+  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(),
-      xevent->xkey.keycode, xevent->xkey.state, xevent->xkey.type);
+      xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
 }
 
 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
@@ -2294,18 +2305,17 @@ TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
   // Send left control press.
   std::string rewritten_event;
   {
-    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 */);
+    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 */);
     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(),
-        xevent->xkey.keycode, xevent->xkey.state, xevent->xkey.type);
+        xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
   }
 
   // XK_Control_L (left Control key) should NOT be remapped to Alt if send_event
@@ -2347,12 +2357,10 @@ TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
   window_state->Activate();
 
   // Create a simulated keypress of F1 targetted at the window.
-  ui::ScopedXI2Event xev_f1;
+  XEvent xev_f1;
   KeyCode keycode_f1 = XKeysymToKeycode(gfx::GetXDisplay(), XK_F1);
-  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);
+  InitXKeyEvent(ui::VKEY_F1, 0, ui::ET_KEY_PRESSED, keycode_f1, 0u, &xev_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 afc26a4..1db6b6e 100644
--- a/chrome/browser/ui/views/constrained_window_views_browsertest.cc
+++ b/chrome/browser/ui/views/constrained_window_views_browsertest.cc
@@ -365,9 +365,10 @@ 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)
-  ui::ScopedXI2Event x_event;
-  x_event.InitKeyEvent(ui::ET_KEY_PRESSED, key_code, ui::EF_NONE);
-  XEvent* native_key_event = x_event;
+  XEvent x_event;
+  ui::InitXKeyEventForTesting(
+      ui::ET_KEY_PRESSED, key_code, ui::EF_NONE, &x_event);
+  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 d67d0cd..9154cfb 100644
--- a/content/browser/renderer_host/web_input_event_aura_unittest.cc
+++ b/content/browser/renderer_host/web_input_event_aura_unittest.cc
@@ -21,19 +21,25 @@ namespace content {
 // crbug.com/127142
 TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) {
 #if defined(USE_X11)
-  ui::ScopedXI2Event xev;
+  XEvent xev;
   {
     // Press Ctrl.
-    xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
-    ui::KeyEvent event(xev, false /* is_char */);
+    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 */);
     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.
-    xev.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, ControlMask);
-    ui::KeyEvent event(xev, false /* is_char */);
+    ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
+                                ui::VKEY_CONTROL,
+                                ControlMask,  // X sets the mask for KeyRelease.
+                                &xev);
+    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);
@@ -44,23 +50,27 @@ TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) {
 // Checks that MakeWebKeyboardEvent returns a correct windowsKeyCode.
 TEST(WebInputEventAuraTest, TestMakeWebKeyboardEventWindowsKeyCode) {
 #if defined(USE_X11)
-  ui::ScopedXI2Event xev;
+  XEvent xev;
   {
     // Press left Ctrl.
-    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 */);
+    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 */);
     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.
-    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 */);
+    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 */);
     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 40a99ee..950ee35 100644
--- a/content/renderer/render_view_browsertest.cc
+++ b/content/renderer/render_view_browsertest.cc
@@ -194,25 +194,30 @@ class RenderViewImplTest : public RenderViewTest {
     CHECK(output);
     const int flags = ConvertMockKeyboardModifier(modifiers);
 
-    ui::ScopedXI2Event xevent;
-    xevent.InitKeyEvent(ui::ET_KEY_PRESSED,
-                        static_cast<ui::KeyboardCode>(key_code),
-                        flags);
-    ui::KeyEvent event1(xevent, false);
+    XEvent xevent1;
+    InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
+                            static_cast<ui::KeyboardCode>(key_code),
+                            flags,
+                            &xevent1);
+    ui::KeyEvent event1(&xevent1, false);
     NativeWebKeyboardEvent keydown_event(&event1);
     SendNativeKeyEvent(keydown_event);
 
-    xevent.InitKeyEvent(ui::ET_KEY_PRESSED,
-                        static_cast<ui::KeyboardCode>(key_code),
-                        flags);
-    ui::KeyEvent event2(xevent, true);
+    XEvent xevent2;
+    InitXKeyEventForTesting(ui::ET_KEY_PRESSED,
+                            static_cast<ui::KeyboardCode>(key_code),
+                            flags,
+                            &xevent2);
+    ui::KeyEvent event2(&xevent2, true);
     NativeWebKeyboardEvent char_event(&event2);
     SendNativeKeyEvent(char_event);
 
-    xevent.InitKeyEvent(ui::ET_KEY_RELEASED,
-                        static_cast<ui::KeyboardCode>(key_code),
-                        flags);
-    ui::KeyEvent event3(xevent, false);
+    XEvent xevent3;
+    InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
+                            static_cast<ui::KeyboardCode>(key_code),
+                            flags,
+                            &xevent3);
+    ui::KeyEvent event3(&xevent3, 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 871ca68..36b6976 100644
--- a/ui/aura/root_window_host_x11_unittest.cc
+++ b/ui/aura/root_window_host_x11_unittest.cc
@@ -116,35 +116,34 @@ 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.
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators);
-  root_window_host->Dispatch(scoped_xevent);
+  ui::ScopedXI2Event event1(ui::CreateTouchEventForTest(
+      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators));
+  root_window_host->Dispatch(event1);
   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.
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 1500), valuators);
-  root_window_host->Dispatch(scoped_xevent);
+  ui::ScopedXI2Event event2(ui::CreateTouchEventForTest(
+      0, XI_TouchBegin, 5, gfx::Point(1500, 1500), valuators));
+  root_window_host->Dispatch(event2);
   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());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchUpdate, 5, gfx::Point(1500, 1600), valuators);
-  root_window_host->Dispatch(scoped_xevent);
+  ui::ScopedXI2Event event3(ui::CreateTouchEventForTest(
+      0, XI_TouchUpdate, 5, gfx::Point(1500, 1600), valuators));
+  root_window_host->Dispatch(event3);
   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());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchEnd, 5, gfx::Point(1500, 1600), valuators);
-  root_window_host->Dispatch(scoped_xevent);
+  ui::ScopedXI2Event event4(ui::CreateTouchEventForTest(
+      0, XI_TouchEnd, 5, gfx::Point(1500, 1600), valuators));
+  root_window_host->Dispatch(event4);
   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());
@@ -191,11 +190,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(-1, delegate2->last_touch_id());
 
   // 2 Touch events are targeted at the second RootWindowHost.
-  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);
+  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);
   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());
@@ -204,10 +202,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1500, 2500 - host2_y_offset),
             delegate2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 6, gfx::Point(1600, 2600), valuators);
-  root_window_host1->Dispatch(scoped_xevent);
-  root_window_host2->Dispatch(scoped_xevent);
+  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);
   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());
@@ -216,10 +214,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1600, 2600 - host2_y_offset),
             delegate2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchUpdate, 5, gfx::Point(1500, 2550), valuators);
-  root_window_host1->Dispatch(scoped_xevent);
-  root_window_host2->Dispatch(scoped_xevent);
+  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);
   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());
@@ -228,10 +226,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1500, 2550 - host2_y_offset),
             delegate2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchUpdate, 6, gfx::Point(1600, 2650), valuators);
-  root_window_host1->Dispatch(scoped_xevent);
-  root_window_host2->Dispatch(scoped_xevent);
+  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);
   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());
@@ -240,10 +238,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1600, 2650 - host2_y_offset),
             delegate2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchEnd, 5, gfx::Point(1500, 2550), valuators);
-  root_window_host1->Dispatch(scoped_xevent);
-  root_window_host2->Dispatch(scoped_xevent);
+  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);
   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());
@@ -252,10 +250,10 @@ TEST_F(RootWindowHostX11Test, DispatchTouchEventToTwoRootWindow) {
   EXPECT_EQ(gfx::Point(1500, 2550 - host2_y_offset),
             delegate2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchEnd, 6, gfx::Point(1600, 2650), valuators);
-  root_window_host1->Dispatch(scoped_xevent);
-  root_window_host2->Dispatch(scoped_xevent);
+  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);
   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 248270b..0c28ed4 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;
-  ScopedXI2Event xevent;
-  xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags);
-  const ui::KeyEvent event(xevent, true);
+  XEvent xevent = {};
+  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags, &xevent);
+  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;
-  ScopedXI2Event xevent;
-  xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_B, kXFlags);
-  const ui::KeyEvent event(xevent, true);
+  XEvent xevent = {};
+  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_B, kXFlags, &xevent);
+  const ui::KeyEvent event(&xevent, true);
 
   // Do key event.
   ime_->DispatchKeyEvent(event);
@@ -967,9 +967,10 @@ TEST_F(InputMethodIBusKeyEventTest, MultiKeyEventDelayResponseTest) {
       mock_ime_engine_handler_->last_passed_callback();
 
   // Do key event again.
-  ScopedXI2Event xevent2;
-  xevent2.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_C, kXFlags);
-  const ui::KeyEvent event2(xevent2, true);
+  XEvent xevent2 = {};
+  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_C, kXFlags,
+                              &xevent2);
+  const ui::KeyEvent event2(&xevent2, true);
 
   ime_->DispatchKeyEvent(event2);
   EXPECT_EQ("C",
@@ -993,7 +994,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.
@@ -1003,15 +1004,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;
-  ScopedXI2Event xevent;
-  xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags);
-  const ui::KeyEvent event(xevent, true);
+  XEvent xevent = {};
+  ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, ui::VKEY_A, kXFlags, &xevent);
+  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 7fbceca..e70160b 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)
-  ScopedXI2Event event;
-  event.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, 0);
-  KeyEvent keyev(event, false);
+  scoped_ptr<XEvent> native_event(new XEvent);
+  InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_A, 0, native_event.get());
+  KeyEvent keyev(native_event.get(), false);
   EXPECT_TRUE(keyev.HasNativeEvent());
 #endif
 }
@@ -43,13 +43,15 @@ TEST(EventTest, GetCharacter) {
 
 #if defined(USE_X11)
   // For X11, test the functions with native_event() as well. crbug.com/107837
-  ScopedXI2Event event;
-  event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
-  KeyEvent keyev3(event, false);
+  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);
   EXPECT_EQ(10, keyev3.GetCharacter());
 
-  event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, 0);
-  KeyEvent keyev4(event, false);
+  InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_RETURN, 0, native_event.get());
+  KeyEvent keyev4(native_event.get(), false);
   EXPECT_EQ(13, keyev4.GetCharacter());
 #endif
 }
@@ -193,35 +195,46 @@ TEST(EventTest, KeyEventDirectUnicode) {
 TEST(EventTest, NormalizeKeyEventFlags) {
 #if defined(USE_X11)
   // Normalize flags when KeyEvent is created from XEvent.
-  ScopedXI2Event event;
   {
-    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
-    KeyEvent keyev(event, false);
+    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);
     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
   }
   {
-    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
-    KeyEvent keyev(event, false);
+    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);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
-    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
-    KeyEvent keyev(event, false);
+    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);
     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
   }
   {
-    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
-    KeyEvent keyev(event, false);
+    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);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
-    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
-    KeyEvent keyev(event, false);
+    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);
     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
   }
   {
-    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
-    KeyEvent keyev(event, false);
+    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);
     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 9d5b9dd..4849f16 100644
--- a/ui/events/test/events_test_utils_x11.cc
+++ b/ui/events/test/events_test_utils_x11.cc
@@ -26,6 +26,7 @@ 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 }
@@ -33,6 +34,7 @@ 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) {
@@ -136,121 +138,102 @@ XEvent* CreateXInput2Event(int deviceid,
 
 namespace ui {
 
-ScopedXI2Event::ScopedXI2Event() {}
-ScopedXI2Event::~ScopedXI2Event() {
-  Cleanup();
-}
-
-void ScopedXI2Event::InitKeyEvent(EventType type,
-                                  KeyboardCode key_code,
-                                  int flags) {
-  Cleanup();
+void InitXKeyEventForTesting(EventType type,
+                             KeyboardCode key_code,
+                             int flags,
+                             XEvent* event) {
+  CHECK(event);
   XDisplay* display = gfx::GetXDisplay();
-  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;
+  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;
 }
 
-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 InitXButtonEventForTesting(EventType type,
+                                int flags,
+                                XEvent* event) {
+  CHECK(event);
+  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;
 }
 
-void ScopedXI2Event::InitMouseWheelEvent(int wheel_delta,
-                                         int flags) {
-  InitButtonEvent(ui::ET_MOUSEWHEEL, flags);
+void InitXMouseWheelEventForTesting(int wheel_delta,
+                                    int flags,
+                                    XEvent* event) {
+  InitXButtonEventForTesting(ui::ET_MOUSEWHEEL, flags, event);
   // 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;
 }
 
-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(XEvent* event) : event_(event) {
+}
 
-  int valuator_data[kScrollValuatorNum] =
-      { x_offset, y_offset, x_offset_ordinal, y_offset_ordinal, finger_count};
+ScopedXI2Event::~ScopedXI2Event() {
   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];
+  if (xiev) {
+    delete[] xiev->valuators.mask;
+    delete[] xiev->valuators.values;
+    delete xiev;
   }
 }
 
-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));
+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, 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;
-      }
-    }
+      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];
   }
 
-}
-
-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();
+  return event;
 }
 
  void SetUpScrollDeviceForTest(unsigned int deviceid) {
@@ -271,6 +254,32 @@ void ScopedXI2Event::Cleanup() {
   }
 }
 
+#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);
@@ -288,4 +297,6 @@ 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 4faa8f4..0fffd22 100644
--- a/ui/events/test/events_test_utils_x11.h
+++ b/ui/events/test/events_test_utils_x11.h
@@ -26,50 +26,72 @@ struct Valuator {
 
 class ScopedXI2Event {
  public:
-  ScopedXI2Event();
+  explicit ScopedXI2Event(XEvent* event);
   ~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);
 
-// Initializes a list of touchscreen devices for touch events.
+#if defined(USE_XI2_MT)
+XEvent* CreateTouchEventForTest(
+    int deviceid,
+    int evtype,
+    int tracking_id,
+    const gfx::Point& location,
+    const std::vector<Valuator>& valuators);
+
 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 643454b..d8ef85e 100644
--- a/ui/events/x/events_x_unittest.cc
+++ b/ui/events/x/events_x_unittest.cc
@@ -182,67 +182,66 @@ 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 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);
+  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);
 
   // Touch update, with new orientation info.
   valuators.clear();
   valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.5f));
-  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);
+  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);
 
   // 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));
-  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);
+  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);
 
   // 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));
-  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);
+  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);
 
   // 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));
-  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);
+  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);
 }
 #endif
 }  // namespace ui