Send early ShowPress on TapDown when page isn't scrollable/pinchable.

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 358 matching lines @@
     , m_flingSourceDevice(false)
     , m_fullscreenController(FullscreenController::create(this))
     , m_showFPSCounter(false)
     , m_showPaintRects(false)
     , m_showDebugBorders(false)
     , m_continuousPaintingEnabled(false)
     , m_showScrollBottleneckRects(false)
     , m_baseBackgroundColor(Color::white)
     , m_backgroundColorOverride(Color::transparent)
     , m_zoomFactorOverride(0)
+    , m_sentEarlyShowPress(false)
 {
     Page::PageClients pageClients;
     pageClients.chromeClient = &m_chromeClientImpl;
     pageClients.contextMenuClient = &m_contextMenuClientImpl;
     pageClients.editorClient = &m_editorClientImpl;
     pageClients.dragClient = &m_dragClientImpl;
     pageClients.inspectorClient = &m_inspectorClientImpl;
     pageClients.backForwardClient = &m_backForwardClientImpl;
     pageClients.spellCheckerClient = &m_spellCheckerClientImpl;
     pageClients.storageClient = &m_storageClientImpl;
@@ skipping 236 matching lines @@
     default:
         break;
     }
 
     PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(), event);
 
     // Handle link highlighting outside the main switch to avoid getting lost in the
     // complicated set of cases handled below.
     switch (event.type) {
     case WebInputEvent::GestureShowPress:
+        // Skip if already seen a ShowPress triggered by TapDown.
+        if (m_sentEarlyShowPress)
+            return false;
+
         // Queue a highlight animation, then hand off to regular handler.
         if (settingsImpl()->gestureTapHighlightEnabled())
             enableTapHighlightAtPoint(platformEvent);
         break;
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTap:
     case WebInputEvent::GestureLongPress:
         for (size_t i = 0; i < m_linkHighlights.size(); ++i)
             m_linkHighlights[i]->startHighlightAnimationIfNeeded();
         break;
@@ skipping 74 matching lines @@
     }
     case WebInputEvent::GestureDoubleTap:
         if (m_webSettings->doubleTapToZoomEnabled() && minimumPageScaleFactor() != maximumPageScaleFactor()) {
             m_client->cancelScheduledContentIntents();
             animateDoubleTapZoom(platformEvent.position());
         }
         // GestureDoubleTap is currently only used by Android for zooming. For WebCore,
         // GestureTap with tap count = 2 is used instead. So we drop GestureDoubleTap here.
         eventSwallowed = true;
         break;
+    case WebInputEvent::GestureTapDown:
+        m_sentEarlyShowPress = false;
+        eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(platformEvent);
+        if (earlyGestureShowPress(platformEvent)) {
+            m_client->didHandleGestureEvent(event, eventCancelled);
+            WebGestureEvent showPressEvent = event;
+            showPressEvent.type = WebInputEvent::GestureShowPress;
+            eventSwallowed = handleGestureEvent(showPressEvent);
+            // Ignore subsequent ShowPress events until another TapDown
+            m_sentEarlyShowPress = true;
+            return eventSwallowed;
+        }
+        break;
     case WebInputEvent::GestureScrollBegin:
     case WebInputEvent::GesturePinchBegin:
         m_client->cancelScheduledContentIntents();
-    case WebInputEvent::GestureTapDown:
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureScrollUpdate:
     case WebInputEvent::GestureScrollUpdateWithoutPropagation:
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTapUnconfirmed:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::GesturePinchUpdate:
     case WebInputEvent::GestureFlingStart: {
         eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(platformEvent);
         break;
     }
     default:
         ASSERT_NOT_REACHED();
     }
     m_client->didHandleGestureEvent(event, eventCancelled);
+
+
     return eventSwallowed;
 }
 
+// GestureShowPress is normally delayed to avoid triggering on the start of a
+// scroll, but when scrolling and pinching aren't possible we can do the
+// ShowPress early, immediately after TapDown.
+bool WebViewImpl::earlyGestureShowPress(const WebCore::PlatformGestureEvent& event)
+{
+    LocalFrame* mainFrame = mainFrameImpl()->frame();
+    FrameView* frameView = mainFrame->view();
+
+    if (frameView && !frameView->isScrollable() && !isPinchZoomable()) {
+        IntPoint adjustedPoint = event.position();
+        LocalFrame* eventFrame = mainFrame->eventHandler().frameForGestureEvent(event, adjustedPoint);
+        IntPoint hitTestPoint = eventFrame->view()->windowToContents(event.position());
+        HitTestResult result = eventFrame->eventHandler().hitTestResultAtPoint(hitTestPoint, HitTestRequest::TouchEvent | HitTestRequest::ReadOnly  | HitTestRequest::AllowFrameScrollbars);
+
+        // If no ancestor is scrollable then this couldn't possibly be the start of a scroll.
+        return !eventFrame->eventHandler().hasScrollableAncestor(result.innerElement());
+    }
+
+    return false;
+}
+
 void WebViewImpl::transferActiveWheelFlingAnimation(const WebActiveWheelFlingParameters& parameters)
 {
     TRACE_EVENT0("webkit", "WebViewImpl::transferActiveWheelFlingAnimation");
     ASSERT(!m_gestureAnimation);
     m_positionOnFlingStart = parameters.point;
     m_globalPositionOnFlingStart = parameters.globalPoint;
     m_flingModifier = parameters.modifiers;
     OwnPtr<WebGestureCurve> curve = adoptPtr(Platform::current()->createFlingAnimationCurve(parameters.sourceDevice, WebFloatPoint(parameters.delta), parameters.cumulativeScroll));
     m_gestureAnimation = WebActiveGestureAnimation::createWithTimeOffset(curve.release(), this, parameters.startTime);
     scheduleAnimation();
@@ skipping 2160 matching lines @@
 float WebViewImpl::minimumPageScaleFactor() const
 {
     return m_pageScaleConstraintsSet.finalConstraints().minimumScale;
 }
 
 float WebViewImpl::maximumPageScaleFactor() const
 {
     return m_pageScaleConstraintsSet.finalConstraints().maximumScale;
 }
 
+bool WebViewImpl::isPinchZoomable() const
+{
+    // This covers all cases:
+    //  * viewport user-scalable: no
+    //  * viewport minimum and maximum scale equal
+    //  * pinch disabled by command line flag
+    return minimumPageScaleFactor() != maximumPageScaleFactor();
+}
+
 void WebViewImpl::saveScrollAndScaleState()
 {
     m_savedPageScaleFactor = pageScaleFactor();
     m_savedScrollOffset = mainFrame()->scrollOffset();
 }
 
 void WebViewImpl::restoreScrollAndScaleState()
 {
     if (!m_savedPageScaleFactor)
         return;
@@ skipping 1056 matching lines @@
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return false;
 
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace blink