Android mouse events shouldn't appear as TouchEvents

ui/events/blink/blink_event_util.cc

 // Copyright 2015 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/blink/blink_event_util.h"
 
 #include <stddef.h>
@@ skipping 15 matching lines @@
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebPointerProperties;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace ui {
 namespace {
 
-WebInputEvent::Type ToWebInputEventType(MotionEvent::Action action) {
+WebInputEvent::Type ToWebTouchEventType(MotionEvent::Action action) {
   switch (action) {
     case MotionEvent::ACTION_DOWN:
       return WebInputEvent::TouchStart;
     case MotionEvent::ACTION_MOVE:
       return WebInputEvent::TouchMove;
     case MotionEvent::ACTION_UP:
       return WebInputEvent::TouchEnd;
     case MotionEvent::ACTION_CANCEL:
       return WebInputEvent::TouchCancel;
     case MotionEvent::ACTION_POINTER_DOWN:
       return WebInputEvent::TouchStart;
     case MotionEvent::ACTION_POINTER_UP:
       return WebInputEvent::TouchEnd;
     case MotionEvent::ACTION_NONE:
-      NOTREACHED();
-      return WebInputEvent::Undefined;
+    case MotionEvent::ACTION_HOVER_ENTER:
+    case MotionEvent::ACTION_HOVER_EXIT:
+    case MotionEvent::ACTION_HOVER_MOVE:
+    case MotionEvent::ACTION_BUTTON_PRESS:
+    case MotionEvent::ACTION_BUTTON_RELEASE:
+      break;
   }
-  NOTREACHED() << "Invalid MotionEvent::Action.";
+  NOTREACHED() << "Invalid MotionEvent::Action = " << action;
   return WebInputEvent::Undefined;
 }
 
 // Note that the action index is meaningful only in the context of
 // |ACTION_POINTER_UP| and |ACTION_POINTER_DOWN|; other actions map directly to
 // WebTouchPoint::State.
 WebTouchPoint::State ToWebTouchPointState(const MotionEvent& event,
                                           size_t pointer_index) {
   switch (event.GetAction()) {
     case MotionEvent::ACTION_DOWN:
       return WebTouchPoint::StatePressed;
     case MotionEvent::ACTION_MOVE:
       return WebTouchPoint::StateMoved;
     case MotionEvent::ACTION_UP:
       return WebTouchPoint::StateReleased;
     case MotionEvent::ACTION_CANCEL:
       return WebTouchPoint::StateCancelled;
     case MotionEvent::ACTION_POINTER_DOWN:
       return static_cast<int>(pointer_index) == event.GetActionIndex()
                  ? WebTouchPoint::StatePressed
                  : WebTouchPoint::StateStationary;
     case MotionEvent::ACTION_POINTER_UP:
       return static_cast<int>(pointer_index) == event.GetActionIndex()
                  ? WebTouchPoint::StateReleased
                  : WebTouchPoint::StateStationary;
     case MotionEvent::ACTION_NONE:
-      NOTREACHED();
-      return WebTouchPoint::StateUndefined;
+    case MotionEvent::ACTION_HOVER_ENTER:
+    case MotionEvent::ACTION_HOVER_EXIT:
+    case MotionEvent::ACTION_HOVER_MOVE:
+    case MotionEvent::ACTION_BUTTON_PRESS:
+    case MotionEvent::ACTION_BUTTON_RELEASE:
+      break;
   }
   NOTREACHED() << "Invalid MotionEvent::Action.";
   return WebTouchPoint::StateUndefined;
 }
 
+WebPointerProperties::PointerType ToWebPointerType(int tool_type) {
+  switch (static_cast<MotionEvent::ToolType>(tool_type)) {
+    case MotionEvent::TOOL_TYPE_UNKNOWN:
+      return WebPointerProperties::PointerType::Unknown;
+    case MotionEvent::TOOL_TYPE_FINGER:
+      return WebPointerProperties::PointerType::Touch;
+    case MotionEvent::TOOL_TYPE_STYLUS:
+      return WebPointerProperties::PointerType::Pen;
+    case MotionEvent::TOOL_TYPE_MOUSE:
+      return WebPointerProperties::PointerType::Mouse;
+    case MotionEvent::TOOL_TYPE_ERASER:
+      return WebPointerProperties::PointerType::Eraser;
+  }
+  NOTREACHED() << "Invalid MotionEvent::ToolType = " << tool_type;
+  return WebPointerProperties::PointerType::Unknown;
+}
+
+WebPointerProperties::Button ToWebPointerButton(int android_button_state) {
+    if (android_button_state & MotionEvent::BUTTON_PRIMARY)
+        return WebPointerProperties::Button::Left;
+    else if (android_button_state & MotionEvent::BUTTON_SECONDARY)
+        return WebPointerProperties::Button::Right;
+    else if (android_button_state & MotionEvent::BUTTON_TERTIARY)
+        return WebPointerProperties::Button::Middle;
+    else if (android_button_state & MotionEvent::BUTTON_BACK)
+        return WebPointerProperties::Button::X1;
+    else if (android_button_state & MotionEvent::BUTTON_FORWARD)
+        return WebPointerProperties::Button::X2;
+    else if (android_button_state & MotionEvent::BUTTON_STYLUS_PRIMARY)
+        return WebPointerProperties::Button::Left;
+    else if (android_button_state & MotionEvent::BUTTON_STYLUS_SECONDARY)
+        return WebPointerProperties::Button::Right;
+    else
+        return WebPointerProperties::Button::NoButton;
+}
+
 WebTouchPoint CreateWebTouchPoint(const MotionEvent& event,
                                   size_t pointer_index) {
   WebTouchPoint touch;
-  touch.id = event.GetPointerId(pointer_index);
-  touch.pointerType = ToWebPointerType(event.GetToolType(pointer_index));
+
+  SetWebPointerPropertiesFromMotionEventData(
+      touch, event.GetPointerId(pointer_index),
+      event.GetPressure(pointer_index), event.GetOrientation(pointer_index),
+      event.GetTilt(pointer_index), 0 /* no button changed */,
+      event.GetToolType(pointer_index));
+
   touch.state = ToWebTouchPointState(event, pointer_index);
   touch.position.x = event.GetX(pointer_index);
   touch.position.y = event.GetY(pointer_index);
   touch.screenPosition.x = event.GetRawX(pointer_index);
   touch.screenPosition.y = event.GetRawY(pointer_index);
 
   // A note on touch ellipse specifications:
   //
   // Android MotionEvent provides the major and minor axes of the touch ellipse,
   // as well as the orientation of the major axis clockwise from vertical, in
   // radians. See:
   // http://developer.android.com/reference/android/view/MotionEvent.html
   //
   // The proposed extension to W3C Touch Events specifies the touch ellipse
   // using two radii along x- & y-axes and a positive acute rotation angle in
   // degrees. See:
   // http://dvcs.w3.org/hg/webevents/raw-file/default/touchevents.html
 
   float major_radius = event.GetTouchMajor(pointer_index) / 2.f;
   float minor_radius = event.GetTouchMinor(pointer_index) / 2.f;
+  float orientation_deg = event.GetOrientation(pointer_index) * 180.f / M_PI;
 
-  float orientation_rad = event.GetOrientation(pointer_index);
-  float orientation_deg = orientation_rad * 180.f / M_PI;
   DCHECK_GE(major_radius, 0);
   DCHECK_GE(minor_radius, 0);
   DCHECK_GE(major_radius, minor_radius);
   // Orientation lies in [-180, 180] for a stylus, and [-90, 90] for other
   // touchscreen inputs. There are exceptions on Android when a device is
   // rotated, yielding touch orientations in the range of [-180, 180].
   // Regardless, normalise to [-90, 90), allowing a small tolerance to account
   // for floating point conversion.
   // TODO(e_hakkinen): Also pass unaltered stylus orientation, avoiding loss of
   // quadrant information, see crbug.com/493728.
@@ skipping 10 matching lines @@
     // report elliptical touches).
     touch.radiusX = minor_radius;
     touch.radiusY = major_radius;
     touch.rotationAngle = orientation_deg;
   } else {
     touch.radiusX = major_radius;
     touch.radiusY = minor_radius;
     touch.rotationAngle = orientation_deg + 90;
   }
 
-  touch.force = event.GetPressure(pointer_index);
-
-  if (event.GetToolType(pointer_index) == MotionEvent::TOOL_TYPE_STYLUS) {
-    // A stylus points to a direction specified by orientation and tilts to
-    // the opposite direction. Coordinate system is left-handed.
-    float tilt_rad = event.GetTilt(pointer_index);
-    float r = sin(tilt_rad);
-    float z = cos(tilt_rad);
-    touch.tiltX = lround(atan2(sin(-orientation_rad) * r, z) * 180.f / M_PI);
-    touch.tiltY = lround(atan2(cos(-orientation_rad) * r, z) * 180.f / M_PI);
-  } else {
-    touch.tiltX = touch.tiltY = 0;
-  }
-
   return touch;
 }
 
 }  // namespace
 
 blink::WebTouchEvent CreateWebTouchEventFromMotionEvent(
     const MotionEvent& event,
     bool moved_beyond_slop_region) {
   static_assert(static_cast<int>(MotionEvent::MAX_TOUCH_POINT_COUNT) ==
                     static_cast<int>(blink::WebTouchEvent::kTouchesLengthCap),
                 "inconsistent maximum number of active touch points");
 
   blink::WebTouchEvent result;
 
-  result.type = ToWebInputEventType(event.GetAction());
+  result.type = ToWebTouchEventType(event.GetAction());
   result.dispatchType = result.type == WebInputEvent::TouchCancel
                             ? WebInputEvent::EventNonBlocking
                             : WebInputEvent::Blocking;
   result.timeStampSeconds = ui::EventTimeStampToSeconds(event.GetEventTime());
   result.movedBeyondSlopRegion = moved_beyond_slop_region;
+
   result.modifiers = EventFlagsToWebEventModifiers(event.GetFlags());
+  // TODO(mustaq): MotionEvent flags seems unrelated, should use
+  // metaState instead?
+
   DCHECK_NE(event.GetUniqueEventId(), 0U);
   result.uniqueTouchEventId = event.GetUniqueEventId();
   result.touchesLength =
       std::min(static_cast<unsigned>(event.GetPointerCount()),
                static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap));
   DCHECK_GT(result.touchesLength, 0U);
 
   for (size_t i = 0; i < result.touchesLength; ++i)
     result.touches[i] = CreateWebTouchPoint(event, i);
 
@@ skipping 282 matching lines @@
         break;
 
       // TODO(oshima): Find out if ContextMenu needs to be scaled.
       default:
         break;
     }
   }
   return scaled_event;
 }
 
-WebPointerProperties::PointerType ToWebPointerType(
-    MotionEvent::ToolType tool_type) {
-  switch (tool_type) {
-    case MotionEvent::TOOL_TYPE_UNKNOWN:
-      return WebPointerProperties::PointerType::Unknown;
-    case MotionEvent::TOOL_TYPE_FINGER:
-      return WebPointerProperties::PointerType::Touch;
-    case MotionEvent::TOOL_TYPE_STYLUS:
-      return WebPointerProperties::PointerType::Pen;
-    case MotionEvent::TOOL_TYPE_MOUSE:
-      return WebPointerProperties::PointerType::Mouse;
-    case MotionEvent::TOOL_TYPE_ERASER:
-      return WebPointerProperties::PointerType::Eraser;
+WebInputEvent::Type ToWebMouseEventType(MotionEvent::Action action) {
+  switch (action) {
+    case MotionEvent::ACTION_DOWN:
+    case MotionEvent::ACTION_BUTTON_PRESS:
+      return WebInputEvent::MouseDown;
+    case MotionEvent::ACTION_MOVE:
+    case MotionEvent::ACTION_HOVER_MOVE:
+      return WebInputEvent::MouseMove;
+    case MotionEvent::ACTION_HOVER_ENTER:
+      return WebInputEvent::MouseEnter;
+    case MotionEvent::ACTION_HOVER_EXIT:
+      return WebInputEvent::MouseLeave;
+    case MotionEvent::ACTION_UP:
+    case MotionEvent::ACTION_BUTTON_RELEASE:
+      return WebInputEvent::MouseUp;
+    case MotionEvent::ACTION_NONE:
+    case MotionEvent::ACTION_CANCEL:
+    case MotionEvent::ACTION_POINTER_DOWN:
+    case MotionEvent::ACTION_POINTER_UP:
+      break;
   }
-  NOTREACHED() << "Invalid MotionEvent::ToolType = " << tool_type;
-  return WebPointerProperties::PointerType::Unknown;
+  NOTREACHED() << "Invalid MotionEvent::Action = " << action;
+  return WebInputEvent::Undefined;
+}
+
+void SetWebPointerPropertiesFromMotionEventData(
+    WebPointerProperties& webPointerProperties,
+    int pointer_id,
+    float pressure,
+    float orientation_rad,
+    float tilt_rad,
+    int android_buttons_changed,
+    int tool_type) {
+
+  webPointerProperties.id = pointer_id;
+  webPointerProperties.force = pressure;
+
+  if (tool_type == MotionEvent::TOOL_TYPE_STYLUS) {
+    // A stylus points to a direction specified by orientation and tilts to
+    // the opposite direction. Coordinate system is left-handed.
+    float r = sin(tilt_rad);
+    float z = cos(tilt_rad);
+    webPointerProperties.tiltX =
+        lround(atan2(sin(-orientation_rad) * r, z) * 180.f / M_PI);
+    webPointerProperties.tiltY =
+        lround(atan2(cos(-orientation_rad) * r, z) * 180.f / M_PI);
+  } else {
+    webPointerProperties.tiltX = webPointerProperties.tiltY = 0;
+  }
+
+  webPointerProperties.button = ToWebPointerButton(android_buttons_changed);
+  webPointerProperties.pointerType = ToWebPointerType(tool_type);
 }
 
 int WebEventModifiersToEventFlags(int modifiers) {
   int flags = 0;
 
   if (modifiers & blink::WebInputEvent::ShiftKey)
     flags |= EF_SHIFT_DOWN;
   if (modifiers & blink::WebInputEvent::ControlKey)
     flags |= EF_CONTROL_DOWN;
   if (modifiers & blink::WebInputEvent::AltKey)
@@ skipping 26 matching lines @@
       return blink::WebInputEvent::IsRight;
     case DomKeyLocation::NUMPAD:
       return blink::WebInputEvent::IsKeyPad;
     case DomKeyLocation::STANDARD:
       break;
   }
   return static_cast<blink::WebInputEvent::Modifiers>(0);
 }
 
 }  // namespace ui