Deprecate use of user gestures during scroll-related touch events

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/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/EventHandler.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/Histogram.h"
 #include "platform/PlatformTouchEvent.h"
@@ skipping 196 matching lines @@
                     } else {
                         DEFINE_STATIC_LOCAL(EnumerationHistogram, touchDispositionsOutsideFlingHistogram, ("Event.Touch.TouchDispositionsOutsideFling", TouchEventDispatchResultTypeMax));
                         touchDispositionsOutsideFlingHistogram.count((domDispatchResult != DispatchEventResult::NotCanceled) ? HandledTouches : UnhandledTouches);
                     }
                 }
             }
             eventResult = EventHandler::mergeEventResult(eventResult,
                 EventHandler::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
@@ skipping 169 matching lines @@
             m_touchSequenceUserGestureToken.clear();
         }
         return false;
     }
 
     setAllPropertiesOfTouchInfos(touchInfos);
 
     return true;
 }
 
+// TODO(rbyers): Replace with AutoReset as base/WTF unification permits.
+class CurrentEventHolder {
+    // Always stack allocated to ensure lifetime doesn't exceed that of target
+    DISALLOW_NEW();
+public:
+    CurrentEventHolder(PlatformEvent::EventType& target, PlatformEvent::EventType value)
+    : m_target(target)
+    {
+        m_target = value;
+    }
+    ~CurrentEventHolder()
+    {
+        m_target = PlatformEvent::NoType;
+    }
+private:
+    PlatformEvent::EventType& m_target;
+};
+
 WebInputEventResult TouchEventManager::handleTouchEvent(
     const PlatformTouchEvent& event,
     HeapVector<TouchInfo>& touchInfos)
 {
+    // Track the current event for the scope of this function.
+    CurrentEventHolder holder(m_currentEvent, event.type());
+
     if (!reHitTestTouchPointsIfNeeded(event, touchInfos))
         return WebInputEventResult::NotHandled;
 
     // 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
@@ skipping 20 matching lines @@
     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;
     }
 
     OwnPtr<UserGestureIndicator> gestureIndicator;
     if (isTap || isSameOrigin) {
         UserGestureUtilizedCallback* callback = 0;
-        if (!isTap) {
-            // This is some other touch event that we currently consider a user gesture.  So
-            // use a UserGestureUtilizedCallback to get metrics.
-            callback = &m_touchSequenceDocument->frame()->eventHandler();
+        // 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().
+            callback = this;
         }
-
         if (m_touchSequenceUserGestureToken)
             gestureIndicator = adoptPtr(new UserGestureIndicator(m_touchSequenceUserGestureToken.release(), callback));
         else
             gestureIndicator = adoptPtr(new UserGestureIndicator(DefinitelyProcessingUserGesture, callback));
         m_touchSequenceUserGestureToken = UserGestureIndicator::currentToken();
     }
 
     return dispatchTouchEvents(event, touchInfos, allTouchesReleased);
 }
 
 void TouchEventManager::clear()
 {
     m_touchSequenceDocument.clear();
     m_touchSequenceUserGestureToken.clear();
     m_targetForTouchID.clear();
     m_regionForTouchID.clear();
     m_touchPressed = false;
     m_waitingForFirstTouchMove = false;
+    m_touchScrollStarted = false;
+    m_currentEvent = PlatformEvent::NoType;
 }
 
 bool TouchEventManager::isAnyTouchActive() const
 {
     return m_touchPressed;
 }
 
 DEFINE_TRACE(TouchEventManager)
 {
     visitor->trace(m_frame);
     visitor->trace(m_touchSequenceDocument);
     visitor->trace(m_targetForTouchID);
 }
 
+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