Move touch slop suppression from LegacyTouchEventQueue to TouchEventManager

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"
@@ skipping 44 matching lines @@
       return emptyAtom;
   }
 }
 
 enum TouchEventDispatchResultType {
   UnhandledTouches,  // Unhandled touch events.
   HandledTouches,    // Handled touch events.
   TouchEventDispatchResultTypeMax,
 };
 
+bool IsTouchSequenceStart(const PlatformTouchEvent& event) {
+  if (!event.touchPoints().size())
+    return false;
+  if (event.type() != PlatformEvent::TouchStart)
+    return false;
+  for (const auto& point : event.touchPoints()) {
+    if (point.state() != PlatformTouchPoint::TouchPressed)
+      return false;
+  }
+  return true;
+}
+
 // 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 {
   STACK_ALLOCATED();
 
@@ skipping 14 matching lines @@
 TouchEventManager::TouchEventManager(LocalFrame& frame) : m_frame(frame) {
   clear();
 }
 
 void TouchEventManager::clear() {
   m_touchSequenceDocument.clear();
   m_targetForTouchID.clear();
   m_regionForTouchID.clear();
   m_touchPressed = false;
   m_currentEvent = PlatformEvent::NoType;
+  m_suppressingTouchmovesWithinSlop = false;
   m_currentTouchAction = TouchActionAuto;
 }
 
 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.
 
+  // Suppress all the touch moves in the slop region.
+  if (IsTouchSequenceStart(event))
+    m_suppressingTouchmovesWithinSlop = true;
+
+  if (event.type() == PlatformEvent::TouchEnd ||
+      event.type() == PlatformEvent::TouchCancel ||
+      event.touchPoints().size() > 1) {
+    m_suppressingTouchmovesWithinSlop = false;
+  }
+
+  if (m_suppressingTouchmovesWithinSlop &&
+      event.type() == PlatformEvent::TouchMove) {
+    if (!event.causesScrollingIfUncanceled())
+      return WebInputEventResult::HandledSuppressed;
+    m_suppressingTouchmovesWithinSlop = false;
+  }
+
   // 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];
@@ skipping 378 matching lines @@
   }
 
   return dispatchTouchEvents(event, touchInfos, allTouchesReleased);
 }
 
 bool TouchEventManager::isAnyTouchActive() const {
   return m_touchPressed;
 }
 
 }  // namespace blink