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