ozone: evdev: Dispatch events in task

ui/events/ozone/evdev/event_factory_evdev.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 
 #include "base/debug/trace_event.h"
@@ skipping 132 matching lines @@
   converter.reset();
 }
 
 }  // namespace
 
 EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor,
                                      DeviceManager* device_manager)
     : last_device_id_(0),
       device_manager_(device_manager),
       dispatch_callback_(
-          base::Bind(base::IgnoreResult(&EventFactoryEvdev::DispatchUiEvent),
-                     base::Unretained(this))),
+          base::Bind(&EventFactoryEvdev::PostUiEvent, base::Unretained(this))),
       keyboard_(&modifiers_, dispatch_callback_),
       cursor_(cursor),
       weak_ptr_factory_(this) {
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
-void EventFactoryEvdev::DispatchUiEvent(Event* event) {
-  DispatchEvent(event);
+void EventFactoryEvdev::PostUiEvent(scoped_ptr<Event> event) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&EventFactoryEvdev::DispatchUiEventTask,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&event)));
+}
+
+void EventFactoryEvdev::DispatchUiEventTask(scoped_ptr<Event> event) {
+  DispatchEvent(event.get());
 }
 
 void EventFactoryEvdev::AttachInputDevice(
     scoped_ptr<EventConverterEvdev> converter) {
   const base::FilePath& path = converter->path();
 
   TRACE_EVENT1("ozone", "AttachInputDevice", "path", path.value());
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   // If we have an existing device, detach it. We don't want two
@@ skipping 75 matching lines @@
         FROM_HERE,
         base::Bind(&CloseInputDevice, path, base::Passed(&converter)),
         true);
   }
 }
 
 void EventFactoryEvdev::WarpCursorTo(gfx::AcceleratedWidget widget,
                                      const gfx::PointF& location) {
   if (cursor_) {
     cursor_->MoveCursorTo(widget, location);
-    MouseEvent mouse_event(ET_MOUSE_MOVED,
-                           cursor_->location(),
-                           cursor_->location(),
-                           modifiers_.GetModifierFlags(),
-                           /* changed_button_flags */ 0);
-    DispatchEvent(&mouse_event);
+    PostUiEvent(make_scoped_ptr(new MouseEvent(ET_MOUSE_MOVED,
+                                               cursor_->location(),
+                                               cursor_->location(),
+                                               modifiers_.GetModifierFlags(),
+                                               /* changed_button_flags */ 0)));
   }
 }
 
 void EventFactoryEvdev::NotifyHotplugEventObserver(
     const EventConverterEvdev& converter) {
   // For now the only information propagated is related to touchscreens. Ignore
   // events for everything but touchscreens.
   if (!converter.HasTouchscreen())
     return;
 
   DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   std::vector<TouchscreenDevice> touchscreens;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasTouchscreen()) {
       touchscreens.push_back(TouchscreenDevice(it->second->id(),
                                                it->second->GetTouchscreenSize(),
                                                false /* is_internal */));
     }
   }
 
   observer->OnTouchscreenDevicesUpdated(touchscreens);
 }
 
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
 }
 
 }  // namespace ui