Home | History | Annotate | Download | only in input 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/basictypes.h"
      6 #include "base/memory/scoped_ptr.h"
      7 #include "content/browser/renderer_host/input/tap_suppression_controller.h"
      8 #include "content/browser/renderer_host/input/tap_suppression_controller_client.h"
      9 #include "testing/gtest/include/gtest/gtest.h"
     10 
     11 using base::TimeDelta;
     12 
     13 namespace content {
     14 
     15 class MockTapSuppressionController : public TapSuppressionController,
     16                                      public TapSuppressionControllerClient {
     17  public:
     18   using TapSuppressionController::DISABLED;
     19   using TapSuppressionController::NOTHING;
     20   using TapSuppressionController::GFC_IN_PROGRESS;
     21   using TapSuppressionController::TAP_DOWN_STASHED;
     22   using TapSuppressionController::LAST_CANCEL_STOPPED_FLING;
     23 
     24   enum Action {
     25     NONE                                 = 0,
     26     TAP_DOWN_DEFERRED                    = 1 << 0,
     27     TAP_DOWN_FORWARDED                   = 1 << 1,
     28     TAP_DOWN_DROPPED                     = 1 << 2,
     29     TAP_UP_SUPPRESSED                    = 1 << 3,
     30     TAP_UP_FORWARDED                     = 1 << 4,
     31     TAP_CANCEL_SUPPRESSED                = 1 << 5,
     32     TAP_CANCEL_FORWARDED                 = 1 << 6,
     33     STASHED_TAP_DOWN_FORWARDED           = 1 << 7,
     34   };
     35 
     36   MockTapSuppressionController(const TapSuppressionController::Config& config)
     37       : TapSuppressionController(this, config),
     38         last_actions_(NONE),
     39         time_(),
     40         timer_started_(false) {}
     41 
     42   virtual ~MockTapSuppressionController() {}
     43 
     44   void SendGestureFlingCancel() {
     45     last_actions_ = NONE;
     46     GestureFlingCancel();
     47   }
     48 
     49   void SendGestureFlingCancelAck(bool processed) {
     50     last_actions_ = NONE;
     51     GestureFlingCancelAck(processed);
     52   }
     53 
     54   void SendTapDown() {
     55     last_actions_ = NONE;
     56     if (ShouldDeferTapDown())
     57       last_actions_ |= TAP_DOWN_DEFERRED;
     58     else
     59       last_actions_ |= TAP_DOWN_FORWARDED;
     60   }
     61 
     62   void SendTapUp() {
     63     last_actions_ = NONE;
     64     if (ShouldSuppressTapEnd())
     65       last_actions_ |= TAP_UP_SUPPRESSED;
     66     else
     67       last_actions_ |= TAP_UP_FORWARDED;
     68   }
     69 
     70   void SendTapCancel() {
     71     last_actions_ = NONE;
     72     if (ShouldSuppressTapEnd())
     73       last_actions_ |= TAP_CANCEL_SUPPRESSED;
     74     else
     75       last_actions_ |= TAP_CANCEL_FORWARDED;
     76   }
     77 
     78   void AdvanceTime(const base::TimeDelta& delta) {
     79     last_actions_ = NONE;
     80     time_ += delta;
     81     if (timer_started_ && time_ >= timer_expiry_time_) {
     82       timer_started_ = false;
     83       TapDownTimerExpired();
     84     }
     85   }
     86 
     87   State state() { return state_; }
     88 
     89   int last_actions() { return last_actions_; }
     90 
     91  protected:
     92   virtual base::TimeTicks Now() OVERRIDE {
     93     return time_;
     94   }
     95 
     96   virtual void StartTapDownTimer(const base::TimeDelta& delay) OVERRIDE {
     97     timer_expiry_time_ = time_ + delay;
     98     timer_started_ = true;
     99   }
    100 
    101   virtual void StopTapDownTimer() OVERRIDE {
    102     timer_started_ = false;
    103   }
    104 
    105  private:
    106   // TapSuppressionControllerClient implementation
    107   virtual void DropStashedTapDown() OVERRIDE {
    108     last_actions_ |= TAP_DOWN_DROPPED;
    109   }
    110 
    111   virtual void ForwardStashedTapDown() OVERRIDE {
    112     last_actions_ |= STASHED_TAP_DOWN_FORWARDED;
    113   }
    114 
    115   // Hiding some derived public methods
    116   using TapSuppressionController::GestureFlingCancel;
    117   using TapSuppressionController::GestureFlingCancelAck;
    118   using TapSuppressionController::ShouldDeferTapDown;
    119   using TapSuppressionController::ShouldSuppressTapEnd;
    120 
    121   int last_actions_;
    122 
    123   base::TimeTicks time_;
    124   bool timer_started_;
    125   base::TimeTicks timer_expiry_time_;
    126 
    127   DISALLOW_COPY_AND_ASSIGN(MockTapSuppressionController);
    128 };
    129 
    130 class TapSuppressionControllerTest : public testing::Test {
    131  public:
    132   TapSuppressionControllerTest() {
    133   }
    134   virtual ~TapSuppressionControllerTest() {
    135   }
    136 
    137  protected:
    138   // testing::Test
    139   virtual void SetUp() {
    140     tap_suppression_controller_.reset(
    141         new MockTapSuppressionController(GetConfig()));
    142   }
    143 
    144   virtual void TearDown() {
    145     tap_suppression_controller_.reset();
    146   }
    147 
    148   static TapSuppressionController::Config GetConfig() {
    149     TapSuppressionController::Config config;
    150     config.enabled = true;
    151     config.max_cancel_to_down_time = base::TimeDelta::FromMilliseconds(10);
    152     config.max_tap_gap_time = base::TimeDelta::FromMilliseconds(10);
    153     return config;
    154   }
    155 
    156   scoped_ptr<MockTapSuppressionController> tap_suppression_controller_;
    157 };
    158 
    159 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
    160 // TapDown and everything happens without any delays.
    161 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapFast) {
    162   // Send GestureFlingCancel.
    163   tap_suppression_controller_->SendGestureFlingCancel();
    164   EXPECT_EQ(MockTapSuppressionController::NONE,
    165             tap_suppression_controller_->last_actions());
    166   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    167             tap_suppression_controller_->state());
    168 
    169   // Send GestureFlingCancel Ack.
    170   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    171   EXPECT_EQ(MockTapSuppressionController::NONE,
    172             tap_suppression_controller_->last_actions());
    173   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    174             tap_suppression_controller_->state());
    175 
    176   // Send TapDown. This TapDown should be suppressed.
    177   tap_suppression_controller_->SendTapDown();
    178   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    179             tap_suppression_controller_->last_actions());
    180   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    181             tap_suppression_controller_->state());
    182 
    183   // Send TapUp. This TapUp should be suppressed.
    184   tap_suppression_controller_->SendTapUp();
    185   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
    186             MockTapSuppressionController::TAP_DOWN_DROPPED,
    187             tap_suppression_controller_->last_actions());
    188   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    189             tap_suppression_controller_->state());
    190 }
    191 
    192 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
    193 // TapDown, but there is a small delay between TapDown and TapUp.
    194 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapInsufficientlyLateTapUp) {
    195   // Send GestureFlingCancel.
    196   tap_suppression_controller_->SendGestureFlingCancel();
    197   EXPECT_EQ(MockTapSuppressionController::NONE,
    198             tap_suppression_controller_->last_actions());
    199   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    200             tap_suppression_controller_->state());
    201 
    202   // Send GestureFlingCancel Ack.
    203   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    204   EXPECT_EQ(MockTapSuppressionController::NONE,
    205             tap_suppression_controller_->last_actions());
    206   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    207             tap_suppression_controller_->state());
    208 
    209   // Send TapDown. This TapDown should be suppressed.
    210   tap_suppression_controller_->SendTapDown();
    211   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    212             tap_suppression_controller_->last_actions());
    213   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    214             tap_suppression_controller_->state());
    215 
    216   // Wait less than allowed delay between TapDown and TapUp, so they are still
    217   // considered a tap.
    218   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(7));
    219   EXPECT_EQ(MockTapSuppressionController::NONE,
    220             tap_suppression_controller_->last_actions());
    221   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    222             tap_suppression_controller_->state());
    223 
    224   // Send TapUp. This TapUp should be suppressed.
    225   tap_suppression_controller_->SendTapUp();
    226   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
    227             MockTapSuppressionController::TAP_DOWN_DROPPED,
    228             tap_suppression_controller_->last_actions());
    229   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    230             tap_suppression_controller_->state());
    231 }
    232 
    233 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
    234 // TapDown, but there is a long delay between TapDown and TapUp.
    235 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapSufficientlyLateTapUp) {
    236   // Send GestureFlingCancel.
    237   tap_suppression_controller_->SendGestureFlingCancel();
    238   EXPECT_EQ(MockTapSuppressionController::NONE,
    239             tap_suppression_controller_->last_actions());
    240   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    241             tap_suppression_controller_->state());
    242 
    243   // Send processed GestureFlingCancel Ack.
    244   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    245   EXPECT_EQ(MockTapSuppressionController::NONE,
    246             tap_suppression_controller_->last_actions());
    247   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    248             tap_suppression_controller_->state());
    249 
    250   // Send MouseDown. This MouseDown should be suppressed, for now.
    251   tap_suppression_controller_->SendTapDown();
    252   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    253             tap_suppression_controller_->last_actions());
    254   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    255             tap_suppression_controller_->state());
    256 
    257   // Wait more than allowed delay between TapDown and TapUp, so they are not
    258   // considered a tap. This should release the previously suppressed TapDown.
    259   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(13));
    260   EXPECT_EQ(MockTapSuppressionController::STASHED_TAP_DOWN_FORWARDED,
    261             tap_suppression_controller_->last_actions());
    262   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    263             tap_suppression_controller_->state());
    264 
    265   // Send TapUp. This TapUp should not be suppressed.
    266   tap_suppression_controller_->SendTapUp();
    267   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
    268             tap_suppression_controller_->last_actions());
    269   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    270             tap_suppression_controller_->state());
    271 }
    272 
    273 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
    274 // TapDown, but there is a small delay between the Ack and TapDown.
    275 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapInsufficientlyLateTapDown) {
    276   // Send GestureFlingCancel.
    277   tap_suppression_controller_->SendGestureFlingCancel();
    278   EXPECT_EQ(MockTapSuppressionController::NONE,
    279             tap_suppression_controller_->last_actions());
    280   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    281             tap_suppression_controller_->state());
    282 
    283   // Send GestureFlingCancel Ack.
    284   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    285   EXPECT_EQ(MockTapSuppressionController::NONE,
    286             tap_suppression_controller_->last_actions());
    287   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    288             tap_suppression_controller_->state());
    289 
    290   // Wait less than allowed delay between GestureFlingCancel and TapDown, so the
    291   // TapDown is still considered associated with the GestureFlingCancel.
    292   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(7));
    293   EXPECT_EQ(MockTapSuppressionController::NONE,
    294             tap_suppression_controller_->last_actions());
    295   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    296             tap_suppression_controller_->state());
    297 
    298   // Send TapDown. This TapDown should be suppressed.
    299   tap_suppression_controller_->SendTapDown();
    300   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    301             tap_suppression_controller_->last_actions());
    302   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    303             tap_suppression_controller_->state());
    304 
    305   // Send TapUp. This TapUp should be suppressed.
    306   tap_suppression_controller_->SendTapUp();
    307   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
    308             MockTapSuppressionController::TAP_DOWN_DROPPED,
    309             tap_suppression_controller_->last_actions());
    310   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    311             tap_suppression_controller_->state());
    312 }
    313 
    314 // Test TapSuppressionController for when GestureFlingCancel Ack comes before
    315 // TapDown, but there is a long delay between the Ack and TapDown.
    316 TEST_F(TapSuppressionControllerTest, GFCAckBeforeTapSufficientlyLateTapDown) {
    317   // Send GestureFlingCancel.
    318   tap_suppression_controller_->SendGestureFlingCancel();
    319   EXPECT_EQ(MockTapSuppressionController::NONE,
    320             tap_suppression_controller_->last_actions());
    321   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    322             tap_suppression_controller_->state());
    323 
    324   // Send GestureFlingCancel Ack.
    325   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    326   EXPECT_EQ(MockTapSuppressionController::NONE,
    327             tap_suppression_controller_->last_actions());
    328   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    329             tap_suppression_controller_->state());
    330 
    331   // Wait more than allowed delay between GestureFlingCancel and TapDown, so the
    332   // TapDown is not considered associated with the GestureFlingCancel.
    333   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(13));
    334   EXPECT_EQ(MockTapSuppressionController::NONE,
    335             tap_suppression_controller_->last_actions());
    336   EXPECT_EQ(MockTapSuppressionController::LAST_CANCEL_STOPPED_FLING,
    337             tap_suppression_controller_->state());
    338 
    339   // Send TapDown. This TapDown should not be suppressed.
    340   tap_suppression_controller_->SendTapDown();
    341   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_FORWARDED,
    342             tap_suppression_controller_->last_actions());
    343   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    344             tap_suppression_controller_->state());
    345 
    346   // Send MouseUp. This MouseUp should not be suppressed.
    347   tap_suppression_controller_->SendTapUp();
    348   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
    349             tap_suppression_controller_->last_actions());
    350   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    351             tap_suppression_controller_->state());
    352 }
    353 
    354 // Test TapSuppressionController for when unprocessed GestureFlingCancel Ack
    355 // comes after TapDown and everything happens without any delay.
    356 TEST_F(TapSuppressionControllerTest, GFCAckUnprocessedAfterTapFast) {
    357   // Send GestureFlingCancel.
    358   tap_suppression_controller_->SendGestureFlingCancel();
    359   EXPECT_EQ(MockTapSuppressionController::NONE,
    360             tap_suppression_controller_->last_actions());
    361   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    362             tap_suppression_controller_->state());
    363 
    364   // Send TapDown. This TapDown should be suppressed, for now.
    365   tap_suppression_controller_->SendTapDown();
    366   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    367             tap_suppression_controller_->last_actions());
    368   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    369             tap_suppression_controller_->state());
    370 
    371   // Send unprocessed GestureFlingCancel Ack. This should release the
    372   // previously suppressed TapDown.
    373   tap_suppression_controller_->SendGestureFlingCancelAck(false);
    374   EXPECT_EQ(MockTapSuppressionController::STASHED_TAP_DOWN_FORWARDED,
    375             tap_suppression_controller_->last_actions());
    376   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    377             tap_suppression_controller_->state());
    378 
    379   // Send TapUp. This TapUp should not be suppressed.
    380   tap_suppression_controller_->SendTapUp();
    381   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
    382             tap_suppression_controller_->last_actions());
    383   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    384             tap_suppression_controller_->state());
    385 }
    386 
    387 // Test TapSuppressionController for when processed GestureFlingCancel Ack comes
    388 // after TapDown and everything happens without any delay.
    389 TEST_F(TapSuppressionControllerTest, GFCAckProcessedAfterTapFast) {
    390   // Send GestureFlingCancel.
    391   tap_suppression_controller_->SendGestureFlingCancel();
    392   EXPECT_EQ(MockTapSuppressionController::NONE,
    393             tap_suppression_controller_->last_actions());
    394   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    395             tap_suppression_controller_->state());
    396 
    397   // Send TapDown. This TapDown should be suppressed.
    398   tap_suppression_controller_->SendTapDown();
    399   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    400             tap_suppression_controller_->last_actions());
    401   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    402             tap_suppression_controller_->state());
    403 
    404   // Send processed GestureFlingCancel Ack.
    405   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    406   EXPECT_EQ(MockTapSuppressionController::NONE,
    407             tap_suppression_controller_->last_actions());
    408   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    409             tap_suppression_controller_->state());
    410 
    411   // Send TapUp. This TapUp should be suppressed.
    412   tap_suppression_controller_->SendTapUp();
    413   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
    414             MockTapSuppressionController::TAP_DOWN_DROPPED,
    415             tap_suppression_controller_->last_actions());
    416   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    417             tap_suppression_controller_->state());
    418 }
    419 
    420 // Test TapSuppressionController for when GestureFlingCancel Ack comes after
    421 // TapDown and there is a small delay between the Ack and TapUp.
    422 TEST_F(TapSuppressionControllerTest, GFCAckAfterTapInsufficientlyLateTapUp) {
    423   // Send GestureFlingCancel.
    424   tap_suppression_controller_->SendGestureFlingCancel();
    425   EXPECT_EQ(MockTapSuppressionController::NONE,
    426             tap_suppression_controller_->last_actions());
    427   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    428             tap_suppression_controller_->state());
    429 
    430   // Send TapDown. This TapDown should be suppressed.
    431   tap_suppression_controller_->SendTapDown();
    432   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    433             tap_suppression_controller_->last_actions());
    434   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    435             tap_suppression_controller_->state());
    436 
    437   // Send GestureFlingCancel Ack.
    438   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    439   EXPECT_EQ(MockTapSuppressionController::NONE,
    440             tap_suppression_controller_->last_actions());
    441   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    442             tap_suppression_controller_->state());
    443 
    444   // Wait less than allowed delay between TapDown and TapUp, so they are still
    445   // considered as a tap.
    446   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(7));
    447   EXPECT_EQ(MockTapSuppressionController::NONE,
    448             tap_suppression_controller_->last_actions());
    449   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    450             tap_suppression_controller_->state());
    451 
    452   // Send TapUp. This TapUp should be suppressed.
    453   tap_suppression_controller_->SendTapUp();
    454   EXPECT_EQ(MockTapSuppressionController::TAP_UP_SUPPRESSED |
    455             MockTapSuppressionController::TAP_DOWN_DROPPED,
    456             tap_suppression_controller_->last_actions());
    457   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    458             tap_suppression_controller_->state());
    459 }
    460 
    461 // Test TapSuppressionController for when GestureFlingCancel Ack comes after
    462 // TapDown and there is a long delay between the Ack and TapUp.
    463 TEST_F(TapSuppressionControllerTest, GFCAckAfterTapSufficientlyLateTapUp) {
    464   // Send GestureFlingCancel.
    465   tap_suppression_controller_->SendGestureFlingCancel();
    466   EXPECT_EQ(MockTapSuppressionController::NONE,
    467             tap_suppression_controller_->last_actions());
    468   EXPECT_EQ(MockTapSuppressionController::GFC_IN_PROGRESS,
    469             tap_suppression_controller_->state());
    470 
    471   // Send TapDown. This TapDown should be suppressed, for now.
    472   tap_suppression_controller_->SendTapDown();
    473   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_DEFERRED,
    474             tap_suppression_controller_->last_actions());
    475   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    476             tap_suppression_controller_->state());
    477 
    478   // Send GestureFlingCancel Ack.
    479   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    480   EXPECT_EQ(MockTapSuppressionController::NONE,
    481             tap_suppression_controller_->last_actions());
    482   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_STASHED,
    483             tap_suppression_controller_->state());
    484 
    485   // Wait more than allowed delay between TapDown and TapUp, so they are not
    486   // considered as a tap. This should release the previously suppressed TapDown.
    487   tap_suppression_controller_->AdvanceTime(TimeDelta::FromMilliseconds(13));
    488   EXPECT_EQ(MockTapSuppressionController::STASHED_TAP_DOWN_FORWARDED,
    489             tap_suppression_controller_->last_actions());
    490   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    491             tap_suppression_controller_->state());
    492 
    493   // Send TapUp. This TapUp should not be suppressed.
    494   tap_suppression_controller_->SendTapUp();
    495   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
    496             tap_suppression_controller_->last_actions());
    497   EXPECT_EQ(MockTapSuppressionController::NOTHING,
    498             tap_suppression_controller_->state());
    499 }
    500 
    501 // Test that no suppression occurs if the TapSuppressionController is disabled.
    502 TEST_F(TapSuppressionControllerTest, NoSuppressionIfDisabled) {
    503   TapSuppressionController::Config disabled_config;
    504   disabled_config.enabled = false;
    505   tap_suppression_controller_.reset(
    506       new MockTapSuppressionController(disabled_config));
    507 
    508   // Send GestureFlingCancel.
    509   tap_suppression_controller_->SendGestureFlingCancel();
    510   EXPECT_EQ(MockTapSuppressionController::NONE,
    511             tap_suppression_controller_->last_actions());
    512   EXPECT_EQ(MockTapSuppressionController::DISABLED,
    513             tap_suppression_controller_->state());
    514 
    515   // Send GestureFlingCancel Ack.
    516   tap_suppression_controller_->SendGestureFlingCancelAck(true);
    517   EXPECT_EQ(MockTapSuppressionController::NONE,
    518             tap_suppression_controller_->last_actions());
    519   EXPECT_EQ(MockTapSuppressionController::DISABLED,
    520             tap_suppression_controller_->state());
    521 
    522   // Send TapDown. This TapDown should not be suppressed.
    523   tap_suppression_controller_->SendTapDown();
    524   EXPECT_EQ(MockTapSuppressionController::TAP_DOWN_FORWARDED,
    525             tap_suppression_controller_->last_actions());
    526   EXPECT_EQ(MockTapSuppressionController::DISABLED,
    527             tap_suppression_controller_->state());
    528 
    529   // Send TapUp. This TapUp should not be suppressed.
    530   tap_suppression_controller_->SendTapUp();
    531   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
    532             tap_suppression_controller_->last_actions());
    533   EXPECT_EQ(MockTapSuppressionController::DISABLED,
    534             tap_suppression_controller_->state());
    535 }
    536 
    537 }  // namespace content
    538