TestTransformNotifications.cpp (19645B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #include "APZCBasicTester.h" 8 #include "APZCTreeManagerTester.h" 9 #include "APZTestCommon.h" 10 #include "mozilla/layers/WebRenderScrollDataWrapper.h" 11 #include "apz/util/APZEventState.h" 12 13 #include "InputUtils.h" 14 15 class APZCTransformNotificationTester : public APZCTreeManagerTester { 16 public: 17 explicit APZCTransformNotificationTester() { CreateMockHitTester(); } 18 19 UniquePtr<ScopedLayerTreeRegistration> mRegistration; 20 21 RefPtr<TestAsyncPanZoomController> mRootApzc; 22 23 void SetupBasicTest() { 24 const char* treeShape = "x"; 25 LayerIntRect layerVisibleRect[] = { 26 LayerIntRect(0, 0, 100, 100), 27 }; 28 CreateScrollData(treeShape, layerVisibleRect); 29 SetScrollableFrameMetrics(root, ScrollableLayerGuid::START_SCROLL_ID, 30 CSSRect(0, 0, 500, 500)); 31 32 mRegistration = MakeUnique<ScopedLayerTreeRegistration>(LayersId{0}, mcc); 33 34 UpdateHitTestingTree(); 35 36 mRootApzc = ApzcOf(root); 37 } 38 39 void SetupNonScrollableTest() { 40 const char* treeShape = "x"; 41 LayerIntRect layerVisibleRect[] = { 42 LayerIntRect(0, 0, 100, 100), 43 }; 44 CreateScrollData(treeShape, layerVisibleRect); 45 SetScrollableFrameMetrics(root, ScrollableLayerGuid::START_SCROLL_ID, 46 CSSRect(0, 0, 100, 100)); 47 48 mRegistration = MakeUnique<ScopedLayerTreeRegistration>(LayersId{0}, mcc); 49 50 UpdateHitTestingTree(); 51 52 mRootApzc = ApzcOf(root); 53 54 mRootApzc->GetFrameMetrics().SetIsRootContent(true); 55 } 56 }; 57 58 TEST_F(APZCTransformNotificationTester, PanningTransformNotifications) { 59 SCOPED_GFX_PREF_BOOL("apz.overscroll.enabled", true); 60 61 SetupBasicTest(); 62 63 // Scroll down by 25 px. Ensure we only get one set of 64 // state change notifications. 65 // 66 // Then, scroll back up by 20px, this time flinging after. 67 // The fling should cover the remaining 5 px of room to scroll, then 68 // go into overscroll, and finally snap-back to recover from overscroll. 69 // Again, ensure we only get one set of state change notifications for 70 // this entire procedure. 71 72 MockFunction<void(std::string checkPointName)> check; 73 { 74 InSequence s; 75 EXPECT_CALL(check, Call("Simple pan")); 76 EXPECT_CALL( 77 *mcc, NotifyAPZStateChange( 78 _, GeckoContentController::APZStateChange::eStartTouch, _, _)) 79 .Times(1); 80 EXPECT_CALL( 81 *mcc, 82 NotifyAPZStateChange( 83 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 84 .Times(1); 85 EXPECT_CALL( 86 *mcc, 87 NotifyAPZStateChange( 88 _, GeckoContentController::APZStateChange::eStartPanning, _, _)) 89 .Times(1); 90 EXPECT_CALL(*mcc, 91 NotifyAPZStateChange( 92 _, GeckoContentController::APZStateChange::eEndTouch, _, _)) 93 .Times(1); 94 EXPECT_CALL( 95 *mcc, 96 NotifyAPZStateChange( 97 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 98 .Times(1); 99 EXPECT_CALL(check, Call("Complex pan")); 100 EXPECT_CALL( 101 *mcc, NotifyAPZStateChange( 102 _, GeckoContentController::APZStateChange::eStartTouch, _, _)) 103 .Times(1); 104 EXPECT_CALL( 105 *mcc, 106 NotifyAPZStateChange( 107 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 108 .Times(1); 109 EXPECT_CALL( 110 *mcc, 111 NotifyAPZStateChange( 112 _, GeckoContentController::APZStateChange::eStartPanning, _, _)) 113 .Times(1); 114 EXPECT_CALL(*mcc, 115 NotifyAPZStateChange( 116 _, GeckoContentController::APZStateChange::eEndTouch, _, _)) 117 .Times(1); 118 EXPECT_CALL( 119 *mcc, 120 NotifyAPZStateChange( 121 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 122 .Times(1); 123 EXPECT_CALL(check, Call("Done")); 124 } 125 126 check.Call("Simple pan"); 127 Pan(mRootApzc, 50, 25, PanOptions::NoFling); 128 check.Call("Complex pan"); 129 Pan(mRootApzc, 25, 45); 130 mRootApzc->AdvanceAnimationsUntilEnd(); 131 check.Call("Done"); 132 } 133 134 TEST_F(APZCTransformNotificationTester, PanWithMomentumTransformNotifications) { 135 SetupBasicTest(); 136 137 MockFunction<void(std::string checkPointName)> check; 138 { 139 InSequence s; 140 EXPECT_CALL(check, Call("Pan Start")); 141 EXPECT_CALL( 142 *mcc, 143 NotifyAPZStateChange( 144 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 145 .Times(1); 146 147 EXPECT_CALL(check, Call("Panning")); 148 EXPECT_CALL(check, Call("Pan End")); 149 EXPECT_CALL(check, Call("Momentum Start")); 150 151 EXPECT_CALL(check, Call("Momentum Pan")); 152 EXPECT_CALL(check, Call("Momentum End")); 153 // The TransformEnd should only be sent after the momentum pan. 154 EXPECT_CALL( 155 *mcc, 156 NotifyAPZStateChange( 157 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 158 .Times(1); 159 160 EXPECT_CALL(check, Call("Done")); 161 } 162 163 check.Call("Pan Start"); 164 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 165 PanGesture(PanGestureInput::PANGESTURE_START, manager, ScreenIntPoint(50, 50), 166 ScreenIntPoint(1, 2), mcc->Time()); 167 mcc->AdvanceByMillis(5); 168 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 169 170 check.Call("Panning"); 171 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 172 PanGesture(PanGestureInput::PANGESTURE_PAN, mRootApzc, ScreenIntPoint(50, 50), 173 ScreenPoint(15, 30), mcc->Time()); 174 mcc->AdvanceByMillis(5); 175 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 176 177 check.Call("Pan End"); 178 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 179 PanGesture(PanGestureInput::PANGESTURE_END, manager, ScreenIntPoint(50, 50), 180 ScreenPoint(0, 0), mcc->Time()); 181 mcc->AdvanceByMillis(5); 182 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 183 184 check.Call("Momentum Start"); 185 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 186 PanGesture(PanGestureInput::PANGESTURE_MOMENTUMSTART, manager, 187 ScreenIntPoint(50, 50), ScreenPoint(30, 90), mcc->Time()); 188 mcc->AdvanceByMillis(10); 189 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 190 191 check.Call("Momentum Pan"); 192 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 193 PanGesture(PanGestureInput::PANGESTURE_MOMENTUMPAN, manager, 194 ScreenIntPoint(50, 50), ScreenPoint(10, 30), mcc->Time()); 195 mcc->AdvanceByMillis(10); 196 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 197 198 check.Call("Momentum End"); 199 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 200 PanGesture(PanGestureInput::PANGESTURE_MOMENTUMEND, manager, 201 ScreenIntPoint(50, 50), ScreenPoint(0, 0), mcc->Time()); 202 mcc->AdvanceByMillis(10); 203 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 204 205 check.Call("Done"); 206 } 207 208 TEST_F(APZCTransformNotificationTester, 209 PanWithoutMomentumTransformNotifications) { 210 // Ensure that the TransformEnd delay is 100ms. 211 SCOPED_GFX_PREF_INT("apz.scrollend-event.content.delay_ms", 100); 212 213 SetupBasicTest(); 214 215 MockFunction<void(std::string checkPointName)> check; 216 { 217 InSequence s; 218 EXPECT_CALL(check, Call("Pan Start")); 219 EXPECT_CALL( 220 *mcc, 221 NotifyAPZStateChange( 222 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 223 .Times(1); 224 225 EXPECT_CALL(check, Call("Panning")); 226 EXPECT_CALL(check, Call("Pan End")); 227 EXPECT_CALL(check, Call("TransformEnd delay")); 228 // The TransformEnd should only be sent after the pan gesture and 100ms 229 // timer fire. 230 EXPECT_CALL( 231 *mcc, 232 NotifyAPZStateChange( 233 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 234 .Times(1); 235 236 EXPECT_CALL(check, Call("Done")); 237 } 238 239 check.Call("Pan Start"); 240 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 241 PanGesture(PanGestureInput::PANGESTURE_START, manager, ScreenIntPoint(50, 50), 242 ScreenIntPoint(1, 2), mcc->Time()); 243 mcc->AdvanceByMillis(5); 244 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 245 246 check.Call("Panning"); 247 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 248 PanGesture(PanGestureInput::PANGESTURE_PAN, mRootApzc, ScreenIntPoint(50, 50), 249 ScreenPoint(15, 30), mcc->Time()); 250 mcc->AdvanceByMillis(5); 251 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 252 253 check.Call("Pan End"); 254 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 255 PanGesture(PanGestureInput::PANGESTURE_END, manager, ScreenIntPoint(50, 50), 256 ScreenPoint(0, 0), mcc->Time()); 257 mcc->AdvanceByMillis(55); 258 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 259 260 check.Call("TransformEnd delay"); 261 mcc->AdvanceByMillis(55); 262 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 263 264 check.Call("Done"); 265 } 266 267 TEST_F(APZCTransformNotificationTester, 268 PanFollowedByNewPanTransformNotifications) { 269 // Ensure that the TransformEnd delay is 100ms. 270 SCOPED_GFX_PREF_INT("apz.scrollend-event.content.delay_ms", 100); 271 272 SetupBasicTest(); 273 274 MockFunction<void(std::string checkPointName)> check; 275 { 276 InSequence s; 277 EXPECT_CALL(check, Call("Pan Start")); 278 EXPECT_CALL( 279 *mcc, 280 NotifyAPZStateChange( 281 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 282 .Times(1); 283 284 EXPECT_CALL(check, Call("Panning")); 285 EXPECT_CALL(check, Call("Pan End")); 286 // The TransformEnd delay should be cut short and delivered before the 287 // new pan gesture begins. 288 EXPECT_CALL(check, Call("New Pan Start")); 289 EXPECT_CALL( 290 *mcc, 291 NotifyAPZStateChange( 292 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 293 .Times(1); 294 EXPECT_CALL( 295 *mcc, 296 NotifyAPZStateChange( 297 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 298 .Times(1); 299 EXPECT_CALL(check, Call("New Pan End")); 300 EXPECT_CALL( 301 *mcc, 302 NotifyAPZStateChange( 303 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 304 .Times(1); 305 306 EXPECT_CALL(check, Call("Done")); 307 } 308 309 check.Call("Pan Start"); 310 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 311 PanGesture(PanGestureInput::PANGESTURE_START, manager, ScreenIntPoint(50, 50), 312 ScreenIntPoint(1, 2), mcc->Time()); 313 mcc->AdvanceByMillis(5); 314 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 315 316 check.Call("Panning"); 317 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 318 PanGesture(PanGestureInput::PANGESTURE_PAN, mRootApzc, ScreenIntPoint(50, 50), 319 ScreenPoint(15, 30), mcc->Time()); 320 mcc->AdvanceByMillis(5); 321 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 322 323 check.Call("Pan End"); 324 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 325 PanGesture(PanGestureInput::PANGESTURE_END, manager, ScreenIntPoint(50, 50), 326 ScreenPoint(0, 0), mcc->Time()); 327 mcc->AdvanceByMillis(55); 328 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 329 330 check.Call("New Pan Start"); 331 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 332 PanGesture(PanGestureInput::PANGESTURE_START, manager, ScreenIntPoint(50, 50), 333 ScreenIntPoint(1, 2), mcc->Time()); 334 mcc->AdvanceByMillis(5); 335 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 336 337 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 338 PanGesture(PanGestureInput::PANGESTURE_PAN, mRootApzc, ScreenIntPoint(50, 50), 339 ScreenPoint(15, 30), mcc->Time()); 340 mcc->AdvanceByMillis(5); 341 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 342 343 check.Call("New Pan End"); 344 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 345 PanGesture(PanGestureInput::PANGESTURE_END, manager, ScreenIntPoint(50, 50), 346 ScreenPoint(0, 0), mcc->Time()); 347 mcc->AdvanceByMillis(105); 348 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 349 350 check.Call("Done"); 351 } 352 353 TEST_F(APZCTransformNotificationTester, 354 PanFollowedByWheelTransformNotifications) { 355 // Needed because the test uses SmoothWheel() 356 SCOPED_GFX_PREF_BOOL("general.smoothScroll", true); 357 // Ensure that the TransformEnd delay is 100ms. 358 SCOPED_GFX_PREF_INT("apz.scrollend-event.content.delay_ms", 100); 359 360 SetupBasicTest(); 361 362 MockFunction<void(std::string checkPointName)> check; 363 { 364 InSequence s; 365 EXPECT_CALL(check, Call("Pan Start")); 366 EXPECT_CALL( 367 *mcc, 368 NotifyAPZStateChange( 369 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 370 .Times(1); 371 372 EXPECT_CALL(check, Call("Panning")); 373 EXPECT_CALL(check, Call("Pan End")); 374 // The TransformEnd delay should be cut short and delivered before the 375 // new wheel event begins. 376 EXPECT_CALL(check, Call("Wheel Start")); 377 EXPECT_CALL( 378 *mcc, 379 NotifyAPZStateChange( 380 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 381 .Times(1); 382 EXPECT_CALL( 383 *mcc, 384 NotifyAPZStateChange( 385 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 386 .Times(1); 387 EXPECT_CALL(check, Call("Wheel End")); 388 EXPECT_CALL( 389 *mcc, 390 NotifyAPZStateChange( 391 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 392 .Times(1); 393 EXPECT_CALL(check, Call("Done")); 394 } 395 396 check.Call("Pan Start"); 397 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 398 PanGesture(PanGestureInput::PANGESTURE_START, manager, ScreenIntPoint(50, 50), 399 ScreenIntPoint(1, 2), mcc->Time()); 400 mcc->AdvanceByMillis(5); 401 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 402 403 check.Call("Panning"); 404 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 405 PanGesture(PanGestureInput::PANGESTURE_PAN, mRootApzc, ScreenIntPoint(50, 50), 406 ScreenPoint(15, 30), mcc->Time()); 407 mcc->AdvanceByMillis(5); 408 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 409 410 check.Call("Pan End"); 411 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 412 PanGesture(PanGestureInput::PANGESTURE_END, manager, ScreenIntPoint(50, 50), 413 ScreenPoint(0, 0), mcc->Time()); 414 mcc->AdvanceByMillis(55); 415 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 416 417 check.Call("Wheel Start"); 418 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 419 SmoothWheel(manager, ScreenIntPoint(50, 50), ScreenPoint(10, 10), 420 mcc->Time()); 421 mcc->AdvanceByMillis(10); 422 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 423 424 check.Call("Wheel End"); 425 426 mRootApzc->AdvanceAnimationsUntilEnd(); 427 428 check.Call("Done"); 429 } 430 431 #ifndef MOZ_WIDGET_ANDROID // Currently fails on Android 432 TEST_F(APZCTransformNotificationTester, PanOverscrollTransformNotifications) { 433 SCOPED_GFX_PREF_BOOL("apz.overscroll.enabled", true); 434 435 SetupBasicTest(); 436 437 MockFunction<void(std::string checkPointName)> check; 438 { 439 InSequence s; 440 EXPECT_CALL(check, Call("Pan Start")); 441 EXPECT_CALL( 442 *mcc, 443 NotifyAPZStateChange( 444 _, GeckoContentController::APZStateChange::eTransformBegin, _, _)) 445 .Times(1); 446 447 EXPECT_CALL(check, Call("Panning Into Overscroll")); 448 EXPECT_CALL(check, Call("Pan End")); 449 EXPECT_CALL(check, Call("Overscroll Animation End")); 450 // The TransformEnd should only be sent after the overscroll animation 451 // completes. 452 EXPECT_CALL( 453 *mcc, 454 NotifyAPZStateChange( 455 _, GeckoContentController::APZStateChange::eTransformEnd, _, _)) 456 .Times(1); 457 EXPECT_CALL(check, Call("Done")); 458 } 459 460 check.Call("Pan Start"); 461 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 462 PanGesture(PanGestureInput::PANGESTURE_START, manager, ScreenIntPoint(50, 50), 463 ScreenIntPoint(1, 2), mcc->Time()); 464 mcc->AdvanceByMillis(5); 465 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 466 467 check.Call("Panning Into Overscroll"); 468 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 469 PanGesture(PanGestureInput::PANGESTURE_PAN, mRootApzc, ScreenIntPoint(50, 50), 470 ScreenPoint(15, -30), mcc->Time()); 471 mcc->AdvanceByMillis(5); 472 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 473 474 // Ensure that we have overscrolled. 475 EXPECT_TRUE(mRootApzc->IsOverscrolled()); 476 477 check.Call("Pan End"); 478 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 479 PanGesture(PanGestureInput::PANGESTURE_END, manager, ScreenIntPoint(50, 50), 480 ScreenPoint(0, 0), mcc->Time()); 481 mcc->AdvanceByMillis(5); 482 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 483 484 // Wait for the overscroll animation to complete and the TransformEnd 485 // notification to be sent. 486 check.Call("Overscroll Animation End"); 487 mcc->AdvanceByMillis(5); 488 mRootApzc->AdvanceAnimationsUntilEnd(); 489 EXPECT_FALSE(mRootApzc->IsOverscrolled()); 490 491 check.Call("Done"); 492 } 493 #endif 494 495 TEST_F(APZCTransformNotificationTester, ScrollableTouchStateChange) { 496 // Create a scroll frame with available space for a scroll. 497 SetupBasicTest(); 498 499 MockFunction<void(std::string checkPointName)> check; 500 { 501 EXPECT_CALL(check, Call("Start")); 502 // We receive a touch-start with the flag indicating that the 503 // touch-start occurred over a scrollable element. 504 EXPECT_CALL( 505 *mcc, NotifyAPZStateChange( 506 _, GeckoContentController::APZStateChange::eStartTouch, 1, _)) 507 .Times(1); 508 509 EXPECT_CALL(*mcc, 510 NotifyAPZStateChange( 511 _, GeckoContentController::APZStateChange::eEndTouch, 1, _)) 512 .Times(1); 513 EXPECT_CALL(check, Call("Done")); 514 } 515 516 check.Call("Start"); 517 518 // Conduct a touch down and touch up in the scrollable element, 519 // and ensure the correct state change notifications are sent. 520 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 521 TouchDown(mRootApzc, ScreenIntPoint(10, 10), mcc->Time()); 522 mcc->AdvanceByMillis(5); 523 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 524 525 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 526 TouchUp(mRootApzc, ScreenIntPoint(10, 10), mcc->Time()); 527 mcc->AdvanceByMillis(5); 528 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 529 530 check.Call("Done"); 531 } 532 533 TEST_F(APZCTransformNotificationTester, NonScrollableTouchStateChange) { 534 // Create a non-scrollable frame with no space to scroll. 535 SetupNonScrollableTest(); 536 537 MockFunction<void(std::string checkPointName)> check; 538 { 539 EXPECT_CALL(check, Call("Start")); 540 // We receive a touch-start with the flag indicating that the 541 // touch-start occurred over a non-scrollable element. 542 EXPECT_CALL( 543 *mcc, NotifyAPZStateChange( 544 _, GeckoContentController::APZStateChange::eStartTouch, 0, _)) 545 .Times(1); 546 547 EXPECT_CALL(*mcc, 548 NotifyAPZStateChange( 549 _, GeckoContentController::APZStateChange::eEndTouch, 1, _)) 550 .Times(1); 551 EXPECT_CALL(check, Call("Done")); 552 } 553 554 check.Call("Start"); 555 556 // Conduct a touch down and touch up in the non-scrollable element, 557 // and ensure the correct state change notifications are sent. 558 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 559 TouchDown(mRootApzc, ScreenIntPoint(10, 10), mcc->Time()); 560 mcc->AdvanceByMillis(5); 561 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 562 563 QueueMockHitResult(ScrollableLayerGuid::START_SCROLL_ID); 564 TouchUp(mRootApzc, ScreenIntPoint(10, 10), mcc->Time()); 565 mcc->AdvanceByMillis(5); 566 mRootApzc->AdvanceAnimations(mcc->GetSampleTime()); 567 568 check.Call("Done"); 569 }