Expose native, desktop and mobile gesture detection defaults

content/browser/renderer_host/input/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/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
@@ skipping 10 matching lines @@
 
 // Time interval at which touchmove events will be forwarded to the client while
 // scrolling is active and possible.
 const double kAsyncTouchMoveIntervalSec = .2;
 
 // A slop region just larger than that used by many web applications. When
 // touchmove's are being sent asynchronously, movement outside this region will
 // trigger an immediate async touchmove to cancel potential tap-related logic.
 const double kApplicationSlopRegionLengthDipsSqared = 15. * 15.;
 
-// Using a small epsilon when comparing slop distances allows pixel perfect
-// slop determination when using fractional DIP coordinates (assuming the slop
-// region and DPI scale are reasonably proportioned).
-const float kSlopEpsilon = .05f;
+// A sanity check on touches received to ensure that touch movement outside
+// the platform slop region will cause scrolling, as indicated by the event's
+// |causesScrollingIfUncanceled| bit.
+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 163 matching lines @@
   // The event for which the ack timeout is triggered.
   TouchEventWithLatencyInfo timeout_event_;
 
   // Provides timeout-based callback behavior.
   TimeoutMonitor timeout_monitor_;
 
   bool enabled_;
   bool enabled_for_current_sequence_;
 };
 
-// Provides touchmove slop suppression for a single touch that remains within
-// a given slop region, unless the touchstart is preventDefault'ed.
-// TODO(jdduke): Use a flag bundled with each TouchEvent declaring whether it
-// has exceeded the slop region, removing duplicated slop determination logic.
+// Provides touchmove slop suppression for a touch sequence until a
+// (unprevented) touch will trigger immediate scrolling.
 class TouchEventQueue::TouchMoveSlopSuppressor {
  public:
-  TouchMoveSlopSuppressor(double slop_suppression_length_dips)
-      : slop_suppression_length_dips_squared_(0),
-        suppressing_touchmoves_(false) {
-    if (slop_suppression_length_dips) {
-      slop_suppression_length_dips += kSlopEpsilon;
-      slop_suppression_length_dips_squared_ =
-          slop_suppression_length_dips * slop_suppression_length_dips;
-    }
-  }
+  TouchMoveSlopSuppressor() : suppressing_touchmoves_(false) {}
 
   bool FilterEvent(const WebTouchEvent& event) {
     if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
-      touch_sequence_start_position_ =
-          gfx::PointF(event.touches[0].position);
-      suppressing_touchmoves_ = slop_suppression_length_dips_squared_ != 0;
+      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_) {
-      // Movement with a secondary pointer should terminate suppression.
       if (event.touchesLength > 1) {
         suppressing_touchmoves_ = false;
-      } else if (event.touchesLength == 1) {
-        // Movement outside of the slop region should terminate suppression.
-        gfx::PointF position(event.touches[0].position);
-        if ((position - touch_sequence_start_position_).LengthSquared() >
-            slop_suppression_length_dips_squared_)
-          suppressing_touchmoves_ = false;
+      } else if (event.causesScrollingIfUncanceled) {
+        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:
-  double slop_suppression_length_dips_squared_;
-  gfx::PointF touch_sequence_start_position_;
   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:
@@ skipping 70 matching lines @@
   // Note that this will be empty if no coalescing has occurred.
   typedef std::vector<TouchEventWithLatencyInfo> WebTouchEventWithLatencyList;
   WebTouchEventWithLatencyList uncoaleseced_events_to_ack_;
 
   bool suppress_client_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(CoalescedWebTouchEvent);
 };
 
 TouchEventQueue::Config::Config()
-    : touchmove_slop_suppression_length_dips(0),
-      touch_scrolling_mode(TOUCH_SCROLLING_MODE_DEFAULT),
+    : touch_scrolling_mode(TOUCH_SCROLLING_MODE_DEFAULT),
       touch_ack_timeout_delay(base::TimeDelta::FromMilliseconds(200)),
       touch_ack_timeout_supported(false) {
 }
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client,
                                  const Config& config)
     : client_(client),
       dispatching_touch_ack_(NULL),
       dispatching_touch_(false),
       has_handlers_(true),
       drop_remaining_touches_in_sequence_(false),
-      touchmove_slop_suppressor_(new TouchMoveSlopSuppressor(
-          config.touchmove_slop_suppression_length_dips)),
+      touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
       needs_async_touchmove_for_outer_slop_region_(false),
       last_sent_touch_timestamp_sec_(0),
       touch_scrolling_mode_(config.touch_scrolling_mode) {
   DCHECK(client);
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this, config.touch_ack_timeout_delay));
   }
 }
@@ skipping 387 matching lines @@
         if (ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
           touch_consumer_states_.mark_bit(point.id);
         else
           touch_consumer_states_.clear_bit(point.id);
       }
     }
   }
 }
 
 }  // namespace content