ozone: evdev: Minor refactor of device open

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 15 matching lines @@
 #endif
 
 #ifndef EVIOCSCLOCKID
 #define EVIOCSCLOCKID  _IOW('E', 0xa0, int)
 #endif
 
 namespace ui {
 
 namespace {
 
+typedef base::Callback<void(scoped_ptr<EventConverterEvdev>)>
+    OpenInputDeviceReplyCallback;
+
+struct OpenInputDeviceParams {
+  // Unique identifier for the new device.
+  int id;
+
+  // Device path to open.
+  base::FilePath path;
+
+  // Callback for dispatching events. Call on UI thread only.
+  EventDispatchCallback dispatch_callback;
+
+  // State shared between devices. Must not be dereferenced on worker thread.
+  EventModifiersEvdev* modifiers;
+  CursorDelegateEvdev* cursor;
+};
+
 #if defined(USE_EVDEV_GESTURES)
 bool UseGesturesLibraryForDevice(const EventDeviceInfo& devinfo) {
   if (devinfo.HasAbsXY() && !devinfo.IsMappedToScreen())
     return true;  // touchpad
 
   if (devinfo.HasRelXY())
     return true;  // mouse
 
   return false;
 }
 #endif
 
 scoped_ptr<EventConverterEvdev> CreateConverter(
+    const OpenInputDeviceParams& params,
     int fd,
-    const base::FilePath& path,
-    int id,
-    const EventDeviceInfo& devinfo,
-    const EventDispatchCallback& dispatch,
-    EventModifiersEvdev* modifiers,
-    CursorDelegateEvdev* cursor) {
+    const EventDeviceInfo& devinfo) {
 #if defined(USE_EVDEV_GESTURES)
   // Touchpad or mouse: use gestures library.
   // EventReaderLibevdevCros -> GestureInterpreterLibevdevCros -> DispatchEvent
   if (UseGesturesLibraryForDevice(devinfo)) {
-    scoped_ptr<GestureInterpreterLibevdevCros> gesture_interp = make_scoped_ptr(
-        new GestureInterpreterLibevdevCros(modifiers, cursor, dispatch));
+    scoped_ptr<GestureInterpreterLibevdevCros> gesture_interp =
+        make_scoped_ptr(new GestureInterpreterLibevdevCros(
+            params.modifiers, params.cursor, params.dispatch_callback));
     scoped_ptr<EventReaderLibevdevCros> libevdev_reader =
         make_scoped_ptr(new EventReaderLibevdevCros(
             fd,
-            path,
-            id,
+            params.path,
+            params.id,
             gesture_interp.PassAs<EventReaderLibevdevCros::Delegate>()));
     return libevdev_reader.PassAs<EventConverterEvdev>();
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   scoped_ptr<EventConverterEvdev> converter;
   if (devinfo.HasAbsXY())
-    return make_scoped_ptr<EventConverterEvdev>(
-        new TouchEventConverterEvdev(fd, path, id, devinfo, dispatch));
+    return make_scoped_ptr<EventConverterEvdev>(new TouchEventConverterEvdev(
+        fd, params.path, params.id, devinfo, params.dispatch_callback));
 
   // Everything else: use KeyEventConverterEvdev.
-  return make_scoped_ptr<EventConverterEvdev>(
-      new KeyEventConverterEvdev(fd, path, id, modifiers, dispatch));
+  return make_scoped_ptr<EventConverterEvdev>(new KeyEventConverterEvdev(
+      fd, params.path, params.id, params.modifiers, params.dispatch_callback));
 }
 
 // Open an input device. Opening may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on a thread from the worker pool.
 //
 // This takes a TaskRunner and runs the reply on that thread, so that we
 // can hop threads if necessary (back to the UI thread).
-void OpenInputDevice(
-    const base::FilePath& path,
-    EventModifiersEvdev* modifiers,
-    CursorDelegateEvdev* cursor,
-    int device_id,
-    scoped_refptr<base::TaskRunner> reply_runner,
-    const EventDispatchCallback& dispatch,
-    base::Callback<void(scoped_ptr<EventConverterEvdev>)> reply_callback) {
+void OpenInputDevice(scoped_ptr<OpenInputDeviceParams> params,
+                     scoped_refptr<base::TaskRunner> reply_runner,
+                     const OpenInputDeviceReplyCallback& reply_callback) {
+  const base::FilePath& path = params->path;
+
   TRACE_EVENT1("ozone", "OpenInputDevice", "path", path.value());
 
   int fd = open(path.value().c_str(), O_RDONLY | O_NONBLOCK);
   if (fd < 0) {
     PLOG(ERROR) << "Cannot open '" << path.value();
     return;
   }
 
   // Use monotonic timestamps for events. The touch code in particular
   // expects event timestamps to correlate to the monotonic clock
   // (base::TimeTicks).
   unsigned int clk = CLOCK_MONOTONIC;
   if (ioctl(fd, EVIOCSCLOCKID, &clk))
     PLOG(ERROR) << "failed to set CLOCK_MONOTONIC";
 
   EventDeviceInfo devinfo;
   if (!devinfo.Initialize(fd)) {
     LOG(ERROR) << "failed to get device information for " << path.value();
     close(fd);
     return;
   }
 
-  scoped_ptr<EventConverterEvdev> converter = CreateConverter(
-      fd, path, device_id, devinfo, dispatch, modifiers, cursor);
+  scoped_ptr<EventConverterEvdev> converter =
+      CreateConverter(*params, fd, devinfo);
 
   // Reply with the constructed converter.
   reply_runner->PostTask(FROM_HERE,
                          base::Bind(reply_callback, base::Passed(&converter)));
 }
 
 // Close an input device. Closing may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on the FILE thread.
 void CloseInputDevice(const base::FilePath& path,
@@ skipping 16 matching lines @@
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
 void EventFactoryEvdev::DispatchUiEvent(Event* event) {
   DispatchEvent(event);
 }
 
 void EventFactoryEvdev::AttachInputDevice(
-    const base::FilePath& path,
     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
   // 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();
 
   NotifyHotplugEventObserver(*converters_[path]);
 }
 
 void EventFactoryEvdev::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::INPUT)
     return;
 
   switch (event.action_type()) {
     case DeviceEvent::ADD:
     case DeviceEvent::CHANGE: {
       TRACE_EVENT1("ozone", "OnDeviceAdded", "path", event.path().value());
 
+      scoped_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
+      params->id = NextDeviceId();
+      params->path = event.path();
+      params->dispatch_callback = dispatch_callback_;
+      params->modifiers = &modifiers_;
+      params->cursor = cursor_;
+
+      OpenInputDeviceReplyCallback reply_callback =
+          base::Bind(&EventFactoryEvdev::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,
-                     event.path(),
-                     &modifiers_,
-                     cursor_,
-                     NextDeviceId(),
-                     ui_task_runner_,
-                     dispatch_callback_,
-                     base::Bind(&EventFactoryEvdev::AttachInputDevice,
-                                weak_ptr_factory_.GetWeakPtr(),
-                                event.path())),
-          true);
+      base::WorkerPool::PostTask(FROM_HERE,
+                                 base::Bind(&OpenInputDevice,
+                                            base::Passed(&params),
+                                            ui_task_runner_,
+                                            reply_callback),
+                                 true /* task_is_slow */);
     }
       break;
     case DeviceEvent::REMOVE: {
       TRACE_EVENT1("ozone", "OnDeviceRemoved", "path", event.path().value());
       DetachInputDevice(event.path());
     }
       break;
   }
 }
 
@@ skipping 60 matching lines @@
   }
 
   observer->OnTouchscreenDevicesUpdated(touchscreens);
 }
 
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
 }
 
 }  // namespace ui