Add suppresion of slop region touches in browser

content/browser/renderer_host/input/passthrough_touch_event_queue.cc

 // Copyright 2017 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/passthrough_touch_event_queue.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/touch_timeout_handler.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/gfx/geometry/point_f.h"
 
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
+// A sanity check on touches received to ensure that touch movement outside
+// the platform slop region will cause scrolling.
+const double kMaxConceivablePlatformSlopRegionLengthDipsSquared = 60. * 60.;
+
 // Compare all properties of touch points to determine the state.
 bool HasPointChanged(const WebTouchPoint& point_1,
                      const WebTouchPoint& point_2) {
   DCHECK_EQ(point_1.id, point_2.id);
   if (point_1.screen_position != point_2.screen_position ||
       point_1.position != point_2.position ||
       point_1.radius_x != point_2.radius_x ||
       point_1.radius_y != point_2.radius_y ||
       point_1.rotation_angle != point_2.rotation_angle ||
       point_1.force != point_2.force || point_1.tilt_x != point_2.tilt_x ||
       point_1.tilt_y != point_2.tilt_y) {
     return true;
   }
   return false;
 }
 
 }  // namespace
 
+// Provides touchmove slop suppression for a touch sequence until a
+// (unprevented) touch will trigger immediate scrolling.
+class 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.GetType() == WebInputEvent::kTouchEnd ||
+        event.GetType() == WebInputEvent::kTouchCancel)
+      suppressing_touchmoves_ = false;
+
+    if (event.GetType() != WebInputEvent::kTouchMove)
+      return false;
+
+    if (suppressing_touchmoves_) {
+      if (event.touches_length > 1) {
+        suppressing_touchmoves_ = false;
+      } else if (event.moved_beyond_slop_region) {
+        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);
+};
+
 PassthroughTouchEventQueue::TouchEventWithLatencyInfoAndAckState::
     TouchEventWithLatencyInfoAndAckState(const TouchEventWithLatencyInfo& event)
     : TouchEventWithLatencyInfo(event),
       ack_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {}
 
 bool PassthroughTouchEventQueue::TouchEventWithLatencyInfoAndAckState::
 operator<(const TouchEventWithLatencyInfoAndAckState& other) const {
   return event.unique_touch_event_id < other.event.unique_touch_event_id;
 }
 
 PassthroughTouchEventQueue::PassthroughTouchEventQueue(
     TouchEventQueueClient* client,
     const Config& config)
     : client_(client),
       has_handlers_(true),
       maybe_has_handler_for_current_sequence_(false),
       drop_remaining_touches_in_sequence_(false),
+      touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
       processing_acks_(false) {
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this, config.desktop_touch_ack_timeout_delay,
                                 config.mobile_touch_ack_timeout_delay));
   }
 }
 
 PassthroughTouchEventQueue::~PassthroughTouchEventQueue() {}
@@ skipping 42 matching lines @@
 
 void PassthroughTouchEventQueue::ProcessTouchAck(
     InputEventAckState ack_result,
     const LatencyInfo& latency_info,
     const uint32_t unique_touch_event_id) {
   TRACE_EVENT0("input", "PassthroughTouchEventQueue::ProcessTouchAck");
   if (timeout_handler_ &&
       timeout_handler_->ConfirmTouchEvent(unique_touch_event_id, ack_result))
     return;
 
+  touchmove_slop_suppressor_->ConfirmTouchEvent(ack_result);
+
   auto touch_event_iter = outstanding_touches_.begin();
   while (touch_event_iter != outstanding_touches_.end()) {
     if (unique_touch_event_id == touch_event_iter->event.unique_touch_event_id)
       break;
     ++touch_event_iter;
   }
 
   if (touch_event_iter == outstanding_touches_.end())
     return;
 
@@ skipping 162 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.GetType() != WebInputEvent::kTouchCancel) {
     return ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
   if (event.GetType() == WebInputEvent::kTouchStart) {
     return (has_handlers_ || maybe_has_handler_for_current_sequence_)
                ? FORWARD_TO_RENDERER
                : ACK_WITH_NO_CONSUMER_EXISTS;
   }
@@ skipping 64 matching lines @@
 bool PassthroughTouchEventQueue::IsTimeoutRunningForTesting() const {
   return timeout_handler_ && timeout_handler_->IsTimeoutTimerRunning();
 }
 
 const TouchEventWithLatencyInfo&
 PassthroughTouchEventQueue::GetLatestEventForTesting() const {
   return *outstanding_touches_.rbegin();
 }
 
 }  // namespace content