Move touch slop suppression to TouchEventManager

content/browser/renderer_host/input/legacy_touch_event_queue.cc

 // Copyright 2013 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 "content/browser/renderer_host/input/legacy_touch_event_queue.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
@@ skipping 10 matching lines @@
 using blink::WebTouchPoint;
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
 // Time interval at which touchmove events will be forwarded to the client while
 // scrolling is active and possible.
 const double kAsyncTouchMoveIntervalSec = .2;
 
-// A sanity check on touches received to ensure that touch movement outside
-// the platform slop region will cause scrolling.
-const double kMaxConceivablePlatformSlopRegionLengthDipsSquared = 60. * 60.;
-
 TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
     const TouchEventWithLatencyInfo& event_to_cancel) {
   TouchEventWithLatencyInfo event = event_to_cancel;
   WebTouchEventTraits::ResetTypeAndTouchStates(
       WebInputEvent::TouchCancel,
       // TODO(rbyers): Shouldn't we use a fresh timestamp?
       event.event.timeStampSeconds(), &event.event);
   return event;
 }
 
@@ skipping 227 matching lines @@
   TimeoutMonitor timeout_monitor_;
 
   bool enabled_;
   bool enabled_for_current_sequence_;
 
   // Bookkeeping to classify and log whether a touch sequence times out.
   bool sequence_awaiting_uma_update_;
   bool sequence_using_mobile_timeout_;
 };
 
-// Provides touchmove slop suppression for a touch sequence until a
-// (unprevented) touch will trigger immediate scrolling.
-class LegacyTouchEventQueue::TouchMoveSlopSuppressor {
- public:
-  TouchMoveSlopSuppressor() : suppressing_touchmoves_(false) {}
-
-  bool FilterEvent(const WebTouchEvent& event) {
-    if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
-      suppressing_touchmoves_ = true;
-      touch_start_location_ = gfx::PointF(event.touches[0].position);
-    }
-
-    if (event.type() == WebInputEvent::TouchEnd ||
-        event.type() == WebInputEvent::TouchCancel)
-      suppressing_touchmoves_ = false;
-
-    if (event.type() != WebInputEvent::TouchMove)
-      return false;
-
-    if (suppressing_touchmoves_) {
-      if (event.touchesLength > 1) {
-        suppressing_touchmoves_ = false;
-      } else if (event.movedBeyondSlopRegion) {
-        suppressing_touchmoves_ = false;
-      } else {
-        // No sane slop region should be larger than 60 DIPs.
-        DCHECK_LT(
-            (gfx::PointF(event.touches[0].position) - touch_start_location_)
-                .LengthSquared(),
-            kMaxConceivablePlatformSlopRegionLengthDipsSquared);
-      }
-    }
-
-    return suppressing_touchmoves_;
-  }
-
-  void ConfirmTouchEvent(InputEventAckState ack_result) {
-    if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
-      suppressing_touchmoves_ = false;
-  }
-
-  bool suppressing_touchmoves() const { return suppressing_touchmoves_; }
-
- private:
-  bool suppressing_touchmoves_;
-
-  // Sanity check that the upstream touch provider is properly reporting whether
-  // the touch sequence will cause scrolling.
-  gfx::PointF touch_start_location_;
-
-  DISALLOW_COPY_AND_ASSIGN(TouchMoveSlopSuppressor);
-};
-
 // This class represents a single coalesced touch event. However, it also keeps
 // track of all the original touch-events that were coalesced into a single
 // event. The coalesced event is forwarded to the renderer, while the original
 // touch-events are sent to the Client (on ACK for the coalesced event) so that
 // the Client receives the event with their original timestamp.
 class CoalescedWebTouchEvent {
  public:
   CoalescedWebTouchEvent(const TouchEventWithLatencyInfo& event,
                          bool suppress_client_ack)
       : coalesced_event_(event), suppress_client_ack_(suppress_client_ack) {
@@ skipping 74 matching lines @@
 };
 
 LegacyTouchEventQueue::LegacyTouchEventQueue(TouchEventQueueClient* client,
                                              const Config& config)
     : client_(client),
       dispatching_touch_ack_(false),
       dispatching_touch_(false),
       has_handlers_(true),
       has_handler_for_current_sequence_(false),
       drop_remaining_touches_in_sequence_(false),
-      touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
       last_sent_touch_timestamp_sec_(0) {
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this, config.desktop_touch_ack_timeout_delay,
                                 config.mobile_touch_ack_timeout_delay));
   }
 }
 
 LegacyTouchEventQueue::~LegacyTouchEventQueue() {}
@@ skipping 86 matching lines @@
     }
     return;
   }
 
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
   if (timeout_handler_ && timeout_handler_->ConfirmTouchEvent(ack_result))
     return;
 
-  touchmove_slop_suppressor_->ConfirmTouchEvent(ack_result);
-
   if (touch_queue_.empty())
     return;
 
   // We don't care about the ordering of the acks vs the ordering of the
   // dispatched events because we can receive the ack for event B before the ack
   // for event A even though A was sent before B. This seems to be happening
   // when, for example, A is acked from renderer but B isn't, so the ack for B
   // is synthesized "locally" in InputRouter.
   //
   // TODO(crbug.com/600773): Bring the id checks back when dispatch triggering
@@ skipping 101 matching lines @@
       std::move(pending_async_touchmove_);
   touch->event.dispatchType = WebInputEvent::EventNonBlocking;
   touch_queue_.push_front(
       base::MakeUnique<CoalescedWebTouchEvent>(*touch, true));
   SendTouchEventImmediately(touch.get());
 }
 
 void LegacyTouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type() == blink::WebInputEvent::GestureScrollBegin) {
-    if (has_handler_for_current_sequence_ &&
-        !drop_remaining_touches_in_sequence_) {
-      DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
-          << "A touch handler should be offered a touchmove before scrolling.";
-    }
-
     pending_async_touchmove_.reset();
 
     return;
   }
 
   if (gesture_event.event.type() == blink::WebInputEvent::GestureScrollUpdate &&
       gesture_event.event.resendingPluginId == -1) {
     send_touch_events_async_ = true;
   }
 }
@@ skipping 189 matching lines @@
     drop_remaining_touches_in_sequence_ = false;
     if (!has_handlers_) {
       drop_remaining_touches_in_sequence_ = true;
       return ACK_WITH_NO_CONSUMER_EXISTS;
     }
   }
 
   if (timeout_handler_ && timeout_handler_->FilterEvent(event))
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
-  if (touchmove_slop_suppressor_->FilterEvent(event))
-    return ACK_WITH_NOT_CONSUMED;
-
   if (drop_remaining_touches_in_sequence_ &&
       event.type() != WebInputEvent::TouchCancel) {
     return ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
   if (event.type() == WebInputEvent::TouchStart) {
     return (has_handlers_ || has_handler_for_current_sequence_)
                ? FORWARD_TO_RENDERER
                : ACK_WITH_NO_CONSUMER_EXISTS;
   }
@@ skipping 42 matching lines @@
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content