Disable double tap zoom on mobile sites, to remove 300ms click delay

content/public/android/java/src/org/chromium/content/browser/ContentViewGestureHandler.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.Handler;
 import android.os.SystemClock;
@@ skipping 68 matching lines @@
 
     // Remember whether onShowPress() is called. If it is not, in onSingleTapConfirmed()
     // we will first show the press state, then trigger the click.
     private boolean mShowPressIsCalled;
 
     // TODO(klobag): this is to avoid a bug in GestureDetector. With multi-touch,
     // mAlwaysInTapRegion is not reset. So when the last finger is up, onSingleTapUp()
     // will be mistakenly fired.
     private boolean mIgnoreSingleTap;
 
+    private boolean mDoubleTapZoomEnabled = true;

[klobag.chromium, 2013/07/10 18:26:21]

This should be set by "mListener instanceof GestureDetector.OnDoubleTapListener"
in initGestureDetectors.

[johnme, 2013/07/10 19:19:16]

Done (though that should always be true, as mListener is always initialized to
be a GestureDetector.SimpleOnGestureListener).

I also made setTestDependencies update this accordingly.

+
     // Does native think we are scrolling?  True from right before we
     // send the first scroll event until the last finger is raised.
     // Call nativeScrollBegin() when setting this to true, and use
     // tellNativeScrollingHasEnded() to set it to false.
     private boolean mNativeScrolling;
 
     private boolean mFlingMayBeActive;
 
     private boolean mSeenFirstScrollEvent;
 
@@ skipping 169 matching lines @@
          * @param x The amount scrolled in the X direction.
          * @param y The amount scrolled in the Y direction.
          * @return Whether or not the UI consumed and handled this event.
          */
         boolean didUIStealScroll(float x, float y);
 
         /**
          * Show the zoom picker UI.
          */
         public void invokeZoomPicker();
-
-        /**
-         * @return Whether changing the page scale is not possible on the current page.
-         */
-        public boolean hasFixedPageScale();
     }
 
     ContentViewGestureHandler(
             Context context, MotionEventDelegate delegate, ZoomManager zoomManager,
             int inputEventDeliveryMode) {
         mExtraParamBundle = new Bundle();
         mLongPressDetector = new LongPressDetector(context, this);
         mMotionEventDelegate = delegate;
         mZoomManager = zoomManager;
         mSnapScrollController = new SnapScrollController(context, mZoomManager);
@@ skipping 123 matching lines @@
                         mShowPressIsCalled = true;
                         sendMotionEventAsGesture(GESTURE_SHOW_PRESSED_STATE, e, null);
                     }
 
                     @Override
                     public boolean onSingleTapUp(MotionEvent e) {
                         if (isDistanceBetweenDownAndUpTooLong(e.getRawX(), e.getRawY())) {
                             mIgnoreSingleTap = true;
                             return true;
                         }
+
+                        if (!mDoubleTapZoomEnabled && !mLongPressDetector.isInLongPress()) {
+                            return onSingleTapConfirmed(e);
+                        }
+
                         // This is a hack to address the issue where user hovers
                         // over a link for longer than DOUBLE_TAP_TIMEOUT, then
                         // onSingleTapConfirmed() is not triggered. But we still
                         // want to trigger the tap event at UP. So we override
                         // onSingleTapUp() in this case. This assumes singleTapUp
                         // gets always called before singleTapConfirmed.
                         if (!mIgnoreSingleTap && !mLongPressDetector.isInLongPress()) {
                             if (e.getEventTime() - e.getDownTime() > DOUBLE_TAP_TIMEOUT) {
                                 float x = e.getX();
                                 float y = e.getY();
                                 if (sendMotionEventAsGesture(GESTURE_SINGLE_TAP_UP, e, null)) {
                                     mIgnoreSingleTap = true;
                                 }
                                 setClickXAndY((int) x, (int) y);
                                 return true;
-                            } else if (mMotionEventDelegate.hasFixedPageScale()) {
-                                // If page is not user scalable, we don't need to wait
-                                // for double tap timeout.
-                                float x = e.getX();
-                                float y = e.getY();
-                                mExtraParamBundle.clear();
-                                mExtraParamBundle.putBoolean(SHOW_PRESS, mShowPressIsCalled);
-                                if (sendMotionEventAsGesture(GESTURE_SINGLE_TAP_CONFIRMED, e,
-                                        mExtraParamBundle)) {
-                                    mIgnoreSingleTap = true;
-                                }
-                                setClickXAndY((int) x, (int) y);
                             } else {
                                 // Notify Blink about this tapUp event anyway,
                                 // when none of the above conditions applied.
                                 sendMotionEventAsGesture(GESTURE_SINGLE_TAP_UNCONFIRMED, e, null);
                             }
                         }
 
                         return triggerLongTapIfNeeded(e);
                     }
 
@@ skipping 50 matching lines @@
                     }
                 };
                 mListener = listener;
                 mGestureDetector = new GestureDetector(context, listener);
                 mGestureDetector.setIsLongpressEnabled(false);
         } finally {
             TraceEvent.end();
         }
     }
 
+    public void setDoubleTapZoomEnabled(boolean enable) {
+        if (enable == mDoubleTapZoomEnabled) {
+            return;
+        }
+
+        GestureDetector.OnDoubleTapListener listener = null;
+        if (enable && mListener instanceof GestureDetector.OnDoubleTapListener) {
+            listener = (GestureDetector.OnDoubleTapListener)mListener;
+        }
+        mGestureDetector.setOnDoubleTapListener(listener);
+        mDoubleTapZoomEnabled = enable;
+
+        // Clean up state, in particular, prevent GestureDetector from getting
+        // left with mIsDoubleTapping == true but mDoubleTapListener == null.
+        resetGestureHandlers();
+    }
+
     /**
      * @return LongPressDetector handling setting up timers for and canceling LongPress gestures.
      */
     LongPressDetector getLongPressDetector() {
         return mLongPressDetector;
     }
 
     /**
      * @param event Start a LongPress gesture event from the listener.
      */
@@ skipping 483 matching lines @@
     /**
      * This is for testing only.
      * Sends a show pressed state gesture through mListener. This should always be called after
      * a down event;
      */
     void sendShowPressedStateGestureForTesting() {
         if (mCurrentDownEvent == null) return;
         mListener.onShowPress(mCurrentDownEvent);
     }
 }