Make the ContentGestureProvider a ui::FilteredGestureProvider

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 38 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/menu_item.h"
 #include "content/public/common/page_transition_types.h"
 #include "jni/ContentViewCore_jni.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/base/android/view_android.h"
 #include "ui/base/android/window_android.h"
+#include "ui/events/gesture_detection/gesture_config_helper.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/size_f.h"
 #include "webkit/common/user_agent/user_agent_util.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF16ToJavaString;
@@ skipping 87 matching lines @@
       return -1;
   };
 }
 
 float GetPrimaryDisplayDeviceScaleFactor() {
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   return display.device_scale_factor();
 }
 
+ui::GestureProvider::Config GetGestureProviderConfig() {
+  ui::GestureProvider::Config config = ui::DefaultGestureProviderConfig();
+  config.disable_click_delay =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableClickDelay);
+  return config;
+}
+
 }  // 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()),
       dpi_scale_(GetPrimaryDisplayDeviceScaleFactor()),
       vsync_interval_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros)),
       expected_browser_composite_time_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros * kDefaultBrowserCompositeVSyncFraction)),
       view_android_(view_android),
       window_android_(window_android),
-      gesture_provider_(this, 1.f / dpi_scale_),
+      gesture_provider_(GetGestureProviderConfig(), this),
       device_orientation_(0),
       geolocation_needs_pause_(false) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
   // 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
   // NavigationEntry requires the user agent to be overridden.
   const char kLinuxInfoStr[] = "X11; Linux x86_64";
@@ skipping 109 matching lines @@
       break;
     }
   }
 }
 
 void ContentViewCoreImpl::RenderViewReady() {
   if (device_orientation_ != 0)
     SendOrientationChangeEventInternal();
 }
 
-void ContentViewCoreImpl::OnGestureEvent(const blink::WebGestureEvent& event) {
-  SendGestureEvent(event);
+void ContentViewCoreImpl::OnGestureEvent(const ui::GestureEventData& gesture) {
+  SendGestureEvent(
+      CreateWebGestureEventFromGestureEventData(gesture, 1.f / dpi_scale()));
 }
 
 RenderWidgetHostViewAndroid*
     ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() {
   RenderWidgetHostView* rwhv = NULL;
   if (web_contents_) {
     rwhv = web_contents_->GetRenderWidgetHostView();
     if (web_contents_->ShowingInterstitialPage()) {
       rwhv = static_cast<InterstitialPageImpl*>(
           web_contents_->GetInterstitialPage())->
@@ 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_provider_.OnTouchEventAck(ack_result);
+  const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
+  gesture_provider_.OnTouchEventAck(event_consumed);
 }
 
 void ContentViewCoreImpl::OnGestureEventAck(const blink::WebGestureEvent& event,
                                             InputEventAckState ack_result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
 
   switch (event.type) {
     case WebInputEvent::GestureFlingStart:
       if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) {
         // The view expects the fling velocity in pixels/s.
         Java_ContentViewCore_onFlingStartEventConsumed(env, j_obj.obj(),
-            event.data.flingStart.velocityX * GetDpiScale(),
-            event.data.flingStart.velocityY * GetDpiScale());
+            event.data.flingStart.velocityX * dpi_scale(),
+            event.data.flingStart.velocityY * dpi_scale());
       } else {
         // If a scroll ends with a fling, a SCROLL_END event is never sent.
         // However, if that fling went unconsumed, we still need to let the
         // listeners know that scrolling has ended.
         Java_ContentViewCore_onScrollEndEventAck(env, j_obj.obj());
       }
 
       if (ack_result == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS) {
         // The view expects the fling velocity in pixels/s.
         Java_ContentViewCore_onFlingStartEventHadNoConsumer(env, j_obj.obj(),
-            event.data.flingStart.velocityX * GetDpiScale(),
-            event.data.flingStart.velocityY * GetDpiScale());
+            event.data.flingStart.velocityX * dpi_scale(),
+            event.data.flingStart.velocityY * dpi_scale());
       }
       break;
     case WebInputEvent::GestureFlingCancel:
       Java_ContentViewCore_onFlingCancelEventAck(env, j_obj.obj());
       break;
     case WebInputEvent::GestureScrollBegin:
       Java_ContentViewCore_onScrollBeginEventAck(env, j_obj.obj());
       break;
     case WebInputEvent::GestureScrollUpdate:
       if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
@@ skipping 27 matching lines @@
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return false;
 
   const blink::WebGestureEvent& gesture =
       static_cast<const blink::WebGestureEvent&>(event);
   int gesture_type = ToGestureEventType(event.type);
   return Java_ContentViewCore_filterTapOrPressEvent(env,
                                                     j_obj.obj(),
                                                     gesture_type,
-                                                    gesture.x * GetDpiScale(),
-                                                    gesture.y * GetDpiScale());
+                                                    gesture.x * dpi_scale(),
+                                                    gesture.y * dpi_scale());
 
   // TODO(jdduke): Also report double-tap UMA, crbug/347568.
 }
 
 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());
@@ skipping 157 matching lines @@
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return gfx::Size();
   return gfx::Size(
       Java_ContentViewCore_getViewportSizeOffsetWidthPix(env, j_obj.obj()),
       Java_ContentViewCore_getViewportSizeOffsetHeightPix(env, j_obj.obj()));
 }
 
 gfx::Size ContentViewCoreImpl::GetViewportSizeDip() const {
   return gfx::ToCeiledSize(
-      gfx::ScaleSize(GetViewportSizePix(), 1.0f / GetDpiScale()));
+      gfx::ScaleSize(GetViewportSizePix(), 1.0f / dpi_scale()));
 }
 
 gfx::Size ContentViewCoreImpl::GetViewportSizeOffsetDip() const {
   return gfx::ToCeiledSize(
-      gfx::ScaleSize(GetViewportSizeOffsetPix(), 1.0f / GetDpiScale()));
+      gfx::ScaleSize(GetViewportSizeOffsetPix(), 1.0f / dpi_scale()));
 }
 
 float ContentViewCoreImpl::GetOverdrawBottomHeightDip() const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return 0.f;
   return Java_ContentViewCore_getOverdrawBottomHeightPix(env, j_obj.obj())
-      / GetDpiScale();
+      / dpi_scale();
 }
 
 void ContentViewCoreImpl::AttachLayer(scoped_refptr<cc::Layer> layer) {
   root_layer_->AddChild(layer);
 }
 
 void ContentViewCoreImpl::RemoveLayer(scoped_refptr<cc::Layer> layer) {
   layer->RemoveFromParent();
 }
 
@@ skipping 168 matching lines @@
       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 / GetDpiScale()));
+      CreateWebTouchEventFromMotionEvent(*cancel_event, 1.f / dpi_scale()));
 }
 
 jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
                                            jobject obj,
                                            jobject motion_event) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (!rwhv)
     return false;
 
   MotionEventAndroid event(env, motion_event, false);
 
   if (!gesture_provider_.OnTouchEvent(event))
     return false;
 
-  rwhv->SendTouchEvent(WebTouchEventBuilder::Build(event, 1.f / GetDpiScale()));
+  rwhv->SendTouchEvent(WebTouchEventBuilder::Build(event, 1.f / dpi_scale()));
   return true;
 }
 
 float ContentViewCoreImpl::GetDpiScale() const {
   return dpi_scale_;
 }
 
 jboolean ContentViewCoreImpl::SendMouseMoveEvent(JNIEnv* env,
                                                  jobject obj,
                                                  jlong time_ms,
                                                  jfloat x,
                                                  jfloat y) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (!rwhv)
     return false;
 
   blink::WebMouseEvent event = WebMouseEventBuilder::Build(
       WebInputEvent::MouseMove,
       blink::WebMouseEvent::ButtonNone,
-      time_ms / 1000.0, x / GetDpiScale(), y / GetDpiScale(), 0, 1);
+      time_ms / 1000.0, x / dpi_scale(), y / dpi_scale(), 0, 1);
 
   rwhv->SendMouseEvent(event);
   return true;
 }
 
 jboolean ContentViewCoreImpl::SendMouseWheelEvent(JNIEnv* env,
                                                   jobject obj,
                                                   jlong time_ms,
                                                   jfloat x,
                                                   jfloat y,
                                                   jfloat vertical_axis) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (!rwhv)
     return false;
 
   WebMouseWheelEventBuilder::Direction direction;
   if (vertical_axis > 0) {
     direction = WebMouseWheelEventBuilder::DIRECTION_UP;
   } else if (vertical_axis < 0) {
     direction = WebMouseWheelEventBuilder::DIRECTION_DOWN;
   } else {
     return false;
   }
   blink::WebMouseWheelEvent event = WebMouseWheelEventBuilder::Build(
-      direction, time_ms / 1000.0, x / GetDpiScale(), y / GetDpiScale());
+      direction, time_ms / 1000.0, x / dpi_scale(), y / dpi_scale());
 
   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 / GetDpiScale(), y / GetDpiScale());
+      type, time_ms / 1000.0, x / dpi_scale(), y / dpi_scale());
 }
 
 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,
                                       jfloat x,
                                       jfloat y,
                                       jfloat hintx,
                                       jfloat hinty) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureScrollBegin, time_ms, x, y);
-  event.data.scrollBegin.deltaXHint = hintx / GetDpiScale();
-  event.data.scrollBegin.deltaYHint = hinty / GetDpiScale();
+  event.data.scrollBegin.deltaXHint = hintx / dpi_scale();
+  event.data.scrollBegin.deltaYHint = hinty / dpi_scale();
 
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::ScrollEnd(JNIEnv* env, jobject obj, jlong time_ms) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureScrollEnd, time_ms, 0, 0);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::ScrollBy(JNIEnv* env, jobject obj, jlong time_ms,
                                    jfloat x, jfloat y, jfloat dx, jfloat dy) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureScrollUpdate, time_ms, x, y);
-  event.data.scrollUpdate.deltaX = -dx / GetDpiScale();
-  event.data.scrollUpdate.deltaY = -dy / GetDpiScale();
+  event.data.scrollUpdate.deltaX = -dx / dpi_scale();
+  event.data.scrollUpdate.deltaY = -dy / dpi_scale();
 
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::FlingStart(JNIEnv* env, jobject obj, jlong time_ms,
                                      jfloat x, jfloat y, jfloat vx, jfloat vy) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureFlingStart, time_ms, x, y);
-  event.data.flingStart.velocityX = vx / GetDpiScale();
-  event.data.flingStart.velocityY = vy / GetDpiScale();
+  event.data.flingStart.velocityX = vx / dpi_scale();
+  event.data.flingStart.velocityY = vy / dpi_scale();
 
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::FlingCancel(JNIEnv* env, jobject obj, jlong time_ms) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureFlingCancel, time_ms, 0, 0);
   SendGestureEvent(event);
 }
 
@@ skipping 42 matching lines @@
   event.data.pinchUpdate.scale = delta;
 
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::SelectBetweenCoordinates(JNIEnv* env, jobject obj,
                                                    jfloat x1, jfloat y1,
                                                    jfloat x2, jfloat y2) {
   if (GetRenderWidgetHostViewAndroid()) {
     GetRenderWidgetHostViewAndroid()->SelectRange(
-        gfx::Point(x1 / GetDpiScale(), y1 / GetDpiScale()),
-        gfx::Point(x2 / GetDpiScale(), y2 / GetDpiScale()));
+        gfx::Point(x1 / dpi_scale(), y1 / dpi_scale()),
+        gfx::Point(x2 / dpi_scale(), y2 / dpi_scale()));
   }
 }
 
 void ContentViewCoreImpl::MoveCaret(JNIEnv* env, jobject obj,
                                     jfloat x, jfloat y) {
   if (GetRenderWidgetHostViewAndroid()) {
     GetRenderWidgetHostViewAndroid()->MoveCaret(
-        gfx::Point(x / GetDpiScale(), y / GetDpiScale()));
+        gfx::Point(x / dpi_scale(), y / dpi_scale()));
   }
 }
 
 void ContentViewCoreImpl::ResetGestureDetectors(JNIEnv* env, jobject obj) {
   gesture_provider_.ResetGestureDetectors();
 }
 
 void ContentViewCoreImpl::IgnoreRemainingTouchEvents(JNIEnv* env, jobject obj) {
   CancelActiveTouchSequenceIfNecessary();
 }
@@ skipping 473 matching lines @@
     sodh->OnOrientationChange(orientation);
 }
 
 void ContentViewCoreImpl::ExtractSmartClipData(JNIEnv* env,
                                                jobject obj,
                                                jint x,
                                                jint y,
                                                jint width,
                                                jint height) {
   gfx::Rect rect(
-      static_cast<int>(x / GetDpiScale()),
-      static_cast<int>(y / GetDpiScale()),
-      static_cast<int>((width > 0 && width < GetDpiScale()) ?
-          1 : (int)(width / GetDpiScale())),
-      static_cast<int>((height > 0 && height < GetDpiScale()) ?
-          1 : (int)(height / GetDpiScale())));
+      static_cast<int>(x / dpi_scale()),
+      static_cast<int>(y / dpi_scale()),
+      static_cast<int>((width > 0 && width < dpi_scale()) ?
+          1 : (int)(width / dpi_scale())),
+      static_cast<int>((height > 0 && height < dpi_scale()) ?
+          1 : (int)(height / dpi_scale())));
   GetWebContents()->Send(new ViewMsg_ExtractSmartClipData(
       GetWebContents()->GetRoutingID(), rect));
 }
 
 void ContentViewCoreImpl::OnSmartClipDataExtracted(
     const base::string16& result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
@@ skipping 21 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