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

ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.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/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 #include <linux/input.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/timer/timer.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/event_device_util.h"
 #include "ui/events/ozone/evdev/event_modifiers_evdev.h"
 #include "ui/events/ozone/evdev/keyboard_util_evdev.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_timer_provider.h"
-#include "ui/events/ozone/evdev/mouse_button_map_evdev.h"
 #include "ui/gfx/geometry/point_f.h"
 
 namespace ui {
 
 namespace {
 
 // Convert libevdev device class to libgestures device class.
 GestureInterpreterDeviceClass GestureDeviceClass(Evdev* evdev) {
   switch (evdev->info.evdev_class) {
     case EvdevClassMouse:
       return GESTURES_DEVCLASS_MOUSE;
     case EvdevClassMultitouchMouse:
       return GESTURES_DEVCLASS_MULTITOUCH_MOUSE;
     case EvdevClassTouchpad:
       return GESTURES_DEVCLASS_TOUCHPAD;
     case EvdevClassTouchscreen:
       return GESTURES_DEVCLASS_TOUCHSCREEN;
     default:
       return GESTURES_DEVCLASS_UNKNOWN;
   }
 }
 
-// Convert Linux button code to libgestures button code.
-int GetGestureButton(const MouseButtonMapEvdev::Button code) {
-  switch (code) {
-    case BTN_LEFT:
-      return GESTURES_BUTTON_LEFT;
-    case BTN_RIGHT:
-      return GESTURES_BUTTON_RIGHT;
-    case BTN_MIDDLE:
-      return GESTURES_BUTTON_MIDDLE;
-    case BTN_FORWARD:
-      return GESTURES_BUTTON_FORWARD;
-    case BTN_BACK:
-      return GESTURES_BUTTON_BACK;
-    default:
-      return GESTURES_BUTTON_NONE;
-  }
-}
-
 // Convert libevdev state to libgestures hardware properties.
 HardwareProperties GestureHardwareProperties(
     Evdev* evdev,
     const GestureDeviceProperties* props) {
   HardwareProperties hwprops;
   hwprops.left = props->area_left;
   hwprops.top = props->area_top;
   hwprops.right = props->area_right;
   hwprops.bottom = props->area_bottom;
   hwprops.res_x = props->res_x;
@@ skipping 28 matching lines @@
 const int kGestureScrollFingerCount = 2;
 
 // Number of fingers for swipe gestures.
 const int kGestureSwipeFingerCount = 3;
 
 }  // namespace
 
 GestureInterpreterLibevdevCros::GestureInterpreterLibevdevCros(
     int id,
     EventModifiersEvdev* modifiers,
-    MouseButtonMapEvdev* button_map,
     CursorDelegateEvdev* cursor,
     GesturePropertyProvider* property_provider,
     const KeyEventDispatchCallback& key_callback,
+    const MouseMoveEventDispatchCallback& mouse_move_callback,
+    const MouseButtonEventDispatchCallback& mouse_button_callback,
     const EventDispatchCallback& callback)
     : id_(id),
       is_mouse_(false),
       modifiers_(modifiers),
-      button_map_(button_map),
       cursor_(cursor),
       property_provider_(property_provider),
       key_callback_(key_callback),
+      mouse_move_callback_(mouse_move_callback),
+      mouse_button_callback_(mouse_button_callback),
       dispatch_callback_(callback),
       interpreter_(NULL),
       evdev_(NULL),
       device_properties_(new GestureDeviceProperties) {
   memset(&prev_key_state_, 0, sizeof(prev_key_state_));
 }
 
 GestureInterpreterLibevdevCros::~GestureInterpreterLibevdevCros() {
   // Note that this destructor got called after the evdev device node has been
   // closed. Therefore, all clean-up codes here shouldn't depend on the device
@@ skipping 77 matching lines @@
     fingers[current_finger].position_x = slot->position_x;
     fingers[current_finger].position_y = slot->position_y;
     fingers[current_finger].tracking_id = slot->tracking_id;
     current_finger++;
   }
   hwstate.touch_cnt = Event_Get_Touch_Count(evdev);
   hwstate.finger_cnt = current_finger;
   hwstate.fingers = fingers;
 
   // Buttons.
-  //
-  // We do button mapping for physical clicks only when the device is
-  // mouse-like (e.g., normal mouse and multi-touch mouse).
-  if (Event_Get_Button_Left(evdev)) {
-    hwstate.buttons_down |= GetGestureButton(
-        is_mouse_ ? button_map_->GetMappedButton(BTN_LEFT) : BTN_LEFT);
-  }
-  if (Event_Get_Button_Middle(evdev)) {
-    hwstate.buttons_down |= GetGestureButton(
-        is_mouse_ ? button_map_->GetMappedButton(BTN_MIDDLE) : BTN_MIDDLE);
-  }
-  if (Event_Get_Button_Right(evdev)) {
-    hwstate.buttons_down |= GetGestureButton(
-        is_mouse_ ? button_map_->GetMappedButton(BTN_RIGHT) : BTN_RIGHT);
-  }
+  if (Event_Get_Button_Left(evdev))
+    hwstate.buttons_down |= GESTURES_BUTTON_LEFT;
+  if (Event_Get_Button_Middle(evdev))
+    hwstate.buttons_down |= GESTURES_BUTTON_MIDDLE;
+  if (Event_Get_Button_Right(evdev))
+    hwstate.buttons_down |= GESTURES_BUTTON_RIGHT;
 
   GestureInterpreterPushHardwareState(interpreter_, &hwstate);
 }
 
 void GestureInterpreterLibevdevCros::SetAllowedKeys(
     scoped_ptr<std::set<DomCode>> allowed_keys) {
   if (!allowed_keys) {
     allowed_keys_.reset();
     return;
   }
@@ skipping 52 matching lines @@
                                  move->dx,
                                  move->dy,
                                  move->ordinal_dx,
                                  move->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   cursor_->MoveCursor(gfx::Vector2dF(move->dx, move->dy));
   // TODO(spang): Use move->ordinal_dx, move->ordinal_dy
   // TODO(spang): Use move->start_time, move->end_time
-  Dispatch(make_scoped_ptr(new MouseEvent(ET_MOUSE_MOVED,
-                                          cursor_->GetLocation(),
-                                          cursor_->GetLocation(),
-                                          modifiers_->GetModifierFlags(),
-                                          /* changed_button_flags */ 0)));
+  mouse_move_callback_.Run(MouseMoveEventParams(id_, cursor_->GetLocation()));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureScroll(
     const Gesture* gesture,
     const GestureScroll* scroll) {
   DVLOG(3) << base::StringPrintf("Gesture Scroll: (%f, %f) [%f, %f]",
                                  scroll->dx,
                                  scroll->dy,
                                  scroll->ordinal_dx,
                                  scroll->ordinal_dy);
@@ skipping 27 matching lines @@
     const GestureButtonsChange* buttons) {
   DVLOG(3) << base::StringPrintf("Gesture Button Change: down=0x%02x up=0x%02x",
                                  buttons->down,
                                  buttons->up);
 
   if (!cursor_)
     return;  // No cursor!
 
   // TODO(spang): Use buttons->start_time, buttons->end_time
   if (buttons->down & GESTURES_BUTTON_LEFT)
-    DispatchMouseButton(EVDEV_MODIFIER_LEFT_MOUSE_BUTTON, true);
+    DispatchMouseButton(BTN_LEFT, true);
   if (buttons->down & GESTURES_BUTTON_MIDDLE)
-    DispatchMouseButton(EVDEV_MODIFIER_MIDDLE_MOUSE_BUTTON, true);
+    DispatchMouseButton(BTN_MIDDLE, true);
   if (buttons->down & GESTURES_BUTTON_RIGHT)
-    DispatchMouseButton(EVDEV_MODIFIER_RIGHT_MOUSE_BUTTON, true);
+    DispatchMouseButton(BTN_RIGHT, true);
   if (buttons->up & GESTURES_BUTTON_LEFT)
-    DispatchMouseButton(EVDEV_MODIFIER_LEFT_MOUSE_BUTTON, false);
+    DispatchMouseButton(BTN_LEFT, false);
   if (buttons->up & GESTURES_BUTTON_MIDDLE)
-    DispatchMouseButton(EVDEV_MODIFIER_MIDDLE_MOUSE_BUTTON, false);
+    DispatchMouseButton(BTN_MIDDLE, false);
   if (buttons->up & GESTURES_BUTTON_RIGHT)
-    DispatchMouseButton(EVDEV_MODIFIER_RIGHT_MOUSE_BUTTON, false);
+    DispatchMouseButton(BTN_RIGHT, false);
 }
 
 void GestureInterpreterLibevdevCros::OnGestureContactInitiated(
     const Gesture* gesture) {
   // TODO(spang): handle contact initiated.
 }
 
 void GestureInterpreterLibevdevCros::OnGestureFling(const Gesture* gesture,
                                                     const GestureFling* fling) {
   DVLOG(3) << base::StringPrintf(
@@ skipping 86 matching lines @@
                                  metrics->data[0],
                                  metrics->data[1],
                                  metrics->type);
   NOTIMPLEMENTED();
 }
 
 void GestureInterpreterLibevdevCros::Dispatch(scoped_ptr<Event> event) {
   dispatch_callback_.Run(event.Pass());
 }
 
-void GestureInterpreterLibevdevCros::DispatchMouseButton(unsigned int modifier,
+void GestureInterpreterLibevdevCros::DispatchMouseButton(unsigned int button,
                                                          bool down) {
-  const gfx::PointF location = cursor_->GetLocation();
-  int flag = modifiers_->GetEventFlagFromModifier(modifier);
-  EventType type = (down ? ET_MOUSE_PRESSED : ET_MOUSE_RELEASED);
-  modifiers_->UpdateModifier(modifier, down);
-  Dispatch(make_scoped_ptr(new MouseEvent(
-      type, location, location, modifiers_->GetModifierFlags() | flag, flag)));
+  bool allow_remap = is_mouse_;
+  mouse_button_callback_.Run(MouseButtonEventParams(id_, cursor_->GetLocation(),
+                                                    button, down, allow_remap));
 }
 
 void GestureInterpreterLibevdevCros::DispatchChangedKeys(Evdev* evdev,
                                                          const timeval& time) {
   unsigned long key_state_diff[EVDEV_BITS_TO_LONGS(KEY_CNT)];
 
   // Find changed keys.
   for (unsigned long i = 0; i < arraysize(key_state_diff); ++i)
     key_state_diff[i] = evdev->key_state_bitmask[i] ^ prev_key_state_[i];
 
@@ skipping 17 matching lines @@
       key_callback_.Run(KeyEventParams(id_, key, value));
     }
   }
 
   // Update internal key state.
   for (unsigned long i = 0; i < EVDEV_BITS_TO_LONGS(KEY_CNT); ++i)
     prev_key_state_[i] = evdev->key_state_bitmask[i];
 }
 
 }  // namespace ui