[Tracking Patch] Unified gesture detection

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 "base/android/jni_android.h"
 #include "jni/MotionEvent_jni.h"
 
 using base::android::AttachCurrentThread;
@@ skipping 21 matching lines @@
 int64 ToAndroidTime(base::TimeTicks time) {
   return (time - base::TimeTicks()).InMilliseconds();
 }
 
 base::TimeTicks FromAndroidTime(int64 time_ms) {
   return base::TimeTicks() + base::TimeDelta::FromMilliseconds(time_ms);
 }
 
 }  // namespace
 
-MotionEventAndroid::MotionEventAndroid(jobject event)
-    : should_recycle_(false) {
-  event_.Reset(AttachCurrentThread(), event);
+MotionEventAndroid::MotionEventAndroid(JNIEnv* env,
+                                       jobject event,
+                                       bool should_recycle)
+    : 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_x_(Java_MotionEvent_getXF(env, event)),
+      cached_y_(Java_MotionEvent_getYF(env, event)),
+      should_recycle_(should_recycle) {
+  event_.Reset(env, event);
   DCHECK(event_.obj());
 }
 
-MotionEventAndroid::MotionEventAndroid(
-    const base::android::ScopedJavaLocalRef<jobject>& event,
-    bool should_recycle)
-    : event_(event),
-      should_recycle_(should_recycle) {
-  DCHECK(event_.obj());
+MotionEventAndroid::MotionEventAndroid(const MotionEventAndroid& other)
+    : event_(other.event_),
+      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_x_(other.cached_x_),
+      cached_y_(other.cached_y_),
+      should_recycle_(false) {
+  // An event with a pending recycle should never be copied (only cloned).
+  // TODO(jdduke): Determine if we should support this, and if so, go ahead
+  // perform the implicit clone.
+  DCHECK(!other.should_recycle_);
+}
+
+MotionEventAndroid& MotionEventAndroid::operator=(
+    const MotionEventAndroid& other) {
+  if (should_recycle_)
+    Java_MotionEvent_recycle(AttachCurrentThread(), event_.obj());
+
+  DCHECK(!other.should_recycle_);
+  event_.Reset(other.event_);
+  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_x_ = other.cached_x_;
+  cached_y_ = other.cached_y_;
+  should_recycle_ = false;
+  return *this;
 }
 
 MotionEventAndroid::~MotionEventAndroid() {
   if (should_recycle_)
     Java_MotionEvent_recycle(AttachCurrentThread(), event_.obj());
 }
 
 MotionEventAndroid::Action MotionEventAndroid::GetActionMasked() const {
-  return FromAndroidAction(
-      Java_MotionEvent_getActionMasked(AttachCurrentThread(), event_.obj()));
+  return cached_action_;
 }
 
-size_t MotionEventAndroid::GetActionIndex() const {
-  return Java_MotionEvent_getActionIndex(AttachCurrentThread(), event_.obj());
+int MotionEventAndroid::GetActionIndex() const {
+  return cached_action_index_;
 }
 
 size_t MotionEventAndroid::GetPointerCount() const {
-  return Java_MotionEvent_getPointerCount(AttachCurrentThread(), event_.obj());
+  return cached_pointer_count_;
 }
 
 int MotionEventAndroid::GetPointerId(size_t pointer_index) const {
   return Java_MotionEvent_getPointerId(
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
 float MotionEventAndroid::GetPressure(size_t pointer_index) const {
   return Java_MotionEvent_getPressureF_I(
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
 float MotionEventAndroid::GetX(size_t pointer_index) const {
+  if (pointer_index == 0)
+    return cached_x_;
   return Java_MotionEvent_getXF_I(
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
 float MotionEventAndroid::GetY(size_t pointer_index) const {
+  if (pointer_index == 0)
+    return cached_y_;
   return Java_MotionEvent_getYF_I(
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
 float MotionEventAndroid::GetTouchMajor(size_t pointer_index) const {
   return Java_MotionEvent_getTouchMajorF_I(
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
 float MotionEventAndroid::GetTouchMinor(size_t pointer_index) const {
   return Java_MotionEvent_getTouchMinorF_I(
       AttachCurrentThread(), event_.obj(), pointer_index);
 }
 
 float MotionEventAndroid::GetOrientation() const {
   return Java_MotionEvent_getOrientationF(AttachCurrentThread(), event_.obj());
 }
 
 base::TimeTicks MotionEventAndroid::GetEventTime() const {
-  return FromAndroidTime(
-      Java_MotionEvent_getEventTime(AttachCurrentThread(), event_.obj()));
+  return cached_time_;
 }
 
 base::TimeTicks MotionEventAndroid::GetDownTime() const {
   return FromAndroidTime(
       Java_MotionEvent_getDownTime(AttachCurrentThread(), event_.obj()));
 }
 
 size_t MotionEventAndroid::GetHistorySize() const {
-  return Java_MotionEvent_getHistorySize(AttachCurrentThread(), event_.obj());
+  return cached_history_size_;
 }
 
 base::TimeTicks MotionEventAndroid::GetHistoricalEventTime(
     size_t historical_index) const {
   return FromAndroidTime(Java_MotionEvent_getHistoricalEventTime(
       AttachCurrentThread(), event_.obj(), historical_index));
 }
 
 float MotionEventAndroid::GetHistoricalTouchMajor(size_t pointer_index,
                                                   size_t historical_index)
@@ skipping 13 matching lines @@
   return Java_MotionEvent_getHistoricalYF_I_I(
       AttachCurrentThread(), event_.obj(), pointer_index, historical_index);
 }
 
 // static
 bool MotionEventAndroid::RegisterMotionEventAndroid(JNIEnv* env) {
   return JNI_MotionEvent::RegisterNativesImpl(env);
 }
 
 // static
-scoped_ptr<MotionEventAndroid> MotionEventAndroid::Obtain(
+base::android::ScopedJavaLocalRef<jobject> MotionEventAndroid::Obtain(
     const MotionEventAndroid& event) {
-  return make_scoped_ptr(new MotionEventAndroid(
-      Java_MotionEvent_obtainAVME_AVME(AttachCurrentThread(),
-                                       event.event_.obj()),
-      true));
+  return Java_MotionEvent_obtainAVME_AVME(AttachCurrentThread(),
+                                          event.event_.obj());
 }
 
 // static
-scoped_ptr<MotionEventAndroid> MotionEventAndroid::Obtain(
+base::android::ScopedJavaLocalRef<jobject> MotionEventAndroid::Obtain(
     base::TimeTicks down_time,
     base::TimeTicks event__time,
     Action action,
     float x,
     float y) {
-  return make_scoped_ptr(new MotionEventAndroid(
-      Java_MotionEvent_obtainAVME_J_J_I_F_F_I(AttachCurrentThread(),
-                                              ToAndroidTime(down_time),
-                                              ToAndroidTime(down_time),
-                                              action,
-                                              x,
-                                              y,
-                                              0),
-      true));
+  return Java_MotionEvent_obtainAVME_J_J_I_F_F_I(AttachCurrentThread(),
+                                                 ToAndroidTime(down_time),
+                                                 ToAndroidTime(down_time),
+                                                 action,
+                                                 x,
+                                                 y,
+                                                 0);
 }
 
 }  // namespace content