ozone: evdev: Add gesture property provider

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"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/key_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
 #if defined(USE_EVDEV_GESTURES)
 #include "ui/events/ozone/evdev/libgestures_glue/event_reader_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
+#include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #endif
 
 #ifndef EVIOCSCLOCKID
 #define EVIOCSCLOCKID  _IOW('E', 0xa0, int)
 #endif
 
 namespace ui {
 
 namespace {
 
 #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(
     int fd,
     const base::FilePath& path,
     const EventDeviceInfo& devinfo,
     const EventDispatchCallback& dispatch,
     EventModifiersEvdev* modifiers,
-    CursorDelegateEvdev* cursor) {
+    CursorDelegateEvdev* cursor
+#if defined(USE_EVDEV_GESTURES)
+    ,
+    GesturePropertyProvider* prop_provider
+#endif
+    ) {
 #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(
+            modifiers, cursor, prop_provider, dispatch));
     scoped_ptr<EventReaderLibevdevCros> libevdev_reader =
         make_scoped_ptr(new EventReaderLibevdevCros(
             fd,
             path,
             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, devinfo, dispatch));
 
   // Everything else: use KeyEventConverterEvdev.
   return make_scoped_ptr<EventConverterEvdev>(
       new KeyEventConverterEvdev(fd, path, modifiers, dispatch));
 }
 
 // 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,
+    CursorDelegateEvdev* cursor
+#if defined(USE_EVDEV_GESTURES)
+    ,
+    GesturePropertyProvider* prop_provider,
+#endif
     scoped_refptr<base::TaskRunner> reply_runner,
     const EventDispatchCallback& dispatch,
     base::Callback<void(scoped_ptr<EventConverterEvdev>)> reply_callback) {
   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, devinfo, dispatch, modifiers, cursor);
+  scoped_ptr<EventConverterEvdev> converter = CreateConverter(fd,
+                                                              path,
+                                                              devinfo,
+                                                              dispatch,
+                                                              modifiers,
+                                                              cursor
+#if defined(USE_EVDEV_GESTURES)
+                                                              ,
+                                                              prop_provider
+#endif
+                                                              );
 
   // 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,
                       scoped_ptr<EventConverterEvdev> converter) {
   TRACE_EVENT1("ozone", "CloseInputDevice", "path", path.value());
   converter.reset();
 }
 
 }  // namespace
 
-EventFactoryEvdev::EventFactoryEvdev(
-    CursorDelegateEvdev* cursor,
-    DeviceManager* device_manager)
+EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor,
+                                     DeviceManager* device_manager)
     : device_manager_(device_manager),
-      cursor_(cursor),
+      cursor_(cursor)
+#if defined(USE_EVDEV_GESTURES)
+      ,
+      gesture_prop_provider_(new GesturePropertyProvider),
+#endif
       dispatch_callback_(
           base::Bind(base::IgnoreResult(&EventFactoryEvdev::DispatchUiEvent),
                      base::Unretained(this))),
       weak_ptr_factory_(this) {
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
 void EventFactoryEvdev::DispatchUiEvent(Event* event) {
@@ skipping 24 matching lines @@
     case DeviceEvent::ADD:
     case DeviceEvent::CHANGE: {
       TRACE_EVENT1("ozone", "OnDeviceAdded", "path", event.path().value());
 
       // Dispatch task to open from the worker pool, since open may block.
       base::WorkerPool::PostTask(
           FROM_HERE,
           base::Bind(&OpenInputDevice,
                      event.path(),
                      &modifiers_,
-                     cursor_,
+                     cursor_
+#if defined(USE_EVDEV_GESTURES)
+                     ,
+                     gesture_prop_provider_.get(),
+#endif
                      ui_task_runner_,
                      dispatch_callback_,
                      base::Bind(&EventFactoryEvdev::AttachInputDevice,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 event.path())),
           true);
     }
       break;
     case DeviceEvent::REMOVE: {
       TRACE_EVENT1("ozone", "OnDeviceRemoved", "path", event.path().value());
@@ skipping 40 matching lines @@
     MouseEvent mouse_event(ET_MOUSE_MOVED,
                            cursor_->location(),
                            cursor_->location(),
                            modifiers_.GetModifierFlags(),
                            /* changed_button_flags */ 0);
     DispatchEvent(&mouse_event);
   }
 }
 
 }  // namespace ui