[PATCH 9/11] ozone: evdev: Add a device event dispatcher that forwards to UI thread

ui/events/ozone/evdev/input_device_factory_evdev.cc

 // Copyright 2015 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/input_device_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
@@ skipping 151 matching lines @@
 // run it on the FILE thread.
 void CloseInputDevice(const base::FilePath& path,
                       scoped_ptr<EventConverterEvdev> converter) {
   TRACE_EVENT1("ozone", "CloseInputDevice", "path", path.value());
   converter.reset();
 }
 
 }  // namespace
 
 InputDeviceFactoryEvdev::InputDeviceFactoryEvdev(
-    DeviceEventDispatcherEvdev* dispatcher,
-    scoped_refptr<base::SingleThreadTaskRunner> dispatch_runner,
+    scoped_ptr<DeviceEventDispatcherEvdev> dispatcher,
     CursorDelegateEvdev* cursor)
-    : ui_task_runner_(dispatch_runner),
+    : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       cursor_(cursor),
 #if defined(USE_EVDEV_GESTURES)
       gesture_property_provider_(new GesturePropertyProvider),
 #endif
-      dispatcher_(dispatcher),
+      dispatcher_(dispatcher.Pass()),
       weak_ptr_factory_(this) {
 }
 
 InputDeviceFactoryEvdev::~InputDeviceFactoryEvdev() {
   STLDeleteValues(&converters_);
 }
 
 void InputDeviceFactoryEvdev::AddInputDevice(int id,
                                              const base::FilePath& path) {
   scoped_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
   params->id = id;
   params->path = path;
   params->cursor = cursor_;
-  params->dispatcher = dispatcher_;
+  params->dispatcher = dispatcher_.get();
 
 #if defined(USE_EVDEV_GESTURES)
   params->gesture_property_provider = gesture_property_provider_.get();
 #endif
 
   OpenInputDeviceReplyCallback reply_callback =
       base::Bind(&InputDeviceFactoryEvdev::AttachInputDevice,
                  weak_ptr_factory_.GetWeakPtr());
 
   // Dispatch task to open from the worker pool, since open may block.
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&OpenInputDevice, base::Passed(&params),
-                                        ui_task_runner_, reply_callback),
+                                        task_runner_, reply_callback),
                              true /* task_is_slow */);
 }
 
 void InputDeviceFactoryEvdev::RemoveInputDevice(const base::FilePath& path) {
   DetachInputDevice(path);
 }
 
 void InputDeviceFactoryEvdev::AttachInputDevice(
     scoped_ptr<EventConverterEvdev> converter) {
   const base::FilePath& path = converter->path();
 
   TRACE_EVENT1("ozone", "AttachInputDevice", "path", path.value());
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // If we have an existing device, detach it. We don't want two
   // devices with the same name open at the same time.
   if (converters_[path])
     DetachInputDevice(path);
 
   // Add initialized device to map.
   converters_[path] = converter.release();
   converters_[path]->Start();
 
   NotifyDeviceChange(*converters_[path]);
 }
 
 void InputDeviceFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("ozone", "DetachInputDevice", "path", path.value());
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // Remove device from map.
   scoped_ptr<EventConverterEvdev> converter(converters_[path]);
   converters_.erase(path);
 
   if (converter) {
     // Cancel libevent notifications from this converter. This part must be
     // on UI since the polling happens on UI.
     converter->Stop();
 
@@ skipping 172 matching lines @@
   std::vector<int> ids;
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
   for (size_t i = 0; i < ids.size(); ++i) {
     SetGestureBoolProperty(gesture_property_provider_.get(), ids[i], name,
                            value);
   }
 #endif
 }
 
 }  // namespace ui