Add EventForwarder for routing touch events

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>
 
 #include "base/android/jni_android.h"
 #include "jni/MotionEvent_jni.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 
 using base::android::AttachCurrentThread;
+using base::android::ScopedJavaLocalRef;
 using namespace JNI_MotionEvent;
 
 namespace ui {
 namespace {
 
 MotionEventAndroid::Action FromAndroidAction(int android_action) {
   switch (android_action) {
     case ACTION_DOWN:
       return MotionEventAndroid::ACTION_DOWN;
     case ACTION_UP:
@@ skipping 153 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_action_button,
                                        jint android_button_state,
                                        jint android_meta_state,
                                        jfloat raw_offset_x_pixels,
                                        jfloat raw_offset_y_pixels,
                                        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_action_button_(android_action_button),
       cached_button_state_(FromAndroidButtonState(android_button_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(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);
   if (cached_pointer_count_ > 1)
     cached_pointers_[1] = FromAndroidPointer(*pointer1);
 }
 
+MotionEventAndroid::MotionEventAndroid(const MotionEventAndroid& e)
+    : event_(e.event_),
+      pix_to_dip_(e.pix_to_dip_),
+      cached_time_(e.cached_time_),
+      cached_action_(e.cached_action_),
+      cached_pointer_count_(e.cached_pointer_count_),
+      cached_history_size_(e.cached_history_size_),
+      cached_action_index_(e.cached_action_index_),
+      cached_action_button_(e.cached_action_button_),
+      cached_button_state_(e.cached_button_state_),
+      cached_flags_(e.cached_flags_),
+      cached_raw_position_offset_(e.cached_raw_position_offset_),
+      unique_event_id_(ui::GetNextTouchEventId()) {
+  for (size_t i = 0; i < cached_pointer_count_; i++)
+    cached_pointers_[i] = e.cached_pointers_[i];
+}
+
+std::unique_ptr<MotionEventAndroid> MotionEventAndroid::Offset(float x,
+                                                               float y) const {
+  std::unique_ptr<MotionEventAndroid> event(new MotionEventAndroid(*this));
+  for (size_t i = 0; i < cached_pointer_count_; i++) {
+    event->cached_pointers_[i] = OffsetCachedPointer(cached_pointers_[i], x, y);
+  }
+  return event;
+}
+
 MotionEventAndroid::~MotionEventAndroid() {
 }
 
 uint32_t MotionEventAndroid::GetUniqueEventId() const {
   return unique_event_id_;
 }
 
 MotionEventAndroid::Action MotionEventAndroid::GetAction() const {
   return cached_action_;
 }
 
+int MotionEventAndroid::GetActionButton() const {
+  return cached_action_button_;
+}
+
+ScopedJavaLocalRef<jobject> MotionEventAndroid::GetJavaObject() const {
+  return ScopedJavaLocalRef<jobject>(event_);
+}
+
 int MotionEventAndroid::GetActionIndex() const {
   DCHECK(cached_action_ == MotionEvent::ACTION_POINTER_UP ||
          cached_action_ == MotionEvent::ACTION_POINTER_DOWN)
       << "Invalid action for GetActionIndex(): " << cached_action_;
   DCHECK_GE(cached_action_index_, 0);
   DCHECK_LT(cached_action_index_, static_cast<int>(cached_pointer_count_));
   return cached_action_index_;
 }
 
 size_t MotionEventAndroid::GetPointerCount() const {
@@ skipping 140 matching lines @@
   result.position =
       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
+MotionEventAndroid::CachedPointer MotionEventAndroid::OffsetCachedPointer(
+    const CachedPointer& pointer,
+    float x,
+    float y) const {
+  CachedPointer result;
+  result.id = pointer.id;
+  result.position = gfx::PointF(pointer.position.x() + ToDips(x),
+                                pointer.position.y() + ToDips(y));
+  result.touch_major = pointer.touch_major;
+  result.touch_minor = pointer.touch_minor;
+  result.orientation = pointer.orientation;
+  result.tilt = pointer.tilt;
+  result.tool_type = pointer.tool_type;
+  return result;
+}
+
+}  // namespace ui