Suppress LongPress/Tap, and TwoFingerTap when TapDown cancels a fling.

content/browser/renderer_host/input/tap_suppression_controller.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/tap_suppression_controller.h"
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/tap_suppression_controller_client.h"
+#include "ui/events/gesture_detection/gesture_configuration.h"
 
 namespace content {
 
+// The tapDownTimer is used to avoid waiting for an arbitrarily late fling
+// cancel ack. While the timer is running, if a fling cancel ack with
+// |Processed = false| arrives, all stashed gesture events get forwarded. If
+// the timer expires, the controller forwards stashed GestureTapDown only, and
+// drops the rest of the stashed events. The timer delay should be large enough
+// for a GestureLongPress to get stashed and forwarded if needed. It's still
+// possible for a GestureLongPress to arrive after the timer expiration. In
+// this case, it will be suppressed if the controller is in SUPPRESSING_TAPS
+// state.
+
 TapSuppressionController::Config::Config()
     : enabled(false),
-      max_cancel_to_down_time(base::TimeDelta::FromMilliseconds(180)),
-      max_tap_gap_time(base::TimeDelta::FromMilliseconds(500)) {
+      max_cancel_to_down_time(base::TimeDelta::FromMilliseconds(180)) {
+  ui::GestureConfiguration* gesture_config =
+      ui::GestureConfiguration::GetInstance();
+  max_tap_gap_time = base::TimeDelta::FromMilliseconds(
+      gesture_config->long_press_time_in_ms() + 50);
 }
 
 TapSuppressionController::TapSuppressionController(
     TapSuppressionControllerClient* client,
     const Config& config)
     : client_(client),
       state_(config.enabled ? NOTHING : DISABLED),
       max_cancel_to_down_time_(config.max_cancel_to_down_time),
       max_tap_gap_time_(config.max_tap_gap_time) {
 }
 
 TapSuppressionController::~TapSuppressionController() {}
 
 void TapSuppressionController::GestureFlingCancel() {
   switch (state_) {
     case DISABLED:
       break;
     case NOTHING:
     case GFC_IN_PROGRESS:
     case LAST_CANCEL_STOPPED_FLING:
+    case SUPPRESSING_TAPS:
       state_ = GFC_IN_PROGRESS;
       break;
     case TAP_DOWN_STASHED:
       break;
   }
 }
 
 void TapSuppressionController::GestureFlingCancelAck(bool processed) {
   base::TimeTicks event_time = Now();
   switch (state_) {
     case DISABLED:
     case NOTHING:
+    case SUPPRESSING_TAPS:
       break;
     case GFC_IN_PROGRESS:
       if (processed)
         fling_cancel_time_ = event_time;
       state_ = LAST_CANCEL_STOPPED_FLING;
       break;
     case TAP_DOWN_STASHED:
       if (!processed) {
         TRACE_EVENT0("browser",
                      "TapSuppressionController::GestureFlingCancelAck");
         StopTapDownTimer();
-        client_->ForwardStashedTapDown();
+        // If the fling cancel is not processed, forward all stashed
+        // gesture events.
+        client_->ForwardStashedGestureEvents();
         state_ = NOTHING;
       }  // Else waiting for the timer to release the stashed tap down.
       break;
     case LAST_CANCEL_STOPPED_FLING:
       break;
   }
 }
 
 bool TapSuppressionController::ShouldDeferTapDown() {
   base::TimeTicks event_time = Now();
@@ skipping 11 matching lines @@
       return false;
     case LAST_CANCEL_STOPPED_FLING:
       if ((event_time - fling_cancel_time_) < max_cancel_to_down_time_) {
         state_ = TAP_DOWN_STASHED;
         StartTapDownTimer(max_tap_gap_time_);
         return true;
       } else {
         state_ = NOTHING;
         return false;
       }
+    // Stop suppressing tap end events.
+    case SUPPRESSING_TAPS:
+      state_ = NOTHING;
+      return false;
   }
   NOTREACHED() << "Invalid state";
   return false;
 }
 
 bool TapSuppressionController::ShouldSuppressTapEnd() {
   switch (state_) {
     case DISABLED:
     case NOTHING:
     case GFC_IN_PROGRESS:
       return false;
     case TAP_DOWN_STASHED:
-      state_ = NOTHING;
+      // A tap cancel happens before long tap and two finger tap events. To
+      // drop the latter events as well as the tap cancel, change the state
+      // to "SUPPRESSING_TAPS" when the stashed tap down is dropped.
+      state_ = SUPPRESSING_TAPS;
       StopTapDownTimer();
       client_->DropStashedTapDown();
       return true;
     case LAST_CANCEL_STOPPED_FLING:
       NOTREACHED() << "Invalid tap end on LAST_CANCEL_STOPPED_FLING state";
+    case SUPPRESSING_TAPS:
+      return true;
   }
   return false;
 }
 
 base::TimeTicks TapSuppressionController::Now() {
   return base::TimeTicks::Now();
 }
 
 void TapSuppressionController::StartTapDownTimer(const base::TimeDelta& delay) {
   tap_down_timer_.Start(FROM_HERE, delay, this,
                         &TapSuppressionController::TapDownTimerExpired);
 }
 
 void TapSuppressionController::StopTapDownTimer() {
   tap_down_timer_.Stop();
 }
 
 void TapSuppressionController::TapDownTimerExpired() {
   switch (state_) {
     case DISABLED:
     case NOTHING:
+    case SUPPRESSING_TAPS:
       NOTREACHED() << "Timer fired on invalid state.";
       break;
     case GFC_IN_PROGRESS:
     case LAST_CANCEL_STOPPED_FLING:
       NOTREACHED() << "Timer fired on invalid state.";
       state_ = NOTHING;
       break;
     case TAP_DOWN_STASHED:
       TRACE_EVENT0("browser",
                    "TapSuppressionController::TapDownTimerExpired");
+      // When the timer expires, only forward the stashed tap down event, and
+      // drop other stashed gesture events (show press or long press).
       client_->ForwardStashedTapDown();
-      state_ = NOTHING;
+      state_ = SUPPRESSING_TAPS;
       break;
   }
 }
 
 }  // namespace content