[Android] Perform eager gesture recognition on MotionEvents

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 15 matching lines @@
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/input/web_input_event_builders_android.h"
 #include "content/browser/renderer_host/java/java_bound_object.h"
 #include "content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/browser/ssl/ssl_host_state.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
+#include "content/common/input/web_input_event_traits.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 57 matching lines @@
     JNIEnv* env,
     const gfx::Rect& rect) {
   return ScopedJavaLocalRef<jobject>(
       Java_ContentViewCore_createRect(env,
                                       static_cast<int>(rect.x()),
                                       static_cast<int>(rect.y()),
                                       static_cast<int>(rect.right()),
                                       static_cast<int>(rect.bottom())));
 }
 
+bool PossiblyTriggeredByTouchTimeout(const WebGestureEvent& event) {
+  switch (event.type) {
+    case WebInputEvent::GestureShowPress:
+    case WebInputEvent::GestureLongPress:
+      return true;
+    // On Android, a GestureTap may be sent after a certain timeout window
+    // if there is no GestureDoubleTap follow-up.
+    case WebInputEvent::GestureTap:
+      return true;
+    // On Android, a GestureTapCancel may be triggered by the loss of window
+    //  focus (e.g., following a GestureLongPress).
+    case WebInputEvent::GestureTapCancel:
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+int ToContentViewGestureHandlerType(WebInputEvent::Type type) {
+  // These values should match exactly those in ContentViewGestureHandler.
+  enum ContentViewGestureHandlerType {
+    GESTURE_SHOW_PRESS = 0,
+    GESTURE_DOUBLE_TAP = 1,
+    GESTURE_SINGLE_TAP_UP = 2,
+    GESTURE_SINGLE_TAP_CONFIRMED = 3,
+    GESTURE_SINGLE_TAP_UNCONFIRMED = 4,
+    GESTURE_LONG_PRESS = 5,
+    GESTURE_SCROLL_START = 6,
+    GESTURE_SCROLL_BY = 7,
+    GESTURE_SCROLL_END = 8,
+    GESTURE_FLING_START = 9,
+    GESTURE_FLING_CANCEL = 10,
+    GESTURE_PINCH_BEGIN = 11,
+    GESTURE_PINCH_BY = 12,
+    GESTURE_PINCH_END = 13,
+    GESTURE_TAP_CANCEL = 14,
+    GESTURE_LONG_TAP = 15,
+    GESTURE_TAP_DOWN = 16
+  };
+  switch (type) {
+    case WebInputEvent::GestureScrollBegin:
+      return GESTURE_SCROLL_START;
+    case WebInputEvent::GestureScrollEnd:
+      return GESTURE_SCROLL_END;
+    case WebInputEvent::GestureScrollUpdate:
+      return GESTURE_SCROLL_BY;
+    case WebInputEvent::GestureFlingStart:
+      return GESTURE_FLING_START;
+    case WebInputEvent::GestureFlingCancel:
+      return GESTURE_FLING_CANCEL;
+    case WebInputEvent::GestureShowPress:
+      return GESTURE_SHOW_PRESS;
+    case WebInputEvent::GestureTap:
+      return GESTURE_SINGLE_TAP_CONFIRMED;
+    case WebInputEvent::GestureTapUnconfirmed:
+      return GESTURE_SINGLE_TAP_UNCONFIRMED;
+    case WebInputEvent::GestureTapDown:
+      return GESTURE_TAP_DOWN;
+    case WebInputEvent::GestureTapCancel:
+      return GESTURE_TAP_CANCEL;
+    case WebInputEvent::GestureDoubleTap:
+      return GESTURE_DOUBLE_TAP;
+    case WebInputEvent::GestureLongPress:
+      return GESTURE_LONG_PRESS;
+    case WebInputEvent::GestureLongTap:
+      return GESTURE_LONG_TAP;
+    case WebInputEvent::GesturePinchBegin:
+      return GESTURE_PINCH_BEGIN;
+    case WebInputEvent::GesturePinchEnd:
+      return GESTURE_PINCH_END;
+    case WebInputEvent::GesturePinchUpdate:
+      return GESTURE_PINCH_BY;
+    case WebInputEvent::GestureTwoFingerTap:
+    case WebInputEvent::GestureScrollUpdateWithoutPropagation:
+    default:
+      NOTREACHED() << "Invalid source gesture type: "
+                   << WebInputEventTraits::GetName(type);
+      return -1;
+  };
+}
+
 }  // namespace
 
 // Enables a callback when the underlying WebContents is destroyed, to enable
 // nulling the back-pointer.
 class ContentViewCoreImpl::ContentViewUserData
     : public base::SupportsUserData::Data {
  public:
   explicit ContentViewUserData(ContentViewCoreImpl* content_view_core)
       : content_view_core_(content_view_core) {
   }
@@ skipping 46 matching lines @@
       java_ref_(env, obj),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       root_layer_(cc::Layer::Create()),
       vsync_interval_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros)),
       expected_browser_composite_time_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros * kDefaultBrowserCompositeVSyncFraction)),
       view_android_(view_android),
       window_android_(window_android),
       device_orientation_(0),
-      geolocation_needs_pause_(false) {
+      geolocation_needs_pause_(false),
+      gesture_event_queue_(this),
+      handling_touch_event_(false) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   dpi_scale_ = display.device_scale_factor();
 
   // Currently, the only use case we have for overriding a user agent involves
   // spoofing a desktop Linux user agent for "Request desktop site".
   // Automatically set it for all WebContents so that it is available when a
@@ skipping 105 matching lines @@
       break;
     }
   }
 }
 
 void ContentViewCoreImpl::RenderViewReady() {
   if (device_orientation_ != 0)
     SendOrientationChangeEventInternal();
 }
 
+void ContentViewCoreImpl::ForwardGestureEvent(
+    const blink::WebGestureEvent& event) {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
+  if (j_obj.is_null())
+    return;
+
+  if (!Java_ContentViewCore_onForwardingGestureEvent(
+          env, j_obj.obj(),
+          ToContentViewGestureHandlerType(event.type), event.x, event.y))
+    return;
+
+  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  if (rwhv)
+    rwhv->SendGestureEvent(event);
+}
+
 RenderWidgetHostViewAndroid*
     ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() {
   RenderWidgetHostView* rwhv = NULL;
   if (web_contents_) {
     rwhv = web_contents_->GetRenderWidgetHostView();
     if (web_contents_->ShowingInterstitialPage()) {
       rwhv = static_cast<InterstitialPageImpl*>(
           web_contents_->GetInterstitialPage())->
               GetRenderViewHost()->GetView();
     }
@@ skipping 173 matching lines @@
     env->SetIntArrayRegion(enabled_array.obj(), i, 1, &enabled);
   }
   ScopedJavaLocalRef<jobjectArray> items_array(
       base::android::ToJavaArrayOfStrings(env, labels));
   Java_ContentViewCore_showSelectPopup(env, j_obj.obj(),
                                        items_array.obj(), enabled_array.obj(),
                                        multiple, selected_array.obj());
 }
 
 void ContentViewCoreImpl::ConfirmTouchEvent(InputEventAckState ack_result) {
+  gesture_event_queue_.OnTouchEventAck(ack_result);
+}
+
+void ContentViewCoreImpl::OnUnhandledFlingStartEventAck(bool had_consumer,
+                                                        float vx,
+                                                        float vy) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
-  Java_ContentViewCore_confirmTouchEvent(env, j_obj.obj(),
-                                         static_cast<jint>(ack_result));
-}
-
-void ContentViewCoreImpl::OnFlingStartEventAck(InputEventAckState ack_result) {
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
-  if (j_obj.is_null())
-    return;
-  Java_ContentViewCore_onFlingStartEventAck(env, j_obj.obj(),
-                                            static_cast<jint>(ack_result));
+  Java_ContentViewCore_onUnhandledFlingStartEventAck(env, j_obj.obj(),
+                                                     had_consumer, vx, vy);
 }
 
 void ContentViewCoreImpl::OnScrollBeginEventAck() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
   Java_ContentViewCore_onScrollBeginEventAck(env, j_obj.obj());
 }
 
 void ContentViewCoreImpl::OnScrollUpdateGestureConsumed() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
   Java_ContentViewCore_onScrollUpdateGestureConsumed(env, j_obj.obj());
 }
 
 void ContentViewCoreImpl::OnScrollEndEventAck() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
   Java_ContentViewCore_onScrollEndEventAck(env, j_obj.obj());
 }
 
-void ContentViewCoreImpl::HasTouchEventHandlers(bool need_touch_events) {
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
-  if (j_obj.is_null())
-    return;
-  Java_ContentViewCore_hasTouchEventHandlers(env,
-                                             j_obj.obj(),
-                                             need_touch_events);
-}
-
 bool ContentViewCoreImpl::HasFocus() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
   return Java_ContentViewCore_hasFocus(env, obj.obj());
 }
 
 void ContentViewCoreImpl::OnSelectionChanged(const std::string& text) {
   JNIEnv* env = AttachCurrentThread();
@@ skipping 353 matching lines @@
 
 void ContentViewCoreImpl::SendOrientationChangeEvent(JNIEnv* env,
                                                      jobject obj,
                                                      jint orientation) {
   if (device_orientation_ != orientation) {
     device_orientation_ = orientation;
     SendOrientationChangeEventInternal();
   }
 }
 
-jboolean ContentViewCoreImpl::SendTouchEvent(JNIEnv* env,
-                                             jobject obj,
-                                             jlong time_ms,
-                                             jint type,
-                                             jobjectArray pts) {
+void ContentViewCoreImpl::OnTouchEventHandlingBegin(JNIEnv* env,
+                                                    jobject obj,
+                                                    jlong time_ms,
+                                                    jint type,
+                                                    jobjectArray pts) {
+  DCHECK(!handling_touch_event_);
+  handling_touch_event_ = true;
+
+  blink::WebTouchEvent event;
+  TouchPoint::BuildWebTouchEvent(env, type, time_ms, GetDpiScale(), pts, event);
+  pending_touch_event_ = event;
+
+  pending_gesture_packet_ = GestureEventPacket::FromTouch(event);
+}
+
+void ContentViewCoreImpl::OnTouchEventHandlingEnd(JNIEnv* env, jobject obj) {
+  DCHECK(handling_touch_event_);
+  handling_touch_event_ = false;
+
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
-  if (rwhv) {
-    using blink::WebTouchEvent;
-    blink::WebTouchEvent event;
-    TouchPoint::BuildWebTouchEvent(env, type, time_ms, GetDpiScale(), pts,
-        event);
-    rwhv->SendTouchEvent(event);
-    return true;
-  }
-  return false;
+  if (!rwhv)
+    return;
+
+  // Note: Order is important here, as the touch may be ack'ed synchronously
+  gesture_event_queue_.OnGestureEventPacket(pending_gesture_packet_);
+  rwhv->SendTouchEvent(pending_touch_event_);
 }
 
 float ContentViewCoreImpl::GetTouchPaddingDip() {
   return 48.0f / GetDpiScale();
 }
 
 float ContentViewCoreImpl::GetDpiScale() const {
   return dpi_scale_;
 }
 
@@ skipping 49 matching lines @@
 }
 
 WebGestureEvent ContentViewCoreImpl::MakeGestureEvent(
     WebInputEvent::Type type, int64 time_ms, float x, float y) const {
   return WebGestureEventBuilder::Build(
       type, time_ms / 1000.0, x / GetDpiScale(), y / GetDpiScale());
 }
 
 void ContentViewCoreImpl::SendGestureEvent(
     const blink::WebGestureEvent& event) {
-  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
-  if (rwhv)
-    rwhv->SendGestureEvent(event);
+  // Gestures received while |handling_touch_event_| will accumulate until
+  // touch handling finishes, at which point they will be forwarded to the
+  // |gesture_event_queue_|.
+  if (handling_touch_event_) {
+    pending_gesture_packet_.Push(event);
+    return;
+  }
+
+  // TODO(jdduke): In general, timeout-based gestures *should* have the same
+  // timestamp as the initial TouchStart of the current sequence. We should
+  // verify that this is true, and use that as another timeout check.
+  if (PossiblyTriggeredByTouchTimeout(event)) {
+    gesture_event_queue_.OnGestureEventPacket(
+        GestureEventPacket::FromTouchTimeout(event));
+    return;
+  }
+
+  // If |event| was not (directly or indirectly) touch-derived, treat it as
+  // a synthetic gesture event.
+  SendSyntheticGestureEvent(event);
+}
+
+void ContentViewCoreImpl::SendSyntheticGestureEvent(
+    const blink::WebGestureEvent& event) {
+  // Synthetic gestures (e.g., those not generated directly by touches
+  // for which we expect an ack), should be forwarded directly.
+  ForwardGestureEvent(event);
 }
 
 void ContentViewCoreImpl::ScrollBegin(JNIEnv* env,
                                       jobject obj,
                                       jlong time_ms,
                                       jfloat x,
                                       jfloat y,
                                       jfloat hintx,
                                       jfloat hinty) {
   WebGestureEvent event = MakeGestureEvent(
@@ skipping 39 matching lines @@
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::SingleTap(JNIEnv* env, jobject obj, jlong time_ms,
                                     jfloat x, jfloat y,
                                     jboolean disambiguation_popup_tap) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureTap, time_ms, x, y);
 
   event.data.tap.tapCount = 1;
-  if (!disambiguation_popup_tap) {
-    const float touch_padding_dip = GetTouchPaddingDip();
-    event.data.tap.width = touch_padding_dip;
-    event.data.tap.height = touch_padding_dip;
+
+  // Disambiguation popup gestures are treated as synthetic because their
+  // generating touches were never forwarded to the renderer.
+  if (disambiguation_popup_tap) {
+    SendSyntheticGestureEvent(event);
+    return;
   }
 
+  const float touch_padding_dip = GetTouchPaddingDip();
+  event.data.tap.width = touch_padding_dip;
+  event.data.tap.height = touch_padding_dip;
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::SingleTapUnconfirmed(JNIEnv* env, jobject obj,
                                                jlong time_ms,
                                                jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureTapUnconfirmed, time_ms, x, y);
 
   event.data.tap.tapCount = 1;
 
   const float touch_padding_dip = GetTouchPaddingDip();
   event.data.tap.width = touch_padding_dip;
   event.data.tap.height = touch_padding_dip;
 
   SendGestureEvent(event);
 }
 
-void ContentViewCoreImpl::ShowPressState(JNIEnv* env, jobject obj,
-                                         jlong time_ms,
-                                         jfloat x, jfloat y) {
+void ContentViewCoreImpl::ShowPress(JNIEnv* env, jobject obj,
+                                    jlong time_ms,
+                                    jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureShowPress, time_ms, x, y);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::TapCancel(JNIEnv* env,
                                     jobject obj,
                                     jlong time_ms,
                                     jfloat x,
                                     jfloat y) {
@@ skipping 16 matching lines @@
       WebInputEvent::GestureDoubleTap, time_ms, x, y);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::LongPress(JNIEnv* env, jobject obj, jlong time_ms,
                                     jfloat x, jfloat y,
                                     jboolean disambiguation_popup_tap) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureLongPress, time_ms, x, y);
 
-  if (!disambiguation_popup_tap) {
-    const float touch_padding_dip = GetTouchPaddingDip();
-    event.data.longPress.width = touch_padding_dip;
-    event.data.longPress.height = touch_padding_dip;
+  // Disambiguation popup gestures are treated as synthetic because their
+  // generating touches were never forwarded to the renderer.
+  if (disambiguation_popup_tap) {
+    SendSyntheticGestureEvent(event);
+    return;
   }
 
+  const float touch_padding_dip = GetTouchPaddingDip();
+  event.data.longPress.width = touch_padding_dip;
+  event.data.longPress.height = touch_padding_dip;
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::LongTap(JNIEnv* env, jobject obj, jlong time_ms,
                                   jfloat x, jfloat y,
                                   jboolean disambiguation_popup_tap) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureLongTap, time_ms, x, y);
 
-  if (!disambiguation_popup_tap) {
-    const float touch_padding_dip = GetTouchPaddingDip();
-    event.data.longPress.width = touch_padding_dip;
-    event.data.longPress.height = touch_padding_dip;
+  // Disambiguation popup gestures are treated as synthetic because their
+  // generating touches were never forwarded to the renderer.
+  if (disambiguation_popup_tap) {
+    SendSyntheticGestureEvent(event);
+    return;
   }
 
+  const float touch_padding_dip = GetTouchPaddingDip();
+  event.data.longPress.width = touch_padding_dip;
+  event.data.longPress.height = touch_padding_dip;
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::PinchBegin(JNIEnv* env, jobject obj, jlong time_ms,
                                      jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GesturePinchBegin, time_ms, x, y);
   SendGestureEvent(event);
 }
 
@@ skipping 543 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