[PATCH 5/11] ozone: evdev: Replace dispatch callbacks with an interface

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/bind.h"
@@ skipping 31 matching lines @@
 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.
-  KeyEventDispatchCallback key_callback;
-  MouseMoveEventDispatchCallback mouse_move_callback;
-  MouseButtonEventDispatchCallback mouse_button_callback;
-  MouseWheelEventDispatchCallback mouse_wheel_callback;
-  ScrollEventDispatchCallback scroll_callback;
-  TouchEventDispatchCallback touch_callback;
+  // Dispatcher for events. Call on UI thread only.
+  DeviceEventDispatcherEvdev* dispatcher;
 
   // State shared between devices. Must not be dereferenced on worker thread.
   CursorDelegateEvdev* cursor;
 #if defined(USE_EVDEV_GESTURES)
   GesturePropertyProvider* gesture_property_provider;
 #endif
 };
 
 #if defined(USE_EVDEV_GESTURES)
 bool UseGesturesLibraryForDevice(const EventDeviceInfo& devinfo) {
@@ skipping 12 matching lines @@
     int fd,
     InputDeviceType type,
     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(
             params.id, params.cursor, params.gesture_property_provider,
-            params.key_callback, params.mouse_move_callback,
-            params.mouse_button_callback, params.mouse_wheel_callback,
-            params.scroll_callback));
+            params.dispatcher));
     return make_scoped_ptr(new EventReaderLibevdevCros(
         fd, params.path, params.id, type, devinfo, gesture_interp.Pass()));
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   if (devinfo.HasMTAbsXY()) {
     scoped_ptr<TouchEventConverterEvdev> converter(new TouchEventConverterEvdev(
-        fd, params.path, params.id, type, params.touch_callback));
+        fd, params.path, params.id, type, params.dispatcher));
     converter->Initialize(devinfo);
     return converter.Pass();
   }
 
   // Graphics tablet
   if (devinfo.HasAbsXY())
     return make_scoped_ptr<EventConverterEvdev>(new TabletEventConverterEvdev(
         fd, params.path, params.id, type, params.cursor, devinfo,
-        params.mouse_move_callback, params.mouse_button_callback));
+        params.dispatcher));
 
   // Everything else: use EventConverterEvdevImpl.
-  return make_scoped_ptr<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
-      fd, params.path, params.id, type, devinfo, params.cursor,
-      params.key_callback, params.mouse_move_callback,
-      params.mouse_button_callback));
+  return make_scoped_ptr<EventConverterEvdevImpl>(
+      new EventConverterEvdevImpl(fd, params.path, params.id, type, devinfo,
+                                  params.cursor, params.dispatcher));
 }
 
 // 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(scoped_ptr<OpenInputDeviceParams> params,
                      scoped_refptr<base::TaskRunner> reply_runner,
@@ skipping 56 matching lines @@
       gesture_property_provider_(new GesturePropertyProvider),
 #endif
       input_controller_(this,
                         &keyboard_,
                         &button_map_
 #if defined(USE_EVDEV_GESTURES)
                         ,
                         gesture_property_provider_.get()
 #endif
                             ),
+      initialized_(false),
       weak_ptr_factory_(this) {
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
+void EventFactoryEvdev::Init() {
+  DCHECK(!initialized_);
+  ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+
+  // Scan & monitor devices.
+  device_manager_->AddObserver(this);
+  device_manager_->ScanDevices(this);
+
+  initialized_ = true;
+}
+
 scoped_ptr<SystemInputInjector> EventFactoryEvdev::CreateSystemInputInjector() {
   return make_scoped_ptr(new InputInjectorEvdev(
       &modifiers_, cursor_, &keyboard_, dispatch_callback_));
 }
 
-void EventFactoryEvdev::PostKeyEvent(int device_id,
-                                     unsigned int code,
-                                     bool down) {
+void EventFactoryEvdev::DispatchKeyEvent(int device_id,
+                                         unsigned int code,
+                                         bool down) {
   keyboard_.OnKeyChange(code, down);
 }
 
-void EventFactoryEvdev::PostMouseMoveEvent(int device_id,
-                                           const gfx::PointF& location) {
+void EventFactoryEvdev::DispatchMouseMoveEvent(int device_id,
+                                               const gfx::PointF& location) {
   scoped_ptr<MouseEvent> event(new MouseEvent(
       ui::ET_MOUSE_MOVED, location, location, modifiers_.GetModifierFlags(),
       /* changed_button_flags */ 0));
   event->set_source_device_id(device_id);
   PostUiEvent(event.Pass());
 }
 
-void EventFactoryEvdev::PostMouseButtonEvent(int device_id,
-                                             const gfx::PointF& location,
-                                             unsigned int button,
-                                             bool down,
-                                             bool allow_remap) {
+void EventFactoryEvdev::DispatchMouseButtonEvent(int device_id,
+                                                 const gfx::PointF& location,
+                                                 unsigned int button,
+                                                 bool down,
+                                                 bool allow_remap) {
   // Mouse buttons can be remapped, touchpad taps & clicks cannot.
   if (allow_remap)
     button = button_map_.GetMappedButton(button);
 
   int modifier = EVDEV_MODIFIER_NONE;
   switch (button) {
     case BTN_LEFT:
       modifier = EVDEV_MODIFIER_LEFT_MOUSE_BUTTON;
       break;
     case BTN_RIGHT:
@@ skipping 10 matching lines @@
   modifiers_.UpdateModifier(modifier, down);
 
   scoped_ptr<MouseEvent> event(
       new MouseEvent(down ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED,
                      location, location, modifiers_.GetModifierFlags() | flag,
                      /* changed_button_flags */ flag));
   event->set_source_device_id(device_id);
   PostUiEvent(event.Pass());
 }
 
-void EventFactoryEvdev::PostMouseWheelEvent(int device_id,
-                                            const gfx::PointF& location,
-                                            const gfx::Vector2d& delta) {
+void EventFactoryEvdev::DispatchMouseWheelEvent(int device_id,
+                                                const gfx::PointF& location,
+                                                const gfx::Vector2d& delta) {
   scoped_ptr<MouseWheelEvent> event(new MouseWheelEvent(
       delta, location, location, modifiers_.GetModifierFlags(),
       0 /* changed_button_flags */));
   event->set_source_device_id(device_id);
   PostUiEvent(event.Pass());
 }
 
-void EventFactoryEvdev::PostScrollEvent(const ScrollEventParams& params) {
+void EventFactoryEvdev::DispatchScrollEvent(const ScrollEventParams& params) {
   scoped_ptr<ScrollEvent> event(new ScrollEvent(
       params.type, params.location, params.timestamp,
       modifiers_.GetModifierFlags(), params.delta.x(), params.delta.y(),
       params.ordinal_delta.x(), params.ordinal_delta.y(), params.finger_count));
   event->set_source_device_id(params.device_id);
   PostUiEvent(event.Pass());
 }
 
-void EventFactoryEvdev::PostTouchEvent(const TouchEventParams& params) {
+void EventFactoryEvdev::DispatchTouchEvent(const TouchEventParams& params) {
   float x = params.location.x();
   float y = params.location.y();
   double radius_x = params.radii.x();
   double radius_y = params.radii.y();
 
   // Transform the event according (this is used to align touches
   // to the image based on display mode).
   DeviceDataManager::GetInstance()->ApplyTouchTransformer(params.device_id, &x,
                                                           &y);
   DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
@@ skipping 46 matching lines @@
 
   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->cursor = cursor_;
-      params->key_callback = base::Bind(&EventFactoryEvdev::PostKeyEvent,
-                                        weak_ptr_factory_.GetWeakPtr());
-      params->mouse_move_callback =
-          base::Bind(&EventFactoryEvdev::PostMouseMoveEvent,
-                     weak_ptr_factory_.GetWeakPtr());
-      params->mouse_button_callback =
-          base::Bind(&EventFactoryEvdev::PostMouseButtonEvent,
-                     weak_ptr_factory_.GetWeakPtr());
-      params->mouse_wheel_callback =
-          base::Bind(&EventFactoryEvdev::PostMouseWheelEvent,
-                     weak_ptr_factory_.GetWeakPtr());
-      params->scroll_callback = base::Bind(&EventFactoryEvdev::PostScrollEvent,
-                                           weak_ptr_factory_.GetWeakPtr());
-      params->touch_callback = base::Bind(&EventFactoryEvdev::PostTouchEvent,
-                                          weak_ptr_factory_.GetWeakPtr());
+      params->dispatcher = this;
 
 #if defined(USE_EVDEV_GESTURES)
       params->gesture_property_provider = gesture_property_provider_.get();
 #endif
 
       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,
                                             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;
   }
 }
 
 void EventFactoryEvdev::OnDispatcherListChanged() {
-  if (!ui_task_runner_.get()) {
-    ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    // Scan & monitor devices.
-    device_manager_->AddObserver(this);
-    device_manager_->ScanDevices(this);
-  }
+  if (!initialized_)
+    Init();
 }
 
 void EventFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("ozone", "DetachInputDevice", "path", path.value());
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   // Remove device from map.
   scoped_ptr<EventConverterEvdev> converter(converters_[path]);
   converters_.erase(path);
 
@@ skipping 121 matching lines @@
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
 #endif
   // In the future we can add other device matching logics here.
 
   if (device_ids)
     device_ids->assign(ids.begin(), ids.end());
   return !ids.empty();
 }
 
 }  // namespace ui