Enable gesture events handling on Android.

This add gesture related functionality to the java side to ContentViewCore and also
adds some missing calls on the routing path of the gesture events to webkit. The WebKit side
for related parts of the WebCompositorInputHandler has already been upstreamed.

BUG=136680
TEST=

Review URL: https://chromiumcodereview.appspot.com/10790066

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@148861 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/android/content_startup_flags.cc

@@ -50,7 +50,7 @@ void SetContentCommandLineFlags(int max_render_process_count,
 
   CommandLine* parsed_command_line = CommandLine::ForCurrentProcess();
 
-#if !defined(ANDROID_UPSTREAM_BRINGUP)
+
   // TODO(yfriedman): Upstream this when bringing up rendering code and
   // rendering modes. b/6668088
   // Set subflags for the --graphics-mode=XYZ omnibus flag.
@@ -73,11 +73,11 @@ void SetContentCommandLineFlags(int max_render_process_count,
     SetCommandLineSwitch(switches::kEnableCompositingForFixedPosition);
     SetCommandLineSwitch(switches::kEnableThreadedCompositing);
     // Per tile painting saves memory in background tabs (http://b/5669228).
-    SetCommandLineSwitch(switches::kEnablePerTilePainting);
+    // ...but it now fails an SkAssert(), so disable it. b/6819634
+    // SetCommandLineSwitch(switches::kEnablePerTilePainting);
   } else {
     LOG(FATAL) << "Invalid --graphics-mode flag: " << graphics_mode;
   }
-#endif
 
   if (parsed_command_line->HasSwitch(switches::kRendererProcessLimit)) {
     std::string limit = parsed_command_line->GetSwitchValueASCII(

content/browser/android/content_view_core_impl.cc

@@ -9,11 +9,17 @@
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "content/browser/android/content_view_client.h"
+#include "content/browser/android/touch_point.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/web_contents/navigation_controller_impl.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/ContentViewCore_jni.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/android/WebInputEventFactory.h"
 #include "webkit/glue/webmenuitem.h"
 
 using base::android::AttachCurrentThread;
@@ -23,6 +29,8 @@ using base::android::GetClass;
 using base::android::HasField;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
+using WebKit::WebInputEvent;
+using WebKit::WebInputEventFactory;
 
 // Describes the type and enabled state of a select popup item.
 // Keep in sync with the value defined in SelectPopupDialog.java
@@ -96,6 +104,14 @@ void ContentViewCoreImpl::InitJNI(JNIEnv* env, jobject obj) {
   java_object_->obj = env->NewWeakGlobalRef(obj);
 }
 
+RenderWidgetHostViewAndroid*
+    ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() {
+  RenderWidgetHostView* rwhv = NULL;
+  if (web_contents_)
+    rwhv = web_contents_->GetRenderWidgetHostView();
+  return static_cast<RenderWidgetHostViewAndroid*>(rwhv);
+}
+
 // ----------------------------------------------------------------------------
 // Methods called from Java via JNI
 // ----------------------------------------------------------------------------
@@ -145,6 +161,103 @@ jboolean ContentViewCoreImpl::IsIncognito(JNIEnv* env, jobject obj) {
   return web_contents()->GetBrowserContext()->IsOffTheRecord();
 }
 
+jboolean ContentViewCoreImpl::TouchEvent(JNIEnv* env,
+                                         jobject obj,
+                                         jlong time_ms,
+                                         jint type,
+                                         jobjectArray pts) {
+  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  if (rwhv) {
+    using WebKit::WebTouchEvent;
+    WebKit::WebTouchEvent event;
+    TouchPoint::BuildWebTouchEvent(env, type, time_ms, pts, event);
+    rwhv->TouchEvent(event);
+    return true;
+  }
+  return false;
+}
+
+void ContentViewCoreImpl::SendGestureEvent(WebInputEvent::Type type,
+                                           long time_ms, int x, int y,
+                                           float dx, float dy,
+                                           bool link_preview_tap) {
+  WebKit::WebGestureEvent event = WebInputEventFactory::gestureEvent(
+      type, time_ms / 1000.0, x, y, dx, dy, 0);
+  if (GetRenderWidgetHostViewAndroid())
+    GetRenderWidgetHostViewAndroid()->GestureEvent(event);
+}
+
+void ContentViewCoreImpl::ScrollBegin(JNIEnv* env, jobject obj, jlong time_ms,
+                                      jint x, jint y) {
+  SendGestureEvent(
+      WebInputEvent::GestureScrollBegin, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::ScrollEnd(JNIEnv* env, jobject obj, jlong time_ms) {
+  SendGestureEvent(WebInputEvent::GestureScrollEnd, time_ms, 0, 0, 0, 0, false);
+}
+
+void ContentViewCoreImpl::ScrollBy(JNIEnv* env, jobject obj, jlong time_ms,
+                                   jint dx, jint dy) {
+  SendGestureEvent(
+      WebInputEvent::GestureScrollUpdate, time_ms, 0, 0, -dx, -dy, false);
+}
+
+void ContentViewCoreImpl::FlingStart(JNIEnv* env, jobject obj, jlong time_ms,
+                                     jint x, jint y, jint vx, jint vy) {
+  SendGestureEvent(
+      WebInputEvent::GestureFlingStart, time_ms, x, y, vx, vy, false);
+}
+
+void ContentViewCoreImpl::FlingCancel(JNIEnv* env, jobject obj, jlong time_ms) {
+  SendGestureEvent(
+      WebInputEvent::GestureFlingCancel, time_ms, 0, 0, 0, 0, false);
+}
+
+void ContentViewCoreImpl::SingleTap(JNIEnv* env, jobject obj, jlong time_ms,
+                                    jint x, jint y, jboolean link_preview_tap) {
+  SendGestureEvent(
+      WebInputEvent::GestureTap, time_ms, x, y, 0, 0, link_preview_tap);
+}
+
+void ContentViewCoreImpl::ShowPressState(JNIEnv* env, jobject obj,
+                                         jlong time_ms,
+                                         jint x, jint y) {
+  SendGestureEvent(WebInputEvent::GestureTapDown, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::DoubleTap(JNIEnv* env, jobject obj, jlong time_ms,
+                                    jint x, jint y) {
+  SendGestureEvent(WebInputEvent::GestureDoubleTap, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::LongPress(JNIEnv* env, jobject obj, jlong time_ms,
+                                    jint x, jint y, jboolean link_preview_tap) {
+  SendGestureEvent(
+      WebInputEvent::GestureLongPress, time_ms, x, y, 0, 0, link_preview_tap);
+}
+
+void ContentViewCoreImpl::PinchBegin(JNIEnv* env, jobject obj, jlong time_ms,
+                                     jint x, jint y) {
+  SendGestureEvent(
+      WebInputEvent::GesturePinchBegin, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::PinchEnd(JNIEnv* env, jobject obj, jlong time_ms) {
+  SendGestureEvent(WebInputEvent::GesturePinchEnd, time_ms, 0, 0, 0, 0, false);
+}
+
+void ContentViewCoreImpl::PinchBy(JNIEnv* env, jobject obj, jlong time_ms,
+                                  jint anchor_x, jint anchor_y, jfloat delta) {
+  SendGestureEvent(WebInputEvent::GesturePinchUpdate,
+                   time_ms,
+                   anchor_x,
+                   anchor_y,
+                   delta,
+                   delta,
+                   false);
+}
+
 jboolean ContentViewCoreImpl::CanGoBack(JNIEnv* env, jobject obj) {
   return web_contents_->GetController().CanGoBack();
 }
@@ -298,6 +411,22 @@ void ContentViewCoreImpl::ShowSelectPopupMenu(
                                        multiple, selected_array.obj());
 }
 
+void ContentViewCoreImpl::ConfirmTouchEvent(bool handled) {
+  // TODO(yusufo): Upstream changes for http://crbug/139386 to match upstream
+  // to downstream.
+  JNIEnv* env = AttachCurrentThread();
+  Java_ContentViewCore_confirmTouchEvent(env,
+                                         java_object_->View(env).obj(),
+                                         handled);
+}
+
+void ContentViewCoreImpl::DidSetNeedTouchEvents(bool need_touch_events) {
+  JNIEnv* env = AttachCurrentThread();
+  Java_ContentViewCore_didSetNeedTouchEvents(env,
+                                             java_object_->View(env).obj(),
+                                             need_touch_events);
+}
+
 bool ContentViewCoreImpl::HasFocus() {
   NOTIMPLEMENTED() << "not upstreamed yet";
   return false;

content/browser/android/content_view_core_impl.h

@@ -13,9 +13,11 @@
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process.h"
+#include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/notification_observer.h"
 #include "googleurl/src/gurl.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "ui/gfx/rect.h"
 
 struct WebMenuItem;
@@ -31,7 +33,7 @@ class ContentViewCoreImpl : public ContentViewCore,
   ContentViewCoreImpl(JNIEnv* env,
                       jobject obj,
                       WebContents* web_contents);
-  virtual void Destroy(JNIEnv* env, jobject obj);
+  virtual void Destroy(JNIEnv* env, jobject obj) OVERRIDE;
 
   // --------------------------------------------------------------------------
   // Methods called from Java via JNI
@@ -56,6 +58,44 @@ class ContentViewCoreImpl : public ContentViewCore,
       JNIEnv* env, jobject obj) const;
   jboolean IsIncognito(JNIEnv* env, jobject obj);
   jboolean Crashed(JNIEnv* env, jobject obj) const { return tab_crashed_; }
+  jboolean TouchEvent(JNIEnv* env,
+                      jobject obj,
+                      jlong time_ms,
+                      jint type,
+                      jobjectArray pts);
+  void ScrollBegin(JNIEnv* env, jobject obj, jlong time_ms, jint x, jint y);
+  void ScrollEnd(JNIEnv* env, jobject obj, jlong time_ms);
+  void ScrollBy(JNIEnv* env, jobject obj, jlong time_ms, jint dx, jint dy);
+  void FlingStart(JNIEnv* env,
+                  jobject obj,
+                  jlong time_ms,
+                  jint x,
+                  jint y,
+                  jint vx,
+                  jint vy);
+  void FlingCancel(JNIEnv* env, jobject obj, jlong time_ms);
+  void SingleTap(JNIEnv* env,
+                 jobject obj,
+                 jlong time_ms,
+                 jint x,
+                 jint y,
+                 jboolean link_preview_tap);
+  void ShowPressState(JNIEnv* env, jobject obj, jlong time_ms, jint x, jint y);
+  void DoubleTap(JNIEnv* env, jobject obj, jlong time_ms, jint x, jint y) ;
+  void LongPress(JNIEnv* env,
+                 jobject obj,
+                 jlong time_ms,
+                 jint x,
+                 jint y,
+                 jboolean link_preview_tap);
+  void PinchBegin(JNIEnv* env, jobject obj, jlong time_ms, jint x, jint y);
+  void PinchEnd(JNIEnv* env, jobject obj, jlong time_ms);
+  void PinchBy(JNIEnv* env,
+               jobject obj,
+               jlong time_ms,
+               jint x,
+               jint y,
+               jfloat delta);
   jboolean CanGoBack(JNIEnv* env, jobject obj);
   jboolean CanGoForward(JNIEnv* env, jobject obj);
   jboolean CanGoToOffset(JNIEnv* env, jobject obj, jint offset);
@@ -85,6 +125,8 @@ class ContentViewCoreImpl : public ContentViewCore,
   void SetTitle(const string16& title);
 
   bool HasFocus();
+  void ConfirmTouchEvent(bool handled);
+  void DidSetNeedTouchEvents(bool need_touch_events);
   void OnSelectionChanged(const std::string& text);
   void OnSelectionBoundsChanged(int startx,
                                 int starty,
@@ -131,6 +173,12 @@ class ContentViewCoreImpl : public ContentViewCore,
 
   void InitJNI(JNIEnv* env, jobject obj);
 
+  RenderWidgetHostViewAndroid* GetRenderWidgetHostViewAndroid();
+
+  void SendGestureEvent(WebKit::WebInputEvent::Type type, long time_ms,
+                        int x, int y,
+                        float dx, float dy, bool link_preview_tap);
+
   void PostLoadUrl(const GURL& url);
 
   struct JavaObject;
@@ -151,6 +199,6 @@ class ContentViewCoreImpl : public ContentViewCore,
 
 bool RegisterContentViewCore(JNIEnv* env);
 
-};  // namespace content
+}  // namespace content
 
 #endif  // CONTENT_BROWSER_ANDROID_CONTENT_VIEW_CORE_IMPL_H_

content/browser/renderer_host/render_widget_host_view_android.cc

@@ -330,6 +330,18 @@ void RenderWidgetHostViewAndroid::UnlockMouse() {
   NOTIMPLEMENTED();
 }
 
+void RenderWidgetHostViewAndroid::TouchEvent(
+    const WebKit::WebTouchEvent& event) {
+  if (host_)
+    host_->ForwardTouchEvent(event);
+}
+
+void RenderWidgetHostViewAndroid::GestureEvent(
+    const WebKit::WebGestureEvent& event) {
+  if (host_)
+    host_->ForwardGestureEvent(event);
+}
+
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   content_view_core_ = content_view_core;
@@ -340,6 +352,12 @@ void RenderWidgetHostViewAndroid::SetContentViewCore(
   }
 }
 
+void RenderWidgetHostViewAndroid::DidSetNeedTouchEvents(
+    bool need_touch_events) {
+  if (content_view_core_)
+    content_view_core_->DidSetNeedTouchEvents(need_touch_events);
+}
+
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
     ::WebKit::WebScreenInfo* results) {

content/browser/renderer_host/render_widget_host_view_android.h

@@ -102,9 +102,13 @@ class RenderWidgetHostViewAndroid : public RenderWidgetHostViewBase {
   virtual bool LockMouse() OVERRIDE;
   virtual void UnlockMouse() OVERRIDE;
   virtual void StartContentIntent(const GURL& content_url) OVERRIDE;
+  virtual void DidSetNeedTouchEvents(bool need_touch_events) OVERRIDE;
 
   void SetContentViewCore(ContentViewCoreImpl* content_view_core);
 
+  void TouchEvent(const WebKit::WebTouchEvent& event);
+  void GestureEvent(const WebKit::WebGestureEvent& event);
+
  private:
   // The model object.
   RenderWidgetHostImpl* host_;

content/public/android/java/src/org/chromium/content/browser/ContentView.java

@@ -289,18 +289,18 @@ public class ContentView extends FrameLayout implements ContentViewCore.Internal
      * Start pinch zoom. You must call {@link #pinchEnd} to stop.
      */
     void pinchBegin(long timeMs, int x, int y) {
-        mContentViewCore.pinchBegin(timeMs, x, y);
+        mContentViewCore.getContentViewGestureHandler().pinchBegin(timeMs, x, y);
     }
 
     /**
      * Stop pinch zoom.
      */
     void pinchEnd(long timeMs) {
-        mContentViewCore.pinchEnd(timeMs);
+        mContentViewCore.getContentViewGestureHandler().pinchEnd(timeMs);
     }
 
     void setIgnoreSingleTap(boolean value) {
-        mContentViewCore.setIgnoreSingleTap(value);
+        mContentViewCore.getContentViewGestureHandler().setIgnoreSingleTap(value);
     }
 
     /**
@@ -316,7 +316,7 @@ public class ContentView extends FrameLayout implements ContentViewCore.Internal
      *            coordinate.
      */
     void pinchBy(long timeMs, int anchorX, int anchorY, float delta) {
-        mContentViewCore.pinchBy(timeMs, anchorX, anchorY, delta);
+        mContentViewCore.getContentViewGestureHandler().pinchBy(timeMs, anchorX, anchorY, delta);
     }
 
     /**
@@ -347,6 +347,10 @@ public class ContentView extends FrameLayout implements ContentViewCore.Internal
         super.onScrollChanged(l, t, oldl, oldt);
     }
 
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        return mContentViewCore.onTouchEvent(event);
+    }
     // End FrameLayout overrides.
 
     @Override

content/public/android/java/src/org/chromium/content/browser/TouchPoint.java

@@ -17,10 +17,10 @@ class TouchPoint {
 
     // Type of motion event to send to the native side. The values originate from their
     // webkit WebInputEvent counterparts, and are set via initializeConstants().
-    private static int TOUCH_EVENT_TYPE_START;
-    private static int TOUCH_EVENT_TYPE_MOVE;
-    private static int TOUCH_EVENT_TYPE_END;
-    private static int TOUCH_EVENT_TYPE_CANCEL;
+    static int TOUCH_EVENT_TYPE_START;
+    static int TOUCH_EVENT_TYPE_MOVE;
+    static int TOUCH_EVENT_TYPE_END;
+    static int TOUCH_EVENT_TYPE_CANCEL;
 
     // Type of motion event to send to the native side. The values originate from their
     // webkit WebTouchPoint counterparts, and are set via initializeConstants().

content/public/android/java/src/org/chromium/content/browser/ZoomManager.java

@@ -55,14 +55,14 @@ class ZoomManager {
         public boolean onScaleBegin(ScaleGestureDetector detector) {
             if (ignoreDetectorEvents()) return false;
             mPinchEventSent = false;
-            mContentViewCore.setIgnoreSingleTap(true);
+            mContentViewCore.getContentViewGestureHandler().setIgnoreSingleTap(true);
             return true;
         }
 
         @Override
         public void onScaleEnd(ScaleGestureDetector detector) {
             if (!mPinchEventSent || !mContentViewCore.isAlive()) return;
-            mContentViewCore.pinchEnd(detector.getEventTime());
+            mContentViewCore.getContentViewGestureHandler().pinchEnd(detector.getEventTime());
             mPinchEventSent = false;
         }
 
@@ -76,11 +76,11 @@ class ZoomManager {
             // that pinchBy() is called without any pinchBegin().
             // To solve this problem, we call pinchBegin() here if it is never called.
             if (!mPinchEventSent) {
-                mContentViewCore.pinchBegin(detector.getEventTime(),
+                mContentViewCore.getContentViewGestureHandler().pinchBegin(detector.getEventTime(),
                         (int) detector.getFocusX(), (int) detector.getFocusY());
                 mPinchEventSent = true;
             }
-            mContentViewCore.pinchBy(
+            mContentViewCore.getContentViewGestureHandler().pinchBy(
                     detector.getEventTime(), (int) detector.getFocusX(), (int) detector.getFocusY(),
                     detector.getScaleFactor());
             return true;

content/public/android/javatests/src/org/chromium/content/browser/ContentViewGestureHandlerTest.java

+// Copyright (c) 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.
+
+package org.chromium.content.browser;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.LargeTest;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+import android.view.GestureDetector.OnGestureListener;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.chromium.base.test.Feature;
+import org.chromium.base.test.ScalableTimeout;
+import org.chromium.content.browser.ContentViewGestureHandler.MotionEventDelegate;
+
+/**
+ * Test suite for ContentViewGestureHandler.
+ */
+public class ContentViewGestureHandlerTest extends InstrumentationTestCase {
+    private static final int FAKE_COORD_X = 42;
+    private static final int FAKE_COORD_Y = 24;
+
+    private static final String TAG = ContentViewGestureHandler.class.toString();
+    private MockListener mMockListener;
+    private MockGestureDetector mMockGestureDetector;
+    private ContentViewGestureHandler mGestureHandler;
+    private LongPressDetector mLongPressDetector;
+
+    static class MockListener extends GestureDetector.SimpleOnGestureListener {
+        MotionEvent mLastLongPress;
+        MotionEvent mLastSingleTap;
+        MotionEvent mLastFling1;
+        MotionEvent mLastFling2;
+        CountDownLatch mLongPressCalled;
+        MotionEvent mLastScroll1;
+        MotionEvent mLastScroll2;
+        float mLastScrollDistanceX;
+        float mLastScrollDistanceY;
+
+        public MockListener() {
+            mLongPressCalled = new CountDownLatch(1);
+        }
+
+        @Override
+        public void onLongPress(MotionEvent e) {
+            mLastLongPress = MotionEvent.obtain(e);
+            mLongPressCalled.countDown();
+        }
+
+        @Override
+        public boolean onSingleTapConfirmed(MotionEvent e) {
+            mLastSingleTap = e;
+            return true;
+        }
+
+        @Override
+        public boolean onSingleTapUp(MotionEvent e) {
+            mLastSingleTap = e;
+            return true;
+        }
+
+        @Override
+        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+            mLastScroll1 = e1;
+            mLastScroll2 = e2;
+            mLastScrollDistanceX = distanceX;
+            mLastScrollDistanceY = distanceY;
+            return true;
+        }
+
+        @Override
+        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+            mLastFling1 = e1;
+            mLastFling2 = e2;
+            return true;
+        }
+    }
+
+    static class MockGestureDetector extends GestureDetector {
+        MotionEvent mLastEvent;
+        public MockGestureDetector(Context context, OnGestureListener listener) {
+            super(context, listener);
+        }
+
+        @Override
+        public boolean onTouchEvent(MotionEvent ev) {
+            mLastEvent = MotionEvent.obtain(ev);
+            return super.onTouchEvent(ev);
+        }
+    }
+
+    static class MockMotionEventDelegate implements MotionEventDelegate {
+        @Override
+        public boolean sendTouchEvent(long timeMs, int action, TouchPoint[] pts) {
+            // Not implemented.
+            return false;
+        }
+
+        @Override
+        public boolean sendGesture(int type, long timeMs, int x, int y, Bundle extraParams) {
+            Log.i(TAG,"Gesture event received with type id " + type);
+            return false;
+        }
+
+        @Override
+        public boolean didUIStealScroll(float x, float y) {
+            // Not implemented.
+            return false;
+        }
+
+        @Override
+        public void invokeZoomPicker() {
+            // Not implemented.
+        }
+    }
+
+    static class MockZoomManager extends ZoomManager {
+        MockZoomManager(Context context, ContentViewCore contentViewCore) {
+            super(context, contentViewCore);
+        }
+
+        @Override
+        public boolean processTouchEvent(MotionEvent event) {
+            return false;
+        }
+    }
+
+    private MotionEvent motionEvent(int action, long downTime, long eventTime) {
+        return MotionEvent.obtain(downTime, eventTime, action, FAKE_COORD_X, FAKE_COORD_Y, 0);
+    }
+
+    @Override
+    public void setUp() {
+        mMockListener = new MockListener();
+        mMockGestureDetector = new MockGestureDetector(
+                getInstrumentation().getTargetContext(), mMockListener);
+        mGestureHandler = new ContentViewGestureHandler(
+                getInstrumentation().getTargetContext(), new MockMotionEventDelegate(),
+                new MockZoomManager(getInstrumentation().getTargetContext(), null));
+        mLongPressDetector = new LongPressDetector(
+                getInstrumentation().getTargetContext(), mGestureHandler);
+        mGestureHandler.setTestDependencies(
+                mLongPressDetector, mMockGestureDetector, mMockListener);
+    }
+
+    /**
+     * Verify that a DOWN followed shortly by an UP will trigger a single tap.
+     *
+     * @throws Exception
+     */
+    @SmallTest
+    @Feature({"Android-WebView"})
+    public void testGestureSingleClick() throws Exception {
+        final long downTime = SystemClock.uptimeMillis();
+        final long eventTime = SystemClock.uptimeMillis();
+
+        MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
+
+        assertFalse(mGestureHandler.onTouchEvent(event));
+        assertTrue("Should have a pending gesture", mMockGestureDetector.mLastEvent != null);
+        assertTrue("Should have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());
+
+        event = motionEvent(MotionEvent.ACTION_UP, downTime, eventTime + 10);
+        mLongPressDetector.cancelLongPressIfNeeded(event);
+        assertTrue("Should not have a pending LONG_PRESS", !mLongPressDetector.hasPendingMessage());
+        assertTrue(mGestureHandler.onTouchEvent(event));
+        // Synchronous, no need to wait.
+        assertTrue("Should have a single tap", mMockListener.mLastSingleTap != null);
+    }
+
+    /**
+     * Verify that a DOWN followed by a MOVE will trigger fling (but not LONG).
+     * @throws Exception
+     */
+    @SmallTest
+    @Feature({"Android-WebView"})
+    public void testGestureFlingAndCancelLongClick() throws Exception {
+        final long downTime = SystemClock.uptimeMillis();
+        final long eventTime = SystemClock.uptimeMillis();
+
+        MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
+
+        assertFalse(mGestureHandler.onTouchEvent(event));
+        assertTrue("Should have a pending gesture", mMockGestureDetector.mLastEvent != null);
+        assertTrue("Should have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());
+
+        event = MotionEvent.obtain(
+                downTime, eventTime + 5, MotionEvent.ACTION_MOVE,
+                FAKE_COORD_X * 10, FAKE_COORD_Y * 10, 0);
+        mLongPressDetector.cancelLongPressIfNeeded(event);
+        assertTrue("Should not have a pending LONG_PRESS", !mLongPressDetector.hasPendingMessage());
+        assertTrue(mGestureHandler.onTouchEvent(event));
+
+        event = MotionEvent.obtain(
+                downTime, eventTime + 10, MotionEvent.ACTION_UP,
+                FAKE_COORD_X * 10, FAKE_COORD_Y * 10, 0);
+        assertTrue(mGestureHandler.onTouchEvent(event));
+
+        // Synchronous, no need to wait.
+        assertTrue("Should have a fling", mMockListener.mLastFling1 != null);
+        assertTrue("Should not have a long press", mMockListener.mLastLongPress == null);
+    }
+}

content/public/common/content_switches.cc

@@ -242,6 +242,9 @@ const char kDomAutomationController[]       = "dom-automation";
 // Enable hardware accelerated page painting.
 const char kEnableAcceleratedPainting[]     = "enable-accelerated-painting";
 
+// Enables the hardware acceleration of plugins.
+const char kEnableAcceleratedPlugins[]      = "enable-accelerated-plugins";
+
 // Enable gpu-accelerated SVG/W3C filters.
 const char kEnableAcceleratedFilters[]      = "enable-accelerated-filters";
 
@@ -652,6 +655,12 @@ const char kEnableVisualWordMovement[]      = "enable-visual-word-movement";
 #if defined(OS_ANDROID)
 // Set when Chromium should use a mobile user agent.
 const char kUseMobileUserAgent[] = "use-mobile-user-agent";
+// Omnibus flag setting an Android graphics mode.  May be:
+//   "basic" (untiled software path)
+//   "compositor" (hardware-accelerated compositing),
+const char kGraphicsMode[]                  = "graphics-mode";
+const char kGraphicsModeValueBasic[]        = "basic";
+const char kGraphicsModeValueCompositor[]   = "compositor";
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)

content/public/common/content_switches.h

@@ -90,6 +90,7 @@ extern const char kDisableXSSAuditor[];
 CONTENT_EXPORT extern const char kDomAutomationController[];
 CONTENT_EXPORT extern const char kEnableAcceleratedPainting[];
 CONTENT_EXPORT extern const char kEnableAcceleratedFilters[];
+extern const char kEnableAcceleratedPlugins[];
 extern const char kEnableAccessibilityLogging[];
 CONTENT_EXPORT extern const char kEnableCompositingForFixedPosition[];
 extern const char kEnableCssRegions[];
@@ -210,6 +211,10 @@ extern const char kEnableVisualWordMovement[];
 
 #if defined(OS_ANDROID)
 extern const char kUseMobileUserAgent[];
+extern const char kGraphicsMode[];
+// Not actual flags, just values: for example, --graphics-mode=compositor
+extern const char kGraphicsModeValueBasic[];
+extern const char kGraphicsModeValueCompositor[];
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)