content/browser/renderer_host/input/tap_suppression_controller_unittest.cc

   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