[Android] Short-circuit touch forwarding when no touch handlers exist

content/browser/android/content_view_core_impl.cc

 // Copyright 2012 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/android/content_view_core_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
@@ skipping 1010 matching lines @@
   if (!rwhv)
     return;
 
   const ui::MotionEvent* current_down_event =
       gesture_provider_.GetCurrentDownEvent();
   if (!current_down_event)
     return;
 
   scoped_ptr<ui::MotionEvent> cancel_event = current_down_event->Cancel();
   DCHECK(cancel_event);
-  if (!gesture_provider_.OnTouchEvent(*cancel_event))
-    return;
-
-  rwhv->SendTouchEvent(
-      CreateWebTouchEventFromMotionEvent(*cancel_event, 1.f / dpi_scale()));
+  OnMotionEvent(*cancel_event);
 }
 
 jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
                                            jobject obj,
                                            jobject motion_event,
                                            jlong time_ms,
                                            jint android_action,
                                            jint pointer_count,
                                            jint history_size,
                                            jint action_index,
                                            jfloat pos_x_0,
                                            jfloat pos_y_0,
                                            jfloat pos_x_1,
                                            jfloat pos_y_1,
                                            jint pointer_id_0,
                                            jint pointer_id_1,
                                            jfloat touch_major_0,
                                            jfloat touch_major_1) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  // Avoid synthesizing a touch event if it cannot be forwarded.
   if (!rwhv)
     return false;
 
   MotionEventAndroid event(env,
                            motion_event,
                            time_ms,
                            android_action,
                            pointer_count,
                            history_size,
                            action_index,
                            pos_x_0,
                            pos_y_0,
                            pos_x_1,
                            pos_y_1,
                            pointer_id_0,
                            pointer_id_1,
                            touch_major_0,
                            touch_major_1);
 
-  if (!gesture_provider_.OnTouchEvent(event))
-    return false;
-
-  rwhv->SendTouchEvent(WebTouchEventBuilder::Build(event, 1.f / dpi_scale()));
-  return true;
+  return OnMotionEvent(event);
 }
 
 float ContentViewCoreImpl::GetDpiScale() const {
   return dpi_scale_;
 }
 
 jboolean ContentViewCoreImpl::SendMouseMoveEvent(JNIEnv* env,
                                                  jobject obj,
                                                  jlong time_ms,
                                                  jfloat x,
@@ skipping 35 matching lines @@
   rwhv->SendMouseWheelEvent(event);
   return true;
 }
 
 WebGestureEvent ContentViewCoreImpl::MakeGestureEvent(
     WebInputEvent::Type type, int64 time_ms, float x, float y) const {
   return WebGestureEventBuilder::Build(
       type, time_ms / 1000.0, x / dpi_scale(), y / dpi_scale());
 }
 
+bool ContentViewCoreImpl::OnMotionEvent(const ui::MotionEvent& event) {
+  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  if (!rwhv)
+    return false;
+
+  if (!gesture_provider_.OnTouchEvent(event))
+    return false;
+
+  // If there are no touch handlers and the touch queue is empty, touch
+  // forwarding can be short-circuited completely.

[tdresser, 2014/03/28 17:55:27]

It feels like this comment is breaking encapsulation by referring to
implementation details of the input router.

Would it be reasonable to reword this more along the lines of "If we don't need
to forward the event to the RWHI, touch forwarding can be short-circuited
completely."

[jdduke (slow), 2014/03/28 18:33:55]

Yes, though in my mind those details are vital to understanding why we can allow
this.  However, I suppose if a dev is interested enough in the way they can
refer to the implementation :) In that case, I'll just remove the comment.

[tdresser, 2014/03/28 18:40:05]

SGTM.

+  RenderWidgetHostImpl* host = RenderWidgetHostImpl::From(
+      rwhv->GetRenderWidgetHost());
+  if (!host->ShouldForwardTouchEvent()) {
+    ConfirmTouchEvent(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+    return true;
+  }
+
+  rwhv->SendTouchEvent(
+      CreateWebTouchEventFromMotionEvent(event, 1.f / dpi_scale()));
+  return true;
+}
+
 void ContentViewCoreImpl::SendGestureEvent(
     const blink::WebGestureEvent& event) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (rwhv)
     rwhv->SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::ScrollBegin(JNIEnv* env,
                                       jobject obj,
                                       jlong time_ms,
@@ skipping 638 matching lines @@
       reinterpret_cast<ui::ViewAndroid*>(view_android),
       reinterpret_cast<ui::WindowAndroid*>(window_android));
   return reinterpret_cast<intptr_t>(view);
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content