Remove UserGesture on touch scrolls

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

 // Copyright 2016 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.
 
 #include "core/input/PointerEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 151 matching lines @@
   }
 
   if (!RuntimeEnabledFeatures::pointerEventEnabled())
     return WebInputEventResult::NotHandled;
   if (!checkForListener || target->hasEventListeners(eventType)) {
     UseCounter::count(m_frame->document(), UseCounter::PointerEventDispatch);
     if (eventType == EventTypeNames::pointerdown)
       UseCounter::count(m_frame->document(),
                         UseCounter::PointerEventDispatchPointerDown);
 
-    std::unique_ptr<UserGestureIndicator> gestureIndicator;
-    if (eventType == EventTypeNames::pointerup &&
-        pointerEvent->pointerType() == "touch") {
-      gestureIndicator =
-          wrapUnique(new UserGestureIndicator(DocumentUserGestureToken::create(
-              target->toNode() ? &target->toNode()->document() : nullptr)));
-    }
-
     DispatchEventResult dispatchResult = target->dispatchEvent(pointerEvent);
     return EventHandlingUtil::toWebInputEventResult(dispatchResult);
   }
   return WebInputEventResult::NotHandled;
 }
 
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target,
     int pointerId) {
   if (EventTarget* capturingTarget = getCapturingNode(pointerId))
@@ skipping 101 matching lines @@
 }
 
 void PointerEventManager::unblockTouchPointers() {
   m_inCanceledStateForPointerTypeTouch = false;
 }
 
 WebInputEventResult PointerEventManager::handleTouchEvents(
     const PlatformTouchEvent& event) {
   if (event.type() == PlatformEvent::TouchScrollStarted) {
     blockTouchPointers();
-    m_touchEventManager->setTouchScrollStarted();
     return WebInputEventResult::HandledSystem;
   }
 
   bool newTouchSequence = true;
   for (const auto& touchPoint : event.touchPoints()) {
     if (touchPoint.state() != PlatformTouchPoint::TouchPressed) {
       newTouchSequence = false;
       break;
     }
   }
   if (newTouchSequence)
     unblockTouchPointers();
+
+  // Do any necessary hit-tests and compute the event targets for all pointers
+  // in the event.
   HeapVector<TouchEventManager::TouchInfo> touchInfos;
+  computeTouchTargets(event, touchInfos);
+
+  // A finger lifting is a user gesture only when it wasn't associated with a
+  // scroll.
+  // Re-use the same UserGesture for touchend and pointerup.
+  // https://docs.google.com/document/d/1oF1T3O7_E4t1PYHV6gyCwHxOi3ystm0eSL5xZu7nvOg/edit#
+  RefPtr<UserGestureToken> possibleGestureToken;
+  if (event.type() == PlatformEvent::TouchEnd &&
+      !m_inCanceledStateForPointerTypeTouch) {
+    possibleGestureToken =
+        DocumentUserGestureToken::create(touchInfos[0].targetFrame->document());

[Navid Zolghadr, 2016/11/04 18:08:19]

I'm a little confused about the intended behavior when different fingers are on
different iframes.
PointerEvents are targeted to the elements in their own document as oppose to
the touch events. So basically if the second finger touches another iframe for
the pointerup of that finger we will not have a token in that document.

+  }
+  UserGestureIndicator holder(possibleGestureToken);
 
   dispatchTouchPointerEvents(event, touchInfos);
 
   return m_touchEventManager->handleTouchEvent(event, touchInfos);
 }
 
-void PointerEventManager::dispatchTouchPointerEvents(
+void PointerEventManager::computeTouchTargets(
     const PlatformTouchEvent& event,
     HeapVector<TouchEventManager::TouchInfo>& touchInfos) {
-  // Iterate through the touch points, sending PointerEvents to the targets as
-  // required.
   for (const auto& touchPoint : event.touchPoints()) {
     TouchEventManager::TouchInfo touchInfo;
     touchInfo.point = touchPoint;
 
     int pointerId =
         m_pointerEventFactory.getPointerEventId(touchPoint.pointerProperties());
     // Do the hit test either when the touch first starts or when the touch
     // is not captured. |m_pendingPointerCaptureTarget| indicates the target
     // that will be capturing this event. |m_pointerCaptureTarget| may not
     // have this target yet since the processing of that will be done right
@@ skipping 30 matching lines @@
       }
     } else {
       // Set the target of pointer event to the captured node as this
       // pointer is captured otherwise it would have gone to the if block
       // and perform a hit-test.
       touchInfo.touchNode =
           m_pendingPointerCaptureTarget.get(pointerId)->toNode();
       touchInfo.targetFrame = touchInfo.touchNode->document().frame();
     }
 
+    touchInfos.append(touchInfo);
+  }
+}
+
+void PointerEventManager::dispatchTouchPointerEvents(
+    const PlatformTouchEvent& event,
+    HeapVector<TouchEventManager::TouchInfo>& touchInfos) {
+  // Iterate through the touch points, sending PointerEvents to the targets as
+  // required.
+  for (auto touchInfo : touchInfos) {
+    const PlatformTouchPoint& touchPoint = touchInfo.point;
     // Do not send pointer events for stationary touches or null targetFrame
     if (touchInfo.touchNode && touchInfo.targetFrame &&
         touchPoint.state() != PlatformTouchPoint::TouchStationary &&
         !m_inCanceledStateForPointerTypeTouch) {
       FloatPoint pagePoint = touchInfo.targetFrame->view()->rootFrameToContents(
           touchInfo.point.pos());
       float scaleFactor = 1.0f / touchInfo.targetFrame->pageZoomFactor();
       FloatPoint scrollPosition(touchInfo.targetFrame->view()->scrollOffset());
       FloatPoint framePoint = pagePoint.scaledBy(scaleFactor);
       framePoint.moveBy(scrollPosition.scaledBy(-scaleFactor));
@@ skipping 12 matching lines @@
       // fired from GestureTap & GestureLongPress (which are triggered by
       // single touches only), it is enough to queue the ids only for
       // primary pointers.
       // TODO(mustaq): What about other cases (e.g. GestureTwoFingerTap)?
       if (result != WebInputEventResult::NotHandled &&
           pointerEvent->type() == EventTypeNames::pointerdown &&
           pointerEvent->isPrimary()) {
         m_touchIdsForCanceledPointerdowns.append(event.uniqueTouchEventId());
       }
     }
-
-    touchInfos.append(touchInfo);
   }
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
     EventTarget* target,
     PointerEvent* pointerEvent) {
   if (m_inCanceledStateForPointerTypeTouch)
     return WebInputEventResult::NotHandled;
 
   processCaptureAndPositionOfPointerEvent(pointerEvent, target);
@@ skipping 280 matching lines @@
       return true;
   }
   return false;
 }
 
 EventTarget* PointerEventManager::getMouseCapturingNode() {
   return getCapturingNode(PointerEventFactory::s_mouseId);
 }
 
 }  // namespace blink