Use touch events to report stylus events

ui/events/ozone/evdev/touch_event_converter_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/touch_event_converter_evdev.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ skipping 60 matching lines @@
       return ABS_MT_POSITION_Y;
     case ABS_PRESSURE:
       return ABS_MT_PRESSURE;
     case ABS_DISTANCE:
       return ABS_MT_DISTANCE;
     default:
       return -1;
   }
 }
 
-ui::PointerDetails GetEventPointerDetails(
-    const ui::InProgressTouchEvdev& event) {
-  ui::EventPointerType type;
-  switch (event.tool_code) {
+ui::EventPointerType GetEventPointerType(int tool_code) {
+  switch (tool_code) {
     case BTN_TOOL_PEN:
-      type = ui::EventPointerType::POINTER_TYPE_PEN;
-      break;
+      return ui::EventPointerType::POINTER_TYPE_PEN;
     case BTN_TOOL_RUBBER:
-      type = ui::EventPointerType::POINTER_TYPE_ERASER;
-      break;
+      return ui::EventPointerType::POINTER_TYPE_ERASER;
     default:
-      type = ui::EventPointerType::POINTER_TYPE_TOUCH;
+      return ui::EventPointerType::POINTER_TYPE_TOUCH;
   }
-  return ui::PointerDetails(type, event.radius_x, event.radius_y,
-                            event.pressure,
-                            /* tilt_x */ 0.0f,
-                            /* tilt_y */ 0.0f);
 }
 
 const int kTrackingIdForUnusedSlot = -1;
 
 }  // namespace
 
 namespace ui {
 
 TouchEventConverterEvdev::TouchEventConverterEvdev(
     int fd,
@@ skipping 213 matching lines @@
 
 void TouchEventConverterEvdev::EmulateMultitouchEvent(
     const input_event& event) {
   input_event emulated_event = event;
 
   if (event.type == EV_ABS) {
     emulated_event.code = AbsCodeToMtCode(event.code);
     if (emulated_event.code >= 0)
       ProcessMultitouchEvent(emulated_event);
   } else if (event.type == EV_KEY) {
-    if (event.code == BTN_TOUCH ||
+    if (event.code == BTN_TOUCH || event.code == BTN_0 ||
         (quirk_left_mouse_button_ && event.code == BTN_LEFT)) {
       emulated_event.type = EV_ABS;
       emulated_event.code = ABS_MT_TRACKING_ID;
       emulated_event.value =
           event.value ? NextTrackingId() : kTrackingIdForUnusedSlot;
       ProcessMultitouchEvent(emulated_event);
     }
   }
 }
 
 void TouchEventConverterEvdev::ProcessKey(const input_event& input) {
   switch (input.code) {
     case BTN_TOUCH:
     case BTN_LEFT:
     case BTN_0:
       events_[current_slot_].btn_left.down = input.value;
       events_[current_slot_].btn_left.changed = true;
       break;
     case BTN_STYLUS:
       events_[current_slot_].btn_right.down = input.value;
       events_[current_slot_].btn_right.changed = true;
       break;
     case BTN_STYLUS2:
       events_[current_slot_].btn_middle.down = input.value;
       events_[current_slot_].btn_middle.changed = true;
       break;
     case BTN_TOOL_PEN:
     case BTN_TOOL_RUBBER:
-      // Do not change tool types while touching to prevent inconsistencies
-      // from switching between Mouse and TouchEvents.
-      if (events_[current_slot_].was_touching)
-        break;
-
       if (input.value > 0) {
         events_[current_slot_].tool_code = input.code;
       } else {
         events_[current_slot_].tool_code = 0;
       }
       events_[current_slot_].altered = true;
       break;
     default:
       NOTIMPLEMENTED() << "invalid code for EV_KEY: " << input.code;
   }
@@ skipping 68 matching lines @@
 
   if (touch.touching)
     return touch.was_touching ? ET_TOUCH_MOVED : ET_TOUCH_PRESSED;
   return touch.was_touching ? ET_TOUCH_RELEASED : ET_UNKNOWN;
 }
 
 void TouchEventConverterEvdev::ReportTouchEvent(
     const InProgressTouchEvdev& event,
     EventType event_type,
     base::TimeTicks timestamp) {
-  dispatcher_->DispatchTouchEvent(TouchEventParams(
-      input_device_.id, event.slot, event_type, gfx::PointF(event.x, event.y),
-      GetEventPointerDetails(event), timestamp));
-}
-
-void TouchEventConverterEvdev::ReportStylusEvent(
-    const InProgressTouchEvdev& event,
-    base::TimeTicks timestamp) {
-  if (event.btn_left.changed)
-    ReportButton(BTN_LEFT, event.btn_left.down, event, timestamp);
-  if (event.btn_right.changed)
-    ReportButton(BTN_RIGHT, event.btn_right.down, event, timestamp);
-  if (event.btn_middle.changed)
-    ReportButton(BTN_MIDDLE, event.btn_middle.down, event, timestamp);
-
-  dispatcher_->DispatchMouseMoveEvent(MouseMoveEventParams(
-      input_device_.id, EF_DIRECT_INPUT, gfx::PointF(event.x, event.y),
-      GetEventPointerDetails(event), timestamp));
-}
-
-void TouchEventConverterEvdev::ReportButton(unsigned int button,
-                                            bool down,
-                                            const InProgressTouchEvdev& event,
-                                            base::TimeTicks timestamp) {
-  dispatcher_->DispatchMouseButtonEvent(MouseButtonEventParams(
-      input_device_.id, EF_DIRECT_INPUT, gfx::PointF(event.x, event.y), button,
-      down, false /* allow_remap */, GetEventPointerDetails(event), timestamp));
+  ui::PointerDetails details(event.reported_tool_type, event.radius_x,
+                             event.radius_y, event.pressure,
+                             /* tilt_x */ 0.0f, /* tilt_y */ 0.0f);
+  dispatcher_->DispatchTouchEvent(
+      TouchEventParams(input_device_.id, event.slot, event_type,
+                       gfx::PointF(event.x, event.y), details, timestamp));
 }
 
 void TouchEventConverterEvdev::ReportEvents(base::TimeTicks timestamp) {
   if (dropped_events_) {
     Reinitialize();
     dropped_events_ = false;
   }
 
   if (touch_noise_finder_)
     touch_noise_finder_->HandleTouches(events_, timestamp);
 
   for (size_t i = 0; i < events_.size(); i++) {
     InProgressTouchEvdev* event = &events_[i];
     if (!event->altered)
       continue;
 
     if (enable_palm_suppression_callback_)
       enable_palm_suppression_callback_.Run(event->tool_code > 0);
 
     if (touch_noise_finder_ && touch_noise_finder_->SlotHasNoise(event->slot))
       event->cancelled = true;
 
-    if (event->tool_code > 0) {
-      ReportStylusEvent(*event, timestamp);
-    } else {
-      EventType event_type = GetEventTypeForTouch(*event);
-      if (event_type != ET_UNKNOWN)
-        ReportTouchEvent(*event, event_type, timestamp);
-    }
+    EventType event_type = GetEventTypeForTouch(*event);
+    // The tool type is fixed with the touch pressed event and does not change.
+    if (event_type == ET_TOUCH_PRESSED)
+      event->reported_tool_type = GetEventPointerType(event->tool_code);
+    if (event_type != ET_UNKNOWN)
+      ReportTouchEvent(*event, event_type, timestamp);
 
     event->was_cancelled = event->cancelled;
     event->was_touching = event->touching;
     event->altered = false;
     event->btn_left.changed = false;
     event->btn_right.changed = false;
     event->btn_middle.changed = false;
   }
 }
 
@@ skipping 48 matching lines @@
   if (pressure_max_ - pressure_min_)
     pressure /= pressure_max_ - pressure_min_;
   return pressure;
 }
 
 int TouchEventConverterEvdev::NextTrackingId() {
   return next_tracking_id_++ & kMaxTrackingId;
 }
 
 }  // namespace ui