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

content/browser/renderer_host/input/tap_suppression_controller_unittest.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 <memory>
 
 #include "base/macros.h"
 #include "content/browser/renderer_host/input/tap_suppression_controller_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 namespace content {
 
 class MockTapSuppressionController : public TapSuppressionController,
                                      public TapSuppressionControllerClient {
  public:
   using TapSuppressionController::DISABLED;
   using TapSuppressionController::NOTHING;
   using TapSuppressionController::GFC_IN_PROGRESS;
   using TapSuppressionController::TAP_DOWN_STASHED;
   using TapSuppressionController::LAST_CANCEL_STOPPED_FLING;
+  using TapSuppressionController::SUPPRESSING_TAPS;
 
   enum Action {
     NONE                                 = 0,
     TAP_DOWN_DEFERRED                    = 1 << 0,
     TAP_DOWN_FORWARDED                   = 1 << 1,
     TAP_DOWN_DROPPED                     = 1 << 2,
     TAP_UP_SUPPRESSED                    = 1 << 3,
     TAP_UP_FORWARDED                     = 1 << 4,
     TAP_CANCEL_SUPPRESSED                = 1 << 5,
     TAP_CANCEL_FORWARDED                 = 1 << 6,
@@ skipping 62 matching lines @@
     timer_expiry_time_ = time_ + delay;
     timer_started_ = true;
   }
 
   void StopTapDownTimer() override { timer_started_ = false; }
 
  private:
   // TapSuppressionControllerClient implementation
   void DropStashedTapDown() override { last_actions_ |= TAP_DOWN_DROPPED; }
 
+  void ForwardStashedGestureEvents() override {
+    last_actions_ |= STASHED_TAP_DOWN_FORWARDED;
+  }
+
   void ForwardStashedTapDown() override {
     last_actions_ |= STASHED_TAP_DOWN_FORWARDED;
   }
 
   // Hiding some derived public methods
   using TapSuppressionController::GestureFlingCancel;
   using TapSuppressionController::GestureFlingCancelAck;
   using TapSuppressionController::ShouldDeferTapDown;
   using TapSuppressionController::ShouldSuppressTapEnd;
 
@@ skipping 54 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Send TapUp. This TapUp should be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
             MockTapSuppressionController::TAP_DOWN_DROPPED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
 // TapDown, but there is a small delay between TapDown and TapUp.
 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapInsufficientlyLateTapUp) {
   // Send GestureFlingCancel.
   tap_suppression_controller_->SendGestureFlingCancel();
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
@@ skipping 20 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Send TapUp. This TapUp should be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
             MockTapSuppressionController::TAP_DOWN_DROPPED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
 // TapDown, but there is a long delay between TapDown and TapUp.
 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapSufficientlyLateTapUp) {
   // Send GestureFlingCancel.
   tap_suppression_controller_->SendGestureFlingCancel();
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
@@ skipping 12 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Wait more than allowed delay between TapDown and TapUp, so they are not
   // considered a tap. This should release the previously suppressed TapDown.
   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(13));
   EXPECT_EQ(MockTapSuppressionController::STASHED_TAP_DOWN_FORWARDED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 
-  // Send TapUp. This TapUp should not be suppressed.
+  // Send TapUp. This TapUp should be still suppressed.
+  // LongTap should be suppressed when the previously suppressed TapDown is
+  // forwarded because of the timer expiration.
   tap_suppression_controller_->SendTapUp();
-  EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
+  EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
 // TapDown, but there is a small delay between the Ack and TapDown.
 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapInsufficientlyLateTapDown) {
   // Send GestureFlingCancel.
   tap_suppression_controller_->SendGestureFlingCancel();
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
@@ skipping 20 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Send TapUp. This TapUp should be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
             MockTapSuppressionController::TAP_DOWN_DROPPED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
 // TapDown, but there is a long delay between the Ack and TapDown.
 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapSufficientlyLateTapDown) {
   // Send GestureFlingCancel.
   tap_suppression_controller_->SendGestureFlingCancel();
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
@@ skipping 85 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Send TapUp. This TapUp should be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
             MockTapSuppressionController::TAP_DOWN_DROPPED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test TapSuppressionController for when GestureFlingCancel Ack comes after
 // TapDown and there is a small delay between the Ack and TapUp.
 TEST_F(TapSuppressionControllerTest, GFCAckAfterTapInsufficientlyLateTapUp) {
   // Send GestureFlingCancel.
   tap_suppression_controller_->SendGestureFlingCancel();
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
@@ skipping 20 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Send TapUp. This TapUp should be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
             MockTapSuppressionController::TAP_DOWN_DROPPED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test TapSuppressionController for when GestureFlingCancel Ack comes after
 // TapDown and there is a long delay between the Ack and TapUp.
 TEST_F(TapSuppressionControllerTest, GFCAckAfterTapSufficientlyLateTapUp) {
   // Send GestureFlingCancel.
   tap_suppression_controller_->SendGestureFlingCancel();
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
@@ skipping 12 matching lines @@
   EXPECT_EQ(MockTapSuppressionController::NONE,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
             tap_suppression_controller_->state());
 
   // Wait more than allowed delay between TapDown and TapUp, so they are not
   // considered as a tap. This should release the previously suppressed TapDown.
   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(13));
   EXPECT_EQ(MockTapSuppressionController::STASHED_TAP_DOWN_FORWARDED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 
-  // Send TapUp. This TapUp should not be suppressed.
+  // Send TapUp. This TapUp should be still suppressed.
+  // LongTap should be suppressed when the previously suppressed TapDown is
+  // forwarded because of timer expiration.
   tap_suppression_controller_->SendTapUp();
-  EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
+  EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED,
             tap_suppression_controller_->last_actions());
-  EXPECT_EQ(MockTapSuppressionController::NOTHING,
+  EXPECT_EQ(MockTapSuppressionController::SUPPRESSING_TAPS,
             tap_suppression_controller_->state());
 }
 
 // Test that no suppression occurs if the TapSuppressionController is disabled.
 TEST_F(TapSuppressionControllerTest, NoSuppressionIfDisabled) {
   TapSuppressionController::Config disabled_config;
   disabled_config.enabled = false;
   tap_suppression_controller_.reset(
       new MockTapSuppressionController(disabled_config));
 
@@ skipping 20 matching lines @@
 
   // Send TapUp. This TapUp should not be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::DISABLED,
             tap_suppression_controller_->state());
 }
 
 }  // namespace content