[Android] Composited selection handle rendering

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 128 matching lines @@
   cached_touch_majors_[1] = ToDips(touch_major_1_pixels);
   cached_raw_position_offset_ =
       ToDips(gfx::PointF(raw_pos_x_pixels, raw_pos_y_pixels)) -
       cached_positions_[0];
   cached_tool_types_[0] = FromAndroidToolType(android_tool_type_0);
   cached_tool_types_[1] = FromAndroidToolType(android_tool_type_1);
 }
 
 MotionEventAndroid::MotionEventAndroid(float pix_to_dip,
                                        JNIEnv* env,
-                                       jobject event)
+                                       jobject event,
+                                       bool should_recycle)

[cjhopman, 2014/07/09 22:29:12]

So this constructor makes like ~16 jni calls (and was private to make you use
the one that doesn't require any jni calls).

Passing around ~20 arguments (especially ones that can be so easily swapped
without compile failure) is incredibly ugly, though.

I don't know if we should be making this public and using it.

One possible way to avoid all the jni calls would be to call up to a java method
passing the event that then calls back down to native unpacking all the event
fields into args.

[jdduke (slow), 2014/07/10 02:08:39]

Agreed, I'll take a closer look at this.  I think there's a way to avoid this
additional public path that's probably for the best. 

     : 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))),
       pix_to_dip_(pix_to_dip),
-      should_recycle_(true) {
+      should_recycle_(should_recycle) {
   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)));
       cached_pointer_ids_[i] = Java_MotionEvent_getPointerId(env, event, i);
       cached_touch_majors_[i] =
@@ skipping 148 matching lines @@
 
 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_);
+  const bool recycle = true;
   return scoped_ptr<MotionEvent>(
       new MotionEventAndroid(pix_to_dip_,
                              AttachCurrentThread(),
                              Obtain(GetDownTime(),
                                     GetEventTime(),
                                     MotionEventAndroid::ACTION_CANCEL,
                                     position_pixels.x(),
-                                    position_pixels.y()).obj()));
+                                    position_pixels.y()).obj(),
+                             recycle));
 }
 
 float MotionEventAndroid::GetTouchMinor(size_t pointer_index) const {
   return ToDips(Java_MotionEvent_getTouchMinorF_I(
       AttachCurrentThread(), event_.obj(), pointer_index));
 }
 
 float MotionEventAndroid::GetOrientation() const {
   return Java_MotionEvent_getOrientationF(AttachCurrentThread(), event_.obj());
 }
@@ skipping 33 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