Android mouse events shouldn't appear as TouchEvents

ui/events/android/motion_event_android.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/android/motion_event_android.h"
 
 #include <android/input.h>
 
 #include <cmath>
 
@@ skipping 60 matching lines @@
     result |= MotionEventAndroid::BUTTON_SECONDARY;
   if ((button_state & BUTTON_TERTIARY) != 0)
     result |= MotionEventAndroid::BUTTON_TERTIARY;
   if ((button_state & BUTTON_STYLUS_PRIMARY) != 0)
     result |= MotionEventAndroid::BUTTON_STYLUS_PRIMARY;
   if ((button_state & BUTTON_STYLUS_SECONDARY) != 0)
     result |= MotionEventAndroid::BUTTON_STYLUS_SECONDARY;
   return result;
 }
 
-int FromAndroidMetaState(int meta_state) {
+int ToEventFlags(int meta_state, int button_state) {
   int flags = ui::EF_NONE;
+
   if ((meta_state & AMETA_SHIFT_ON) != 0)
     flags |= ui::EF_SHIFT_DOWN;
   if ((meta_state & AMETA_CTRL_ON) != 0)
     flags |= ui::EF_CONTROL_DOWN;
   if ((meta_state & AMETA_ALT_ON) != 0)
     flags |= ui::EF_ALT_DOWN;
   if ((meta_state & AMETA_META_ON) != 0)
     flags |= ui::EF_COMMAND_DOWN;
   if ((meta_state & AMETA_CAPS_LOCK_ON) != 0)
     flags |= ui::EF_CAPS_LOCK_ON;
+
+  if ((button_state & BUTTON_BACK) != 0)
+    flags |= ui::EF_BACK_MOUSE_BUTTON;
+  if ((button_state & BUTTON_FORWARD) != 0)
+    flags |= ui::EF_FORWARD_MOUSE_BUTTON;
+  if ((button_state & BUTTON_PRIMARY) != 0)
+    flags |= ui::EF_LEFT_MOUSE_BUTTON;
+  if ((button_state & BUTTON_SECONDARY) != 0)
+    flags |= ui::EF_RIGHT_MOUSE_BUTTON;
+  if ((button_state & BUTTON_TERTIARY) != 0)
+    flags |= ui::EF_MIDDLE_MOUSE_BUTTON;
+  if ((button_state & BUTTON_STYLUS_PRIMARY) != 0)
+    flags |= ui::EF_LEFT_MOUSE_BUTTON;
+  if ((button_state & BUTTON_STYLUS_SECONDARY) != 0)
+    flags |= ui::EF_RIGHT_MOUSE_BUTTON;
+
   return flags;
 }
 
 base::TimeTicks FromAndroidTime(int64_t time_ms) {
   return base::TimeTicks() + base::TimeDelta::FromMilliseconds(time_ms);
 }
 
 float ToValidFloat(float x) {
   if (std::isnan(x))
     return 0.f;
@@ skipping 49 matching lines @@
 
 MotionEventAndroid::MotionEventAndroid(float pix_to_dip,
                                        JNIEnv* env,
                                        jobject event,
                                        jlong time_ms,
                                        jint android_action,
                                        jint pointer_count,
                                        jint history_size,
                                        jint action_index,
                                        jint android_button_state,
-                                       jint meta_state,
+                                       jint android_meta_state,
                                        jfloat raw_offset_x_pixels,
                                        jfloat raw_offset_y_pixels,
-                                       const Pointer& pointer0,
-                                       const Pointer& pointer1)
+                                       const Pointer* const pointer0,
+                                       const Pointer* const pointer1)
     : pix_to_dip_(pix_to_dip),
       cached_time_(FromAndroidTime(time_ms)),
       cached_action_(FromAndroidAction(android_action)),
       cached_pointer_count_(pointer_count),
       cached_history_size_(ToValidHistorySize(history_size, cached_action_)),
       cached_action_index_(action_index),
       cached_button_state_(FromAndroidButtonState(android_button_state)),
-      cached_flags_(FromAndroidMetaState(meta_state)),
+      cached_flags_(ToEventFlags(android_meta_state, android_button_state)),
       cached_raw_position_offset_(ToDips(raw_offset_x_pixels),
                                   ToDips(raw_offset_y_pixels)),
       unique_event_id_(ui::GetNextTouchEventId()) {
-  DCHECK_GT(pointer_count, 0);
+  DCHECK_GT(cached_pointer_count_, 0U);
+  DCHECK(cached_pointer_count_ == 1 || pointer1);
 
   event_.Reset(env, event);
   if (cached_pointer_count_ > MAX_POINTERS_TO_CACHE || cached_history_size_ > 0)
     DCHECK(event_.obj());
 
-  cached_pointers_[0] = FromAndroidPointer(pointer0);
-  cached_pointers_[1] = FromAndroidPointer(pointer1);
+  cached_pointers_[0] = FromAndroidPointer(*pointer0);
+  if (cached_pointer_count_ > 1)

[aelias_OOO_until_Jul13, 2016/10/20 23:26:29]

This looks kind of weird (I understand you expect this value to be exactly 2?). 
Could you replace this with a for loop up to cached_pointer_count_?  You would
also need to replace the arguments passed in to this method with an array
pointers[MAX_POINTERS_TO_CACHE].

[mustaq, 2016/10/21 19:19:08]

Just realized that the name is a bit confusing here: it is the cached value of
pointer-count, not the count of cached-pointers! The name was there before, and
I didn't see the second interpretation until your comment.

So cached_pointer_count_ can be any value supported by the platform (e.g. 3 for
a three finger interaction). The parameters of upto 2 pointers are cached in
this C++ class to save jni round trips. Accessing the parameters of the 3rd or a
later pointer causes jni calls; see MotionEventAndroid::GetPointerId().

Do you still prefer passing an array of size 2, instead of two params?

[aelias_OOO_until_Jul13, 2016/10/21 21:26:54]

OK then, fine as is.

+    cached_pointers_[1] = FromAndroidPointer(*pointer1);
 }
 
 MotionEventAndroid::~MotionEventAndroid() {
 }
 
 uint32_t MotionEventAndroid::GetUniqueEventId() const {
   return unique_event_id_;
 }
 
 MotionEventAndroid::Action MotionEventAndroid::GetAction() const {
@@ skipping 152 matching lines @@
       gfx::PointF(ToDips(pointer.pos_x_pixels), ToDips(pointer.pos_y_pixels));
   result.touch_major = ToDips(pointer.touch_major_pixels);
   result.touch_minor = ToDips(pointer.touch_minor_pixels);
   result.orientation = ToValidFloat(pointer.orientation_rad);
   result.tilt = ToValidFloat(pointer.tilt_rad);
   result.tool_type = FromAndroidToolType(pointer.tool_type);
   return result;
 }
 
 }  // namespace content