Remove UserGesture on touch scrolls

third_party/WebKit/Source/core/input/TouchEventManager.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/TouchEventManager.h"
 
 #include "core/dom/Document.h"
-#include "core/dom/DocumentUserGestureToken.h"
 #include "core/events/TouchEvent.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/layout/HitTestCanvasResult.h"
 #include "core/page/ChromeClient.h"
@@ skipping 65 matching lines @@
 };
 
 }  // namespace
 
 TouchEventManager::TouchEventManager(LocalFrame* frame) : m_frame(frame) {
   clear();
 }
 
 void TouchEventManager::clear() {
   m_touchSequenceDocument.clear();
-  m_touchSequenceUserGestureToken.clear();
   m_targetForTouchID.clear();
   m_regionForTouchID.clear();
   m_touchPressed = false;
-  m_touchScrollStarted = false;
   m_currentEvent = PlatformEvent::NoType;
 }
 
 DEFINE_TRACE(TouchEventManager) {
   visitor->trace(m_frame);
   visitor->trace(m_touchSequenceDocument);
   visitor->trace(m_targetForTouchID);
 }
 
 WebInputEventResult TouchEventManager::dispatchTouchEvents(
     const PlatformTouchEvent& event,
     const HeapVector<TouchInfo>& touchInfos,
     bool allTouchesReleased) {
   // Build up the lists to use for the |touches|, |targetTouches| and
   // |changedTouches| attributes in the JS event. See
   // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
   // lists fit together.
 
   // Holds the complete set of touches on the screen.
   TouchList* touches = TouchList::create();
 
   // A different view on the 'touches' list above, filtered and grouped by
   // event target. Used for the |targetTouches| list in the JS event.
   using TargetTouchesHeapMap = HeapHashMap<EventTarget*, Member<TouchList>>;
   TargetTouchesHeapMap touchesByTarget;
 
   // Array of touches per state, used to assemble the |changedTouches| list.
   ChangedTouches changedTouches[PlatformTouchPoint::TouchStateEnd];
 
-  for (unsigned i = 0; i < touchInfos.size(); ++i) {
-    const TouchInfo& touchInfo = touchInfos[i];
+  for (auto touchInfo : touchInfos) {
     const PlatformTouchPoint& point = touchInfo.point;
     PlatformTouchPoint::TouchState pointState = point.state();
 
     Touch* touch = Touch::create(
         touchInfo.targetFrame.get(), touchInfo.touchNode.get(), point.id(),
         point.screenPos(), touchInfo.contentPoint, touchInfo.adjustedRadius,
         point.rotationAngle(), point.force(), touchInfo.region);
 
     // Ensure this target's touch list exists, even if it ends up empty, so
     // it can always be passed to TouchEvent::Create below.
@@ skipping 24 matching lines @@
       ASSERT(pointState < PlatformTouchPoint::TouchStateEnd);
       if (!changedTouches[pointState].m_touches)
         changedTouches[pointState].m_touches = TouchList::create();
       changedTouches[pointState].m_touches->append(touch);
       changedTouches[pointState].m_targets.add(touchInfo.touchNode);
     }
   }
 
   if (allTouchesReleased) {
     m_touchSequenceDocument.clear();
-    m_touchSequenceUserGestureToken.clear();
   }
 
   WebInputEventResult eventResult = WebInputEventResult::NotHandled;
 
   // Now iterate through the |changedTouches| list and |m_targets| within it,
   // sending TouchEvents to the targets as required.
   for (unsigned state = 0; state != PlatformTouchPoint::TouchStateEnd;
        ++state) {
     if (!changedTouches[state].m_touches)
       continue;
@@ skipping 74 matching lines @@
                   ? HandledTouches
                   : UnhandledTouches);
         }
       }
       eventResult = EventHandlingUtil::mergeEventResult(
           eventResult,
           EventHandlingUtil::toWebInputEventResult(domDispatchResult));
     }
   }
 
-  if (allTouchesReleased)
-    m_touchScrollStarted = false;
-
   return eventResult;
 }
 
 void TouchEventManager::updateTargetAndRegionMapsForTouchStarts(
     HeapVector<TouchInfo>& touchInfos) {
   for (auto& touchInfo : touchInfos) {
     // Touch events implicitly capture to the touched node, and don't change
     // active/hover states themselves (Gesture events do). So we only need
     // to hit-test on touchstart and when the target could be different than
     // the corresponding pointer event target.
@@ skipping 144 matching lines @@
         point.state() != PlatformTouchPoint::TouchCancelled)
       allTouchesReleased = false;
   }
   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());
   if (m_touchSequenceDocument && (!m_touchSequenceDocument->frame() ||
                                   !m_touchSequenceDocument->frame()->view())) {
     // If the active touch document has no frame or view, it's probably being
     // destroyed so we can't dispatch events.
     return false;
   }
 
   updateTargetAndRegionMapsForTouchStarts(touchInfos);
 
   m_touchPressed = !allTouchesReleased;
 
   // If there's no document receiving touch events, or no handlers on the
   // document set to receive the events, then we can skip all the rest of
   // this work.
   if (!m_touchSequenceDocument || !m_touchSequenceDocument->frameHost() ||
       !hasTouchHandlers(
           m_touchSequenceDocument->frameHost()->eventHandlerRegistry()) ||
       !m_touchSequenceDocument->frame()) {
     if (allTouchesReleased) {
       m_touchSequenceDocument.clear();
-      m_touchSequenceUserGestureToken.clear();
     }
     return false;
   }
 
   setAllPropertiesOfTouchInfos(touchInfos);
 
   return true;
 }
 
 // TODO(rbyers): Replace with AutoReset as base/WTF unification permits.
@@ skipping 22 matching lines @@
   if (!reHitTestTouchPointsIfNeeded(event, touchInfos))
     return WebInputEventResult::NotHandled;
 
   bool allTouchesReleased = true;
   for (const auto& point : event.touchPoints()) {
     if (point.state() != PlatformTouchPoint::TouchReleased &&
         point.state() != PlatformTouchPoint::TouchCancelled)
       allTouchesReleased = false;
   }
 
-  // Whether a touch should be considered a "user gesture" or not is a tricky
-  // question.
-  // https://docs.google.com/document/d/1oF1T3O7_E4t1PYHV6gyCwHxOi3ystm0eSL5xZu7nvOg/edit#
-
-  // The touchend corresponding to a tap is always a user gesture.
-  bool isTap =
-      event.touchPoints().size() == 1 &&
-      event.touchPoints()[0].state() == PlatformTouchPoint::TouchReleased &&
-      !event.causesScrollingIfUncanceled();
-
-  // For now, disallow dragging as a user gesture when the events are being sent
-  // to a cross-origin iframe (crbug.com/582140).
-  bool isSameOrigin = false;
-  if (m_touchSequenceDocument && m_touchSequenceDocument->frame()) {
-    SecurityOrigin* securityOrigin = m_touchSequenceDocument->frame()
-                                         ->securityContext()
-                                         ->getSecurityOrigin();
-    Frame* top = m_frame->tree().top();
-    if (top &&
-        securityOrigin->canAccess(top->securityContext()->getSecurityOrigin()))
-      isSameOrigin = true;
-  }
-
-  std::unique_ptr<UserGestureIndicator> gestureIndicator;
-  if (isTap || isSameOrigin) {
-    gestureIndicator = wrapUnique(new UserGestureIndicator(
-        m_touchSequenceUserGestureToken
-            ? m_touchSequenceUserGestureToken.release()
-            : DocumentUserGestureToken::create(m_touchSequenceDocument)));
-
-    m_touchSequenceUserGestureToken = UserGestureIndicator::currentToken();
-    // These are cases we'd like to migrate to not hold a user gesture.
-    if (event.type() == PlatformEvent::TouchStart ||
-        event.type() == PlatformEvent::TouchMove ||
-        (event.type() == PlatformEvent::TouchEnd && m_touchScrollStarted)) {
-      // Collect metrics in userGestureUtilized().
-      m_touchSequenceUserGestureToken->setUserGestureUtilizedCallback(this);
-    }
-  }
-
   return dispatchTouchEvents(event, touchInfos, allTouchesReleased);
 }
 
 bool TouchEventManager::isAnyTouchActive() const {
   return m_touchPressed;
 }
 
-void TouchEventManager::userGestureUtilized() {
-  // This is invoked for UserGestureIndicators created in
-  // TouchEventManger::handleTouchEvent which perhaps represent touch actions
-  // which shouldn't be considered a user-gesture.  Trigger a UseCounter based
-  // on the touch event that's currently being dispatched.
-  UseCounter::Feature feature;
-
-  switch (m_currentEvent) {
-    case PlatformEvent::TouchStart:
-      feature = UseCounter::TouchStartUserGestureUtilized;
-      break;
-    case PlatformEvent::TouchMove:
-      feature = UseCounter::TouchMoveUserGestureUtilized;
-      break;
-    case PlatformEvent::TouchEnd:
-      feature = UseCounter::TouchEndDuringScrollUserGestureUtilized;
-      break;
-    default:
-      NOTREACHED();
-      return;
-  }
-  Deprecation::countDeprecation(m_frame, feature);
-}
-
 }  // namespace blink