[PATCH 3/11] ozone: evdev: Move MouseButtonMap usage during dispatch to EventFactoryEvdev

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 34 matching lines @@
 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;
   KeyEventDispatchCallback key_callback;
+  MouseMoveEventDispatchCallback mouse_move_callback;
+  MouseButtonEventDispatchCallback mouse_button_callback;
   TouchEventDispatchCallback touch_callback;
 
   // State shared between devices. Must not be dereferenced on worker thread.
   EventModifiersEvdev* modifiers;
-  MouseButtonMapEvdev* button_map;
   CursorDelegateEvdev* cursor;
 #if defined(USE_EVDEV_GESTURES)
   GesturePropertyProvider* gesture_property_provider;
 #endif
 };
 
 #if defined(USE_EVDEV_GESTURES)
 bool UseGesturesLibraryForDevice(const EventDeviceInfo& devinfo) {
   if (devinfo.HasTouchpad())
     return true;
 
   if (devinfo.HasRelXY())
     return true;  // mouse
 
   return false;
 }
 #endif
 
 scoped_ptr<EventConverterEvdev> CreateConverter(
     const OpenInputDeviceParams& params,
     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.modifiers, params.button_map, params.cursor,
+            params.id, params.modifiers, params.cursor,
             params.gesture_property_provider, params.key_callback,
+            params.mouse_move_callback, params.mouse_button_callback,
             params.dispatch_callback));
     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));
     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.modifiers, params.cursor,
         devinfo, params.dispatch_callback));
 
   // Everything else: use EventConverterEvdevImpl.
   return make_scoped_ptr<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
       fd, params.path, params.id, type, devinfo, params.modifiers,
-      params.button_map, params.cursor, params.key_callback,
-      params.dispatch_callback));
+      params.cursor, params.key_callback, params.mouse_move_callback,
+      params.mouse_button_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(scoped_ptr<OpenInputDeviceParams> params,
                      scoped_refptr<base::TaskRunner> reply_runner,
@@ skipping 71 matching lines @@
 
 scoped_ptr<SystemInputInjector> EventFactoryEvdev::CreateSystemInputInjector() {
   return make_scoped_ptr(new InputInjectorEvdev(
       &modifiers_, cursor_, &keyboard_, dispatch_callback_));
 }
 
 void EventFactoryEvdev::PostKeyEvent(const KeyEventParams& params) {
   keyboard_.OnKeyChange(params.code, params.down);
 }
 
+void EventFactoryEvdev::PostMouseMoveEvent(const MouseMoveEventParams& params) {
+  scoped_ptr<MouseEvent> event(new MouseEvent(ui::ET_MOUSE_MOVED,
+                                              params.location, params.location,
+                                              modifiers_.GetModifierFlags(),
+                                              /* changed_button_flags */ 0));
+  event->set_source_device_id(params.device_id);
+  PostUiEvent(event.Pass());
+}
+
+void EventFactoryEvdev::PostMouseButtonEvent(
+    const MouseButtonEventParams& params) {
+  // Mouse buttons can be remapped, touchpad taps & clicks cannot.
+  unsigned int button = params.button;
+  if (params.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:
+      modifier = EVDEV_MODIFIER_RIGHT_MOUSE_BUTTON;
+      break;
+    case BTN_MIDDLE:
+      modifier = EVDEV_MODIFIER_MIDDLE_MOUSE_BUTTON;
+      break;
+    default:
+      return;
+  }
+
+  int flag = modifiers_.GetEventFlagFromModifier(modifier);
+  modifiers_.UpdateModifier(modifier, params.down);
+
+  scoped_ptr<MouseEvent> event(new MouseEvent(
+      params.down ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED,
+      params.location, params.location, modifiers_.GetModifierFlags() | flag,
+      /* changed_button_flags */ flag));
+  event->set_source_device_id(params.device_id);
+  PostUiEvent(event.Pass());
+}
+
 void EventFactoryEvdev::PostTouchEvent(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 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 47 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->dispatch_callback = dispatch_callback_;
       params->modifiers = &modifiers_;
-      params->button_map = &button_map_;
       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->touch_callback = base::Bind(&EventFactoryEvdev::PostTouchEvent,
                                           weak_ptr_factory_.GetWeakPtr());
 
 #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());
@@ skipping 156 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