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 137 matching lines @@
     // Whether input events are delivered right before vsync.
     private final boolean mInputEventsDeliveredAtVSync;
 
     // Certain touch-event generated gestures (PINCH_BY, SCROLL_BY) may trigger an expedited vsync
     // signal. Rather than sending the vsync immediately after such a gesture is sent, we
     // set this flag and defer the "last event for vsync" signal until the touch event is fully
     // processed. This allows multiple such gestures to be sent in a given frame.
     private boolean mSentGestureNeedsVSync;
     private long mLastVSyncGestureTimeMs;
 
-    // If the page scale is fixed, double tap gesture detection can be disabled.
-    private boolean mHasFixedPageScale;
+    // The page's viewport and scale sometimes allow us to disable double tap gesture detection,
+    // according to the logic in ContentViewCore.onRenderCoordinatesUpdated().
+    private boolean mShouldDisableDoubleTap;
 
     // Incremented and decremented when the methods onTouchEvent() and confirmTouchEvent() start
     // and finish execution, respectively. This provides accounting for synchronous calls to
     // confirmTouchEvent(), from either itself or onTouchEvent().
     private int mTouchEventHandlingStackDepth;
 
     // Keeps track of the last long press event, if we end up opening a context menu, we would need
     // to potentially use the event to send GESUTRE_SHOW_PRESS_CANCEL to remove ::active styling
     private MotionEvent mLastLongPressEvent;
 
@@ skipping 803 matching lines @@
         int type = TouchPoint.createTouchPoints(event, pts);
 
         if (type == TouchPoint.CONVERSION_ERROR) return EVENT_NOT_FORWARDED;
 
         if (!mTouchScrolling && !mPinchInProgress) {
             if (mMotionEventDelegate.sendTouchEvent(event.getEventTime(), type, pts)) {
                 // If confirmTouchEvent() is called synchronously with respect to sendTouchEvent(),
                 // then |event| will have been recycled. Only start the timer if the sent event has
                 // not yet been confirmed.
                 if (!mJavaScriptIsConsumingGesture
-                        && !mHasFixedPageScale
+                        && !mShouldDisableDoubleTap
                         && event == mPendingMotionEvents.peekFirst()
                         && event.getAction() != MotionEvent.ACTION_UP
                         && event.getAction() != MotionEvent.ACTION_CANCEL) {
                     TraceEvent.instant("TouchEventTimeout:StartTimeoutHandler");
                     mTouchEventTimeoutHandler.start(event.getEventTime(), pts);
                 }
                 return EVENT_FORWARDED_TO_NATIVE;
             }
         }
         return EVENT_NOT_FORWARDED;
@@ skipping 220 matching lines @@
     /**
      * This is for testing only.
      * @return Whether a touch timeout event has been scheduled.
      */
     boolean hasScheduledTouchTimeoutEventForTesting() {
         return mTouchEventTimeoutHandler.hasScheduledTimeoutEventForTesting();
     }
 
     /**
      * Update whether double-tap gestures are supported. This allows
-     * double-tap gesture suppression independent of whether or not the page
-     * scale is fixed.
+     * double-tap gesture suppression independent of whether or not the page's
+     * viewport and scale would normally prevent double-tap.
      * Note: This should never be called while a double-tap gesture is in progress.
      * @param supportDoubleTap Whether double-tap gestures are supported.
      */
     public void updateDoubleTapSupport(boolean supportDoubleTap) {
         assert !isDoubleTapActive();
         int doubleTapMode = supportDoubleTap ?
                 DOUBLE_TAP_MODE_NONE : DOUBLE_TAP_MODE_DISABLED;
         if (mDoubleTapMode == doubleTapMode) return;
         mDoubleTapMode = doubleTapMode;
         updateDoubleTapListener();
     }
 
     /**
-     * Update whether the current page has a fixed page scale.
-     * A fixed page scale will suppress double-tap gesture detection, allowing
-     * for rapid and responsive single-tap gestures.
-     * @param hasFixedPageScale Whether the page scale is fixed.
+     * Update whether double-tap gesture detection should be suppressed due to
+     * the viewport or scale of the current page. Suppressing double-tap gesture
+     * detection allows for rapid and responsive single-tap gestures.
+     * @param shouldDisableDoubleTap Whether double-tap should be suppressed.
      */
-    public void updateHasFixedPageScale(boolean hasFixedPageScale) {
-        if (mHasFixedPageScale == hasFixedPageScale) return;
-        mHasFixedPageScale = hasFixedPageScale;
+    public void updateShouldDisableDoubleTap(boolean shouldDisableDoubleTap) {
+        if (mShouldDisableDoubleTap == shouldDisableDoubleTap) return;
+        mShouldDisableDoubleTap = shouldDisableDoubleTap;
         updateDoubleTapListener();
     }
 
     private boolean isDoubleTapDisabled() {
-        return mDoubleTapMode == DOUBLE_TAP_MODE_DISABLED ||
-               mHasFixedPageScale;
+        return mDoubleTapMode == DOUBLE_TAP_MODE_DISABLED || mShouldDisableDoubleTap;
     }
 
     private boolean isDoubleTapActive() {
         return mDoubleTapMode != DOUBLE_TAP_MODE_DISABLED &&
                mDoubleTapMode != DOUBLE_TAP_MODE_NONE;
     }
 
     private void updateDoubleTapListener() {
         if (isDoubleTapDisabled()) {
             // Defer nulling the DoubleTapListener until the double tap gesture is complete.
             if (isDoubleTapActive()) return;
             mGestureDetector.setOnDoubleTapListener(null);
         } else {
             mGestureDetector.setOnDoubleTapListener(mDoubleTapListener);
         }
 
     }
 }