Notify Blink about start of gesture scroll through a queued event.

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 252 matching lines @@
     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
     , m_svgPan(false)
     , m_resizeScrollableArea(nullptr)
     , m_eventHandlerWillResetCapturingMouseEventsNode(0)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
     , m_accumulatedRootOverscroll(FloatSize())
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_touchPressed(false)
-    , m_inPointerCanceledState(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
 {
 }
 
 EventHandler::~EventHandler()
@@ skipping 54 matching lines @@
     m_capturesDragging = false;
     m_capturingMouseEventsNode = nullptr;
     m_targetForTouchID.clear();
     m_touchSequenceDocument.clear();
     m_touchSequenceUserGestureToken.clear();
     clearGestureScrollState();
     m_lastGestureScrollOverWidget = false;
     m_scrollbarHandlingScrollGesture = nullptr;
     m_touchPressed = false;
     m_pointerEventManager.clear();
-    m_inPointerCanceledState = false;
     m_mouseDownMayStartDrag = false;
     m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
     m_mouseDownTimestamp = 0;
     m_longTapShouldInvokeContextMenu = false;
     m_dragStartPos = LayoutPoint();
@@ skipping 3230 matching lines @@
 
         WebInputEventResult result =
             m_pointerEventManager.sendTouchPointerEvent(
             touchInfo.touchTarget, touchPoint, event.getModifiers(),
             touchInfo.adjustedRadius.width(), touchInfo.adjustedRadius.height(),
             touchInfo.adjustedPagePoint.x(), touchInfo.adjustedPagePoint.y());
         touchInfo.consumed = result != WebInputEventResult::NotHandled;
     }
 }
 
-void EventHandler::sendPointerCancels(HeapVector<TouchInfo>& touchInfos)
-{
-    if (!RuntimeEnabledFeatures::pointerEventEnabled())
-        return;
-
-    for (unsigned i = 0; i < touchInfos.size(); ++i) {
-        TouchInfo& touchInfo = touchInfos[i];
-        const PlatformTouchPoint& point = touchInfo.point;
-        const PlatformTouchPoint::TouchState pointState = point.state();
-
-        if (pointState == PlatformTouchPoint::TouchReleased
-            || pointState == PlatformTouchPoint::TouchCancelled)
-            continue;
-
-        m_pointerEventManager.sendTouchCancelPointerEvent(
-            touchInfo.touchTarget,
-            point);
-    }
-}
-
 namespace {
 
 // Defining this class type local to dispatchTouchEvents() and annotating
 // it with STACK_ALLOCATED(), runs into MSVC(VS 2013)'s C4822 warning
 // that the local class doesn't provide a local definition for 'operator new'.
 // Which it intentionally doesn't and shouldn't.
 //
 // Work around such toolchain bugginess by lifting out the type, thereby
 // taking it out of C4822's reach.
 class ChangedTouches final {
@@ skipping 99 matching lines @@
                 eventName, touchEventTarget->toNode()->document().domWindow(),
                 event.getModifiers(), event.cancelable(), event.causesScrollingIfUncanceled(), event.timestamp());
 
             eventResult = mergeEventResult(eventResult, toWebInputEventResult(touchEventTarget->dispatchEvent(touchEvent)));
         }
     }
 
     return eventResult;
 }
 
 WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

[bokan, 2016/04/12 22:42:46]

This method is way too big. Not in this CL, but I'd make this a candidate for
breaking up into more manageable chunks.

[mustaq, 2016/04/13 14:56:27]

Agree, too big is too unhealthy/unreadable. Navid is currently looking at
releasing implicit touch capture through releasePointerCapture, which would put
the PE handler ahead of the TE handler, and would significantly shorten this
method.

I will start working on making the EventHandler modular (crbug.com/449649) this
quarter.

[bokan, 2016/04/13 22:59:48]

Awesome, thanks!

 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
 
+    if (event.type() == PlatformEvent::TouchScrollStarted) {
+        m_pointerEventManager.blockTouchPointers();
+        return WebInputEventResult::HandledSystem;
+    }
+
     const Vector<PlatformTouchPoint>& points = event.touchPoints();
 
-    bool freshTouchEvents = true;
+    bool newTouchSequence = true;

[bokan, 2016/04/12 22:42:46]

Please also update the param name in dispatchTouchEvents

[Navid Zolghadr, 2016/04/13 14:33:06]

I couldn't find any use for this variable in that function. I was going to
remove it altogether in my next change after this change.

[mustaq, 2016/04/13 14:56:27]

Removed.

     bool allTouchReleased = true;
     for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
 
         if (point.state() != PlatformTouchPoint::TouchPressed)
-            freshTouchEvents = false;
+            newTouchSequence = false;
         if (point.state() != PlatformTouchPoint::TouchReleased && point.state() != PlatformTouchPoint::TouchCancelled)
             allTouchReleased = false;
     }
-    if (freshTouchEvents) {
+    if (newTouchSequence) {
         // Ideally we'd ASSERT !m_touchSequenceDocument here since we should
         // have cleared the active document when we saw the last release. But we
         // have some tests that violate this, ClusterFuzz could trigger it, and
         // there may be cases where the browser doesn't reliably release all
         // touches. http://crbug.com/345372 tracks this.
         m_touchSequenceDocument.clear();
         m_touchSequenceUserGestureToken.clear();
     }
 
     ASSERT(m_frame->view());
@@ skipping 154 matching lines @@
         touchInfo.point = point;
         touchInfo.touchTarget = touchTarget;
         touchInfo.targetFrame = targetFrame;
         touchInfo.adjustedPagePoint = pagePoint.scaledBy(scaleFactor);
         touchInfo.adjustedRadius = point.radius().scaledBy(scaleFactor);
         touchInfo.knownTarget = knownTarget;
         touchInfo.consumed = false;
         touchInfo.region = regionID;
     }
 
-    if (!m_inPointerCanceledState) {
-        dispatchPointerEvents(event, touchInfos);
-        // Note that the disposition of any pointer events affects only the generation of touch
-        // events. If all pointer events were handled (and hence no touch events were fired), that
-        // is still equivalent to the touch events going unhandled because pointer event handler
-        // don't block scroll gesture generation.
-    }
+    if (newTouchSequence)
+        m_pointerEventManager.unblockTouchPointers();

[bokan, 2016/04/12 22:42:46]

Does this have to be way down here or can it be moved up to where we determined
newTouchSequence? As it is, you have to wonder about all the code in between
like the early return for no-touch handlers (which I *think* is fine now, but
future changes could easily get this wrong). 

[mustaq, 2016/04/13 14:56:27]

I kept it here because the code above is fairly unrelated to PEs. But
future-proofing seems to be a stronger argument. Done.

+    dispatchPointerEvents(event, touchInfos);
+    // Note that the disposition of any pointer events affects only the generation of touch
+    // events. If all pointer events were handled (and hence no touch events were fired), that
+    // is still equivalent to the touch events going unhandled because pointer event handler
+    // don't block scroll gesture generation.
 
     // TODO(crbug.com/507408): If PE handlers always call preventDefault, we won't see TEs until after
     // scrolling starts because the scrolling would suppress upcoming PEs. This sudden "break" in TE
     // suppression can make the visible TEs inconsistent (e.g. touchmove without a touchstart).
 
-    WebInputEventResult eventResult = dispatchTouchEvents(event, touchInfos, freshTouchEvents,
-        allTouchReleased);
-
-    if (!m_inPointerCanceledState) {
-        // Check if we need to stop firing pointer events because of a touch action.
-        // See: www.w3.org/TR/pointerevents/#declaring-candidate-regions-for-default-touch-behaviors
-        if (event.causesScrollingIfUncanceled() && eventResult == WebInputEventResult::NotHandled) {
-            m_inPointerCanceledState = true;
-            sendPointerCancels(touchInfos);
-        }
-    } else if (allTouchReleased) {
-        m_inPointerCanceledState = false;
-    }
-
-    return eventResult;
+    return dispatchTouchEvents(event, touchInfos, newTouchSequence, allTouchReleased);

[bokan, 2016/04/12 22:42:46]

Question: How are touch events canceled and blocked?

[mustaq, 2016/04/13 14:56:27]

Any PE that was canceled above effectively "hides" the corresponding touch point
in the TE, checked thru the |consumed| bits in touchInfos. I guess this is what
you meant by "blocking".

Not sure what you meant by "canceled" TEs. |dispatchTouchEvent| convey the
outcome upstream whenever a TE is canceled from JS. It doesn't affect PEs
directly. But it can switch the browser/GR away from the throttled touchmoves
mode, thus affect generation of future touchmoves for the same touch sequence
and hence the generation of future PEs. Does this answer your 2nd query?

[bokan, 2016/04/13 22:59:48]

Got it, thanks.
Yah, my canceled question made no sense here :)

 }
 
 void EventHandler::userGestureUtilized()
 {
     // This is invoked for UserGestureIndicators created in handleTouchEvent which perhaps represent
     // touch actions which shouldn't be considered a user-gesture.
     UseCounter::count(m_frame, UseCounter::TouchDragUserGestureUsed);
     Deprecation::countDeprecationCrossOriginIframe(m_frame, UseCounter::TouchDragUserGestureUsedCrossOrigin);
 }
 
@@ skipping 47 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink