Add modifier flags to MotionEvent

content/browser/renderer_host/input/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 "content/browser/renderer_host/input/motion_event_android.h"
 
+#include <android/input.h>
+
 #include "base/android/jni_android.h"
 #include "base/float_util.h"
 #include "jni/MotionEvent_jni.h"
+#include "ui/events/event_constants.h"
 
 using base::android::AttachCurrentThread;
 using namespace JNI_MotionEvent;
 
 namespace content {
 namespace {
 
 int ToAndroidAction(MotionEventAndroid::Action action) {
   switch (action) {
     case MotionEventAndroid::ACTION_DOWN:
@@ skipping 62 matching lines @@
     result |= MotionEventAndroid::BUTTON_FORWARD;
   if ((button_state & BUTTON_PRIMARY) != 0)
     result |= MotionEventAndroid::BUTTON_PRIMARY;
   if ((button_state & BUTTON_SECONDARY) != 0)
     result |= MotionEventAndroid::BUTTON_SECONDARY;
   if ((button_state & BUTTON_TERTIARY) != 0)
     result |= MotionEventAndroid::BUTTON_TERTIARY;
   return result;
 }
 
+int FromAndroidMetaState(int meta_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_DOWN;
+  return flags;
+}
+
 int64 ToAndroidTime(base::TimeTicks time) {
   return (time - base::TimeTicks()).InMilliseconds();
 }
 
 base::TimeTicks FromAndroidTime(int64 time_ms) {
   return base::TimeTicks() + base::TimeDelta::FromMilliseconds(time_ms);
 }
 
 float ToValidFloat(float x) {
   return base::IsNaN(x) ? 0.f : x;
@@ skipping 18 matching lines @@
                                        jfloat touch_major_0_pixels,
                                        jfloat touch_major_1_pixels,
                                        jfloat touch_minor_0_pixels,
                                        jfloat touch_minor_1_pixels,
                                        jfloat orientation_0_rad,
                                        jfloat orientation_1_rad,
                                        jfloat raw_pos_x_pixels,
                                        jfloat raw_pos_y_pixels,
                                        jint android_tool_type_0,
                                        jint android_tool_type_1,
-                                       jint android_button_state)
+                                       jint android_button_state,
+                                       jint meta_state)
     : cached_time_(FromAndroidTime(time_ms)),
       cached_action_(FromAndroidAction(android_action)),
       cached_pointer_count_(pointer_count),
       cached_history_size_(history_size),
       cached_action_index_(action_index),
       cached_button_state_(FromAndroidButtonState(android_button_state)),
+      cached_flags_(FromAndroidMetaState(meta_state)),
       pix_to_dip_(pix_to_dip),
       should_recycle_(false) {
   DCHECK_GT(pointer_count, 0);
   DCHECK_GE(history_size, 0);
 
   event_.Reset(env, event);
   DCHECK(event_.obj());
 
   cached_positions_[0] = ToDips(gfx::PointF(pos_x_0_pixels, pos_y_0_pixels));
   cached_positions_[1] = ToDips(gfx::PointF(pos_x_1_pixels, pos_y_1_pixels));
@@ skipping 16 matching lines @@
                                        JNIEnv* env,
                                        jobject event)
     : cached_time_(FromAndroidTime(Java_MotionEvent_getEventTime(env, event))),
       cached_action_(
           FromAndroidAction(Java_MotionEvent_getActionMasked(env, event))),
       cached_pointer_count_(Java_MotionEvent_getPointerCount(env, event)),
       cached_history_size_(Java_MotionEvent_getHistorySize(env, event)),
       cached_action_index_(Java_MotionEvent_getActionIndex(env, event)),
       cached_button_state_(
           FromAndroidButtonState(Java_MotionEvent_getButtonState(env, event))),
+      cached_flags_(
+          FromAndroidMetaState(Java_MotionEvent_getMetaState(env, event))),
       pix_to_dip_(pix_to_dip),
       should_recycle_(true) {
   event_.Reset(env, event);
   DCHECK(event_.obj());
 
   for (size_t i = 0; i < MAX_POINTERS_TO_CACHE; ++i) {
     if (i < cached_pointer_count_) {
       cached_positions_[i] =
           ToDips(gfx::PointF(Java_MotionEvent_getXF_I(env, event, i),
                              Java_MotionEvent_getYF_I(env, event, i)));
@@ skipping 23 matching lines @@
 
 MotionEventAndroid::MotionEventAndroid(const MotionEventAndroid& other)
     : event_(Obtain(other)),
       cached_time_(other.cached_time_),
       cached_action_(other.cached_action_),
       cached_pointer_count_(other.cached_pointer_count_),
       cached_history_size_(other.cached_history_size_),
       cached_action_index_(other.cached_action_index_),
       cached_raw_position_offset_(other.cached_raw_position_offset_),
       cached_button_state_(other.cached_button_state_),
+      cached_flags_(other.cached_flags_),
       pix_to_dip_(other.pix_to_dip_),
       should_recycle_(true) {
   DCHECK(event_.obj());
   for (size_t i = 0; i < MAX_POINTERS_TO_CACHE; ++i) {
     cached_positions_[i] = other.cached_positions_[i];
     cached_pointer_ids_[i] = other.cached_pointer_ids_[i];
     cached_touch_majors_[i] = other.cached_touch_majors_[i];
     cached_touch_minors_[i] = other.cached_touch_minors_[i];
     cached_orientations_[i] = other.cached_orientations_[i];
     cached_tool_types_[i] = other.cached_tool_types_[i];
@@ skipping 122 matching lines @@
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_tool_types_[pointer_index];
   return FromAndroidToolType(Java_MotionEvent_getToolType(
       AttachCurrentThread(), event_.obj(), pointer_index));
 }
 
 int MotionEventAndroid::GetButtonState() const {
   return cached_button_state_;
 }
 
+int MotionEventAndroid::GetFlags() const {
+  return cached_flags_;
+}
+
 scoped_ptr<ui::MotionEvent> MotionEventAndroid::Clone() const {
   return scoped_ptr<MotionEvent>(new MotionEventAndroid(*this));
 }
 
 scoped_ptr<ui::MotionEvent> MotionEventAndroid::Cancel() const {
   // The input coordinates to |MotionEventAndroid| are always in device pixels,
   // but the cached coordinates are in DIPs.
   const gfx::PointF position_pixels =
       gfx::ScalePoint(cached_positions_[0], 1.f / pix_to_dip_);
   return scoped_ptr<MotionEvent>(
@@ skipping 41 matching lines @@
   return Java_MotionEvent_obtainAVME_J_J_I_F_F_I(AttachCurrentThread(),
                                                  ToAndroidTime(down_time),
                                                  ToAndroidTime(event_time),
                                                  ToAndroidAction(action),
                                                  x_pixels,
                                                  y_pixels,
                                                  0);
 }
 
 }  // namespace content