| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2012 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 "cc/trees/layer_tree_host.h" | |
| 6 | |
| 7 #include "cc/animation/animation_curve.h" | |
| 8 #include "cc/animation/layer_animation_controller.h" | |
| 9 #include "cc/animation/scroll_offset_animation_curve.h" | |
| 10 #include "cc/animation/timing_function.h" | |
| 11 #include "cc/base/time_util.h" | |
| 12 #include "cc/layers/layer.h" | |
| 13 #include "cc/layers/layer_impl.h" | |
| 14 #include "cc/test/animation_test_common.h" | |
| 15 #include "cc/test/fake_content_layer.h" | |
| 16 #include "cc/test/fake_content_layer_client.h" | |
| 17 #include "cc/test/layer_tree_test.h" | |
| 18 #include "cc/trees/layer_tree_impl.h" | |
| 19 | |
| 20 namespace cc { | |
| 21 namespace { | |
| 22 | |
| 23 class LayerTreeHostAnimationTest : public LayerTreeTest { | |
| 24 public: | |
| 25 void SetupTree() override { | |
| 26 LayerTreeTest::SetupTree(); | |
| 27 layer_tree_host()->root_layer()->set_layer_animation_delegate(this); | |
| 28 } | |
| 29 }; | |
| 30 | |
| 31 // Makes sure that SetNeedsAnimate does not cause the CommitRequested() state to | |
| 32 // be set. | |
| 33 class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested | |
| 34 : public LayerTreeHostAnimationTest { | |
| 35 public: | |
| 36 LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested() | |
| 37 : num_commits_(0) {} | |
| 38 | |
| 39 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 40 | |
| 41 void BeginMainFrame(const BeginFrameArgs& args) override { | |
| 42 // We skip the first commit because its the commit that populates the | |
| 43 // impl thread with a tree. After the second commit, the test is done. | |
| 44 if (num_commits_ != 1) | |
| 45 return; | |
| 46 | |
| 47 layer_tree_host()->SetNeedsAnimate(); | |
| 48 // Right now, CommitRequested is going to be true, because during | |
| 49 // BeginFrame, we force CommitRequested to true to prevent requests from | |
| 50 // hitting the impl thread. But, when the next DidCommit happens, we should | |
| 51 // verify that CommitRequested has gone back to false. | |
| 52 } | |
| 53 | |
| 54 void DidCommit() override { | |
| 55 if (!num_commits_) { | |
| 56 EXPECT_FALSE(layer_tree_host()->CommitRequested()); | |
| 57 layer_tree_host()->SetNeedsAnimate(); | |
| 58 EXPECT_FALSE(layer_tree_host()->CommitRequested()); | |
| 59 } | |
| 60 | |
| 61 // Verifies that the SetNeedsAnimate we made in ::Animate did not | |
| 62 // trigger CommitRequested. | |
| 63 EXPECT_FALSE(layer_tree_host()->CommitRequested()); | |
| 64 EndTest(); | |
| 65 num_commits_++; | |
| 66 } | |
| 67 | |
| 68 void AfterTest() override {} | |
| 69 | |
| 70 private: | |
| 71 int num_commits_; | |
| 72 }; | |
| 73 | |
| 74 MULTI_THREAD_TEST_F( | |
| 75 LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested); | |
| 76 | |
| 77 // Trigger a frame with SetNeedsCommit. Then, inside the resulting animate | |
| 78 // callback, request another frame using SetNeedsAnimate. End the test when | |
| 79 // animate gets called yet-again, indicating that the proxy is correctly | |
| 80 // handling the case where SetNeedsAnimate() is called inside the BeginFrame | |
| 81 // flow. | |
| 82 class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback | |
| 83 : public LayerTreeHostAnimationTest { | |
| 84 public: | |
| 85 LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback() | |
| 86 : num_begin_frames_(0) {} | |
| 87 | |
| 88 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 89 | |
| 90 void BeginMainFrame(const BeginFrameArgs& args) override { | |
| 91 if (!num_begin_frames_) { | |
| 92 layer_tree_host()->SetNeedsAnimate(); | |
| 93 num_begin_frames_++; | |
| 94 return; | |
| 95 } | |
| 96 EndTest(); | |
| 97 } | |
| 98 | |
| 99 void AfterTest() override {} | |
| 100 | |
| 101 private: | |
| 102 int num_begin_frames_; | |
| 103 }; | |
| 104 | |
| 105 MULTI_THREAD_TEST_F( | |
| 106 LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback); | |
| 107 | |
| 108 // Add a layer animation and confirm that | |
| 109 // LayerTreeHostImpl::UpdateAnimationState does get called. | |
| 110 class LayerTreeHostAnimationTestAddAnimation | |
| 111 : public LayerTreeHostAnimationTest { | |
| 112 public: | |
| 113 LayerTreeHostAnimationTestAddAnimation() | |
| 114 : update_animation_state_was_called_(false) {} | |
| 115 | |
| 116 void BeginTest() override { | |
| 117 PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 118 } | |
| 119 | |
| 120 void UpdateAnimationState(LayerTreeHostImpl* host_impl, | |
| 121 bool has_unfinished_animation) override { | |
| 122 EXPECT_FALSE(has_unfinished_animation); | |
| 123 update_animation_state_was_called_ = true; | |
| 124 } | |
| 125 | |
| 126 void NotifyAnimationStarted(base::TimeTicks monotonic_time, | |
| 127 Animation::TargetProperty target_property, | |
| 128 int group) override { | |
| 129 EXPECT_LT(base::TimeTicks(), monotonic_time); | |
| 130 | |
| 131 LayerAnimationController* controller = | |
| 132 layer_tree_host()->root_layer()->layer_animation_controller(); | |
| 133 Animation* animation = controller->GetAnimation(Animation::OPACITY); | |
| 134 if (animation) | |
| 135 controller->RemoveAnimation(animation->id()); | |
| 136 | |
| 137 EndTest(); | |
| 138 } | |
| 139 | |
| 140 void AfterTest() override { EXPECT_TRUE(update_animation_state_was_called_); } | |
| 141 | |
| 142 private: | |
| 143 bool update_animation_state_was_called_; | |
| 144 }; | |
| 145 | |
| 146 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation); | |
| 147 | |
| 148 // Add a layer animation to a layer, but continually fail to draw. Confirm that | |
| 149 // after a while, we do eventually force a draw. | |
| 150 class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws | |
| 151 : public LayerTreeHostAnimationTest { | |
| 152 public: | |
| 153 LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws() | |
| 154 : started_animating_(false) {} | |
| 155 | |
| 156 void BeginTest() override { | |
| 157 PostAddAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 158 } | |
| 159 | |
| 160 void AnimateLayers(LayerTreeHostImpl* host_impl, | |
| 161 base::TimeTicks monotonic_time) override { | |
| 162 started_animating_ = true; | |
| 163 } | |
| 164 | |
| 165 void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override { | |
| 166 if (started_animating_) | |
| 167 EndTest(); | |
| 168 } | |
| 169 | |
| 170 DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl, | |
| 171 LayerTreeHostImpl::FrameData* frame, | |
| 172 DrawResult draw_result) override { | |
| 173 return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS; | |
| 174 } | |
| 175 | |
| 176 void AfterTest() override {} | |
| 177 | |
| 178 private: | |
| 179 bool started_animating_; | |
| 180 }; | |
| 181 | |
| 182 // Starvation can only be an issue with the MT compositor. | |
| 183 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws); | |
| 184 | |
| 185 // Ensures that animations eventually get deleted. | |
| 186 class LayerTreeHostAnimationTestAnimationsGetDeleted | |
| 187 : public LayerTreeHostAnimationTest { | |
| 188 public: | |
| 189 LayerTreeHostAnimationTestAnimationsGetDeleted() | |
| 190 : started_animating_(false) {} | |
| 191 | |
| 192 void BeginTest() override { | |
| 193 PostAddAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 194 } | |
| 195 | |
| 196 void AnimateLayers(LayerTreeHostImpl* host_impl, | |
| 197 base::TimeTicks monotonic_time) override { | |
| 198 bool have_animations = !host_impl->animation_registrar() | |
| 199 ->active_animation_controllers_for_testing() | |
| 200 .empty(); | |
| 201 if (!started_animating_ && have_animations) { | |
| 202 started_animating_ = true; | |
| 203 return; | |
| 204 } | |
| 205 | |
| 206 if (started_animating_ && !have_animations) | |
| 207 EndTest(); | |
| 208 } | |
| 209 | |
| 210 void NotifyAnimationFinished(base::TimeTicks monotonic_time, | |
| 211 Animation::TargetProperty target_property, | |
| 212 int group) override { | |
| 213 // Animations on the impl-side controller only get deleted during a commit, | |
| 214 // so we need to schedule a commit. | |
| 215 layer_tree_host()->SetNeedsCommit(); | |
| 216 } | |
| 217 | |
| 218 void AfterTest() override {} | |
| 219 | |
| 220 private: | |
| 221 bool started_animating_; | |
| 222 }; | |
| 223 | |
| 224 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationsGetDeleted); | |
| 225 | |
| 226 // Ensures that animations continue to be ticked when we are backgrounded. | |
| 227 class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded | |
| 228 : public LayerTreeHostAnimationTest { | |
| 229 public: | |
| 230 LayerTreeHostAnimationTestTickAnimationWhileBackgrounded() | |
| 231 : num_begin_frames_(0) {} | |
| 232 | |
| 233 void BeginTest() override { | |
| 234 PostAddLongAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 235 } | |
| 236 | |
| 237 // Use WillAnimateLayers to set visible false before the animation runs and | |
| 238 // causes a commit, so we block the second visible animate in single-thread | |
| 239 // mode. | |
| 240 void WillAnimateLayers(LayerTreeHostImpl* host_impl, | |
| 241 base::TimeTicks monotonic_time) override { | |
| 242 // Verify that the host can draw, it's just not visible. | |
| 243 EXPECT_TRUE(host_impl->CanDraw()); | |
| 244 if (num_begin_frames_ < 2) { | |
| 245 if (!num_begin_frames_) { | |
| 246 // We have a long animation running. It should continue to tick even | |
| 247 // if we are not visible. | |
| 248 PostSetVisibleToMainThread(false); | |
| 249 } | |
| 250 num_begin_frames_++; | |
| 251 return; | |
| 252 } | |
| 253 EndTest(); | |
| 254 } | |
| 255 | |
| 256 void AfterTest() override {} | |
| 257 | |
| 258 private: | |
| 259 int num_begin_frames_; | |
| 260 }; | |
| 261 | |
| 262 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 263 LayerTreeHostAnimationTestTickAnimationWhileBackgrounded); | |
| 264 | |
| 265 // Ensures that animation time remains monotonic when we switch from foreground | |
| 266 // to background ticking and back, even if we're skipping draws due to | |
| 267 // checkerboarding when in the foreground. | |
| 268 class LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic | |
| 269 : public LayerTreeHostAnimationTest { | |
| 270 public: | |
| 271 LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic() | |
| 272 : has_background_ticked_(false), num_foreground_animates_(0) {} | |
| 273 | |
| 274 void InitializeSettings(LayerTreeSettings* settings) override { | |
| 275 // Make sure that drawing many times doesn't cause a checkerboarded | |
| 276 // animation to start so we avoid flake in this test. | |
| 277 settings->timeout_and_draw_when_animation_checkerboards = false; | |
| 278 } | |
| 279 | |
| 280 void BeginTest() override { | |
| 281 PostAddLongAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 282 } | |
| 283 | |
| 284 void AnimateLayers(LayerTreeHostImpl* host_impl, | |
| 285 base::TimeTicks monotonic_time) override { | |
| 286 EXPECT_GE(monotonic_time, last_tick_time_); | |
| 287 last_tick_time_ = monotonic_time; | |
| 288 if (host_impl->visible()) { | |
| 289 num_foreground_animates_++; | |
| 290 if (num_foreground_animates_ > 1 && !has_background_ticked_) | |
| 291 PostSetVisibleToMainThread(false); | |
| 292 else if (has_background_ticked_) | |
| 293 EndTest(); | |
| 294 } else { | |
| 295 has_background_ticked_ = true; | |
| 296 PostSetVisibleToMainThread(true); | |
| 297 } | |
| 298 } | |
| 299 | |
| 300 DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl, | |
| 301 LayerTreeHostImpl::FrameData* frame, | |
| 302 DrawResult draw_result) override { | |
| 303 if (TestEnded()) | |
| 304 return draw_result; | |
| 305 return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS; | |
| 306 } | |
| 307 | |
| 308 void AfterTest() override {} | |
| 309 | |
| 310 private: | |
| 311 bool has_background_ticked_; | |
| 312 int num_foreground_animates_; | |
| 313 base::TimeTicks last_tick_time_; | |
| 314 }; | |
| 315 | |
| 316 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 317 LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic); | |
| 318 | |
| 319 // Ensures that animations do not tick when we are backgrounded and | |
| 320 // and we have an empty active tree. | |
| 321 class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree | |
| 322 : public LayerTreeHostAnimationTest { | |
| 323 protected: | |
| 324 LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree() | |
| 325 : active_tree_was_animated_(false) {} | |
| 326 | |
| 327 base::TimeDelta BackgroundAnimationInterval(LayerTreeHostImpl* host_impl) { | |
| 328 return base::TimeDelta::FromSecondsD( | |
| 329 1.0 / host_impl->settings().background_animation_rate); | |
| 330 } | |
| 331 | |
| 332 void BeginTest() override { | |
| 333 PostAddAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 334 } | |
| 335 | |
| 336 void NotifyAnimationFinished(base::TimeTicks monotonic_time, | |
| 337 Animation::TargetProperty target_property, | |
| 338 int group) override { | |
| 339 // Replace animated commits with an empty tree. | |
| 340 layer_tree_host()->SetRootLayer(make_scoped_refptr<Layer>(NULL)); | |
| 341 } | |
| 342 | |
| 343 void DidCommit() override { | |
| 344 // This alternates setting an empty tree and a non-empty tree with an | |
| 345 // animation. | |
| 346 switch (layer_tree_host()->source_frame_number()) { | |
| 347 case 1: | |
| 348 // Wait for NotifyAnimationFinished to commit an empty tree. | |
| 349 break; | |
| 350 case 2: | |
| 351 SetupTree(); | |
| 352 AddOpacityTransitionToLayer( | |
| 353 layer_tree_host()->root_layer(), 0.000001, 0, 0.5, true); | |
| 354 break; | |
| 355 case 3: | |
| 356 // Wait for NotifyAnimationFinished to commit an empty tree. | |
| 357 break; | |
| 358 case 4: | |
| 359 EndTest(); | |
| 360 break; | |
| 361 } | |
| 362 } | |
| 363 | |
| 364 void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override { | |
| 365 // At the start of every commit, block activations and make sure | |
| 366 // we are backgrounded. | |
| 367 if (host_impl->settings().impl_side_painting) | |
| 368 host_impl->BlockNotifyReadyToActivateForTesting(true); | |
| 369 PostSetVisibleToMainThread(false); | |
| 370 } | |
| 371 | |
| 372 void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override { | |
| 373 if (!host_impl->settings().impl_side_painting) { | |
| 374 // There are no activations to block if we're not impl-side-painting, | |
| 375 // so just advance the test immediately. | |
| 376 if (host_impl->active_tree()->source_frame_number() < 3) | |
| 377 UnblockActivations(host_impl); | |
| 378 return; | |
| 379 } | |
| 380 | |
| 381 // We block activation for several ticks to make sure that, even though | |
| 382 // there is a pending tree with animations, we still do not background | |
| 383 // tick if the active tree is empty. | |
| 384 if (host_impl->pending_tree()->source_frame_number() < 3) { | |
| 385 base::MessageLoopProxy::current()->PostDelayedTask( | |
| 386 FROM_HERE, | |
| 387 base::Bind( | |
| 388 &LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree:: | |
| 389 UnblockActivations, | |
| 390 base::Unretained(this), host_impl), | |
| 391 4 * BackgroundAnimationInterval(host_impl)); | |
| 392 } | |
| 393 } | |
| 394 | |
| 395 virtual void UnblockActivations(LayerTreeHostImpl* host_impl) { | |
| 396 if (host_impl->settings().impl_side_painting) | |
| 397 host_impl->BlockNotifyReadyToActivateForTesting(false); | |
| 398 } | |
| 399 | |
| 400 void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override { | |
| 401 active_tree_was_animated_ = false; | |
| 402 | |
| 403 // Verify that commits are actually alternating with empty / non-empty | |
| 404 // trees. | |
| 405 int frame_number = host_impl->active_tree()->source_frame_number(); | |
| 406 switch (frame_number) { | |
| 407 case 0: | |
| 408 case 2: | |
| 409 EXPECT_TRUE(host_impl->active_tree()->root_layer()) | |
| 410 << "frame: " << frame_number; | |
| 411 break; | |
| 412 case 1: | |
| 413 case 3: | |
| 414 EXPECT_FALSE(host_impl->active_tree()->root_layer()) | |
| 415 << "frame: " << frame_number; | |
| 416 break; | |
| 417 } | |
| 418 | |
| 419 if (host_impl->active_tree()->source_frame_number() < 3) { | |
| 420 // Initiate the next commit after a delay to give us a chance to | |
| 421 // background tick if the active tree isn't empty. | |
| 422 base::MessageLoopProxy::current()->PostDelayedTask( | |
| 423 FROM_HERE, | |
| 424 base::Bind( | |
| 425 &LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree:: | |
| 426 InitiateNextCommit, | |
| 427 base::Unretained(this), host_impl), | |
| 428 4 * BackgroundAnimationInterval(host_impl)); | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 void WillAnimateLayers(LayerTreeHostImpl* host_impl, | |
| 433 base::TimeTicks monotonic_time) override { | |
| 434 EXPECT_TRUE(host_impl->active_tree()->root_layer()); | |
| 435 active_tree_was_animated_ = true; | |
| 436 } | |
| 437 | |
| 438 void InitiateNextCommit(LayerTreeHostImpl* host_impl) { | |
| 439 // Verify that we actually animated when we should have. | |
| 440 bool has_active_tree = host_impl->active_tree()->root_layer(); | |
| 441 EXPECT_EQ(has_active_tree, active_tree_was_animated_); | |
| 442 | |
| 443 // The next commit is blocked until we become visible again. | |
| 444 PostSetVisibleToMainThread(true); | |
| 445 } | |
| 446 | |
| 447 void AfterTest() override {} | |
| 448 | |
| 449 bool active_tree_was_animated_; | |
| 450 }; | |
| 451 | |
| 452 SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F( | |
| 453 LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree); | |
| 454 | |
| 455 // Ensure that an animation's timing function is respected. | |
| 456 class LayerTreeHostAnimationTestAddAnimationWithTimingFunction | |
| 457 : public LayerTreeHostAnimationTest { | |
| 458 public: | |
| 459 LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {} | |
| 460 | |
| 461 void SetupTree() override { | |
| 462 LayerTreeHostAnimationTest::SetupTree(); | |
| 463 content_ = FakeContentLayer::Create(&client_); | |
| 464 content_->SetBounds(gfx::Size(4, 4)); | |
| 465 layer_tree_host()->root_layer()->AddChild(content_); | |
| 466 } | |
| 467 | |
| 468 void BeginTest() override { PostAddAnimationToMainThread(content_.get()); } | |
| 469 | |
| 470 void AnimateLayers(LayerTreeHostImpl* host_impl, | |
| 471 base::TimeTicks monotonic_time) override { | |
| 472 LayerAnimationController* controller_impl = | |
| 473 host_impl->active_tree()->root_layer()->children()[0]-> | |
| 474 layer_animation_controller(); | |
| 475 Animation* animation = controller_impl->GetAnimation(Animation::OPACITY); | |
| 476 if (!animation) | |
| 477 return; | |
| 478 | |
| 479 const FloatAnimationCurve* curve = | |
| 480 animation->curve()->ToFloatAnimationCurve(); | |
| 481 float start_opacity = curve->GetValue(base::TimeDelta()); | |
| 482 float end_opacity = curve->GetValue(curve->Duration()); | |
| 483 float linearly_interpolated_opacity = | |
| 484 0.25f * end_opacity + 0.75f * start_opacity; | |
| 485 base::TimeDelta time = TimeUtil::Scale(curve->Duration(), 0.25f); | |
| 486 // If the linear timing function associated with this animation was not | |
| 487 // picked up, then the linearly interpolated opacity would be different | |
| 488 // because of the default ease timing function. | |
| 489 EXPECT_FLOAT_EQ(linearly_interpolated_opacity, curve->GetValue(time)); | |
| 490 | |
| 491 EndTest(); | |
| 492 } | |
| 493 | |
| 494 void AfterTest() override {} | |
| 495 | |
| 496 FakeContentLayerClient client_; | |
| 497 scoped_refptr<FakeContentLayer> content_; | |
| 498 }; | |
| 499 | |
| 500 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 501 LayerTreeHostAnimationTestAddAnimationWithTimingFunction); | |
| 502 | |
| 503 // Ensures that main thread animations have their start times synchronized with | |
| 504 // impl thread animations. | |
| 505 class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes | |
| 506 : public LayerTreeHostAnimationTest { | |
| 507 public: | |
| 508 LayerTreeHostAnimationTestSynchronizeAnimationStartTimes() {} | |
| 509 | |
| 510 void SetupTree() override { | |
| 511 LayerTreeHostAnimationTest::SetupTree(); | |
| 512 content_ = FakeContentLayer::Create(&client_); | |
| 513 content_->SetBounds(gfx::Size(4, 4)); | |
| 514 content_->set_layer_animation_delegate(this); | |
| 515 layer_tree_host()->root_layer()->AddChild(content_); | |
| 516 } | |
| 517 | |
| 518 void BeginTest() override { PostAddAnimationToMainThread(content_.get()); } | |
| 519 | |
| 520 void NotifyAnimationStarted(base::TimeTicks monotonic_time, | |
| 521 Animation::TargetProperty target_property, | |
| 522 int group) override { | |
| 523 LayerAnimationController* controller = | |
| 524 layer_tree_host()->root_layer()->children()[0]-> | |
| 525 layer_animation_controller(); | |
| 526 Animation* animation = controller->GetAnimation(Animation::OPACITY); | |
| 527 main_start_time_ = animation->start_time(); | |
| 528 controller->RemoveAnimation(animation->id()); | |
| 529 EndTest(); | |
| 530 } | |
| 531 | |
| 532 void UpdateAnimationState(LayerTreeHostImpl* impl_host, | |
| 533 bool has_unfinished_animation) override { | |
| 534 LayerAnimationController* controller = | |
| 535 impl_host->active_tree()->root_layer()->children()[0]-> | |
| 536 layer_animation_controller(); | |
| 537 Animation* animation = controller->GetAnimation(Animation::OPACITY); | |
| 538 if (!animation) | |
| 539 return; | |
| 540 | |
| 541 impl_start_time_ = animation->start_time(); | |
| 542 } | |
| 543 | |
| 544 void AfterTest() override { | |
| 545 EXPECT_EQ(impl_start_time_, main_start_time_); | |
| 546 EXPECT_LT(base::TimeTicks(), impl_start_time_); | |
| 547 } | |
| 548 | |
| 549 private: | |
| 550 base::TimeTicks main_start_time_; | |
| 551 base::TimeTicks impl_start_time_; | |
| 552 FakeContentLayerClient client_; | |
| 553 scoped_refptr<FakeContentLayer> content_; | |
| 554 }; | |
| 555 | |
| 556 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 557 LayerTreeHostAnimationTestSynchronizeAnimationStartTimes); | |
| 558 | |
| 559 // Ensures that notify animation finished is called. | |
| 560 class LayerTreeHostAnimationTestAnimationFinishedEvents | |
| 561 : public LayerTreeHostAnimationTest { | |
| 562 public: | |
| 563 LayerTreeHostAnimationTestAnimationFinishedEvents() {} | |
| 564 | |
| 565 void BeginTest() override { | |
| 566 PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer()); | |
| 567 } | |
| 568 | |
| 569 void NotifyAnimationFinished(base::TimeTicks monotonic_time, | |
| 570 Animation::TargetProperty target_property, | |
| 571 int group) override { | |
| 572 LayerAnimationController* controller = | |
| 573 layer_tree_host()->root_layer()->layer_animation_controller(); | |
| 574 Animation* animation = controller->GetAnimation(Animation::OPACITY); | |
| 575 if (animation) | |
| 576 controller->RemoveAnimation(animation->id()); | |
| 577 EndTest(); | |
| 578 } | |
| 579 | |
| 580 void AfterTest() override {} | |
| 581 }; | |
| 582 | |
| 583 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 584 LayerTreeHostAnimationTestAnimationFinishedEvents); | |
| 585 | |
| 586 // Ensures that when opacity is being animated, this value does not cause the | |
| 587 // subtree to be skipped. | |
| 588 class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity | |
| 589 : public LayerTreeHostAnimationTest { | |
| 590 public: | |
| 591 LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity() | |
| 592 : update_check_layer_(FakeContentLayer::Create(&client_)) { | |
| 593 } | |
| 594 | |
| 595 void SetupTree() override { | |
| 596 update_check_layer_->SetOpacity(0.f); | |
| 597 layer_tree_host()->SetRootLayer(update_check_layer_); | |
| 598 LayerTreeHostAnimationTest::SetupTree(); | |
| 599 } | |
| 600 | |
| 601 void BeginTest() override { | |
| 602 PostAddAnimationToMainThread(update_check_layer_.get()); | |
| 603 } | |
| 604 | |
| 605 void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override { | |
| 606 LayerAnimationController* controller_impl = | |
| 607 host_impl->active_tree()->root_layer()->layer_animation_controller(); | |
| 608 Animation* animation_impl = | |
| 609 controller_impl->GetAnimation(Animation::OPACITY); | |
| 610 controller_impl->RemoveAnimation(animation_impl->id()); | |
| 611 EndTest(); | |
| 612 } | |
| 613 | |
| 614 void AfterTest() override { | |
| 615 // Update() should have been called once, proving that the layer was not | |
| 616 // skipped. | |
| 617 EXPECT_EQ(1u, update_check_layer_->update_count()); | |
| 618 | |
| 619 // clear update_check_layer_ so LayerTreeHost dies. | |
| 620 update_check_layer_ = NULL; | |
| 621 } | |
| 622 | |
| 623 private: | |
| 624 FakeContentLayerClient client_; | |
| 625 scoped_refptr<FakeContentLayer> update_check_layer_; | |
| 626 }; | |
| 627 | |
| 628 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 629 LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity); | |
| 630 | |
| 631 // Layers added to tree with existing active animations should have the | |
| 632 // animation correctly recognized. | |
| 633 class LayerTreeHostAnimationTestLayerAddedWithAnimation | |
| 634 : public LayerTreeHostAnimationTest { | |
| 635 public: | |
| 636 LayerTreeHostAnimationTestLayerAddedWithAnimation() {} | |
| 637 | |
| 638 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 639 | |
| 640 void DidCommit() override { | |
| 641 if (layer_tree_host()->source_frame_number() == 1) { | |
| 642 scoped_refptr<Layer> layer = Layer::Create(); | |
| 643 layer->set_layer_animation_delegate(this); | |
| 644 | |
| 645 // Any valid AnimationCurve will do here. | |
| 646 scoped_ptr<AnimationCurve> curve(new FakeFloatAnimationCurve()); | |
| 647 scoped_ptr<Animation> animation( | |
| 648 Animation::Create(curve.Pass(), 1, 1, Animation::OPACITY)); | |
| 649 layer->layer_animation_controller()->AddAnimation(animation.Pass()); | |
| 650 | |
| 651 // We add the animation *before* attaching the layer to the tree. | |
| 652 layer_tree_host()->root_layer()->AddChild(layer); | |
| 653 } | |
| 654 } | |
| 655 | |
| 656 void AnimateLayers(LayerTreeHostImpl* impl_host, | |
| 657 base::TimeTicks monotonic_time) override { | |
| 658 EndTest(); | |
| 659 } | |
| 660 | |
| 661 void AfterTest() override {} | |
| 662 }; | |
| 663 | |
| 664 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 665 LayerTreeHostAnimationTestLayerAddedWithAnimation); | |
| 666 | |
| 667 class LayerTreeHostAnimationTestCancelAnimateCommit | |
| 668 : public LayerTreeHostAnimationTest { | |
| 669 public: | |
| 670 LayerTreeHostAnimationTestCancelAnimateCommit() | |
| 671 : num_begin_frames_(0), num_commit_calls_(0), num_draw_calls_(0) {} | |
| 672 | |
| 673 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 674 | |
| 675 void BeginMainFrame(const BeginFrameArgs& args) override { | |
| 676 num_begin_frames_++; | |
| 677 // No-op animate will cancel the commit. | |
| 678 if (layer_tree_host()->source_frame_number() == 1) { | |
| 679 EndTest(); | |
| 680 return; | |
| 681 } | |
| 682 layer_tree_host()->SetNeedsAnimate(); | |
| 683 } | |
| 684 | |
| 685 void CommitCompleteOnThread(LayerTreeHostImpl* impl) override { | |
| 686 num_commit_calls_++; | |
| 687 if (impl->active_tree()->source_frame_number() > 1) | |
| 688 FAIL() << "Commit should have been canceled."; | |
| 689 } | |
| 690 | |
| 691 void DrawLayersOnThread(LayerTreeHostImpl* impl) override { | |
| 692 num_draw_calls_++; | |
| 693 if (impl->active_tree()->source_frame_number() > 1) | |
| 694 FAIL() << "Draw should have been canceled."; | |
| 695 } | |
| 696 | |
| 697 void AfterTest() override { | |
| 698 EXPECT_EQ(2, num_begin_frames_); | |
| 699 EXPECT_EQ(1, num_commit_calls_); | |
| 700 EXPECT_EQ(1, num_draw_calls_); | |
| 701 } | |
| 702 | |
| 703 private: | |
| 704 int num_begin_frames_; | |
| 705 int num_commit_calls_; | |
| 706 int num_draw_calls_; | |
| 707 FakeContentLayerClient client_; | |
| 708 scoped_refptr<FakeContentLayer> content_; | |
| 709 }; | |
| 710 | |
| 711 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCancelAnimateCommit); | |
| 712 | |
| 713 class LayerTreeHostAnimationTestForceRedraw | |
| 714 : public LayerTreeHostAnimationTest { | |
| 715 public: | |
| 716 LayerTreeHostAnimationTestForceRedraw() | |
| 717 : num_animate_(0), num_draw_layers_(0) {} | |
| 718 | |
| 719 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 720 | |
| 721 void BeginMainFrame(const BeginFrameArgs& args) override { | |
| 722 if (++num_animate_ < 2) | |
| 723 layer_tree_host()->SetNeedsAnimate(); | |
| 724 } | |
| 725 | |
| 726 void Layout() override { layer_tree_host()->SetNextCommitForcesRedraw(); } | |
| 727 | |
| 728 void DrawLayersOnThread(LayerTreeHostImpl* impl) override { | |
| 729 if (++num_draw_layers_ == 2) | |
| 730 EndTest(); | |
| 731 } | |
| 732 | |
| 733 void AfterTest() override { | |
| 734 // The first commit will always draw; make sure the second draw triggered | |
| 735 // by the animation was not cancelled. | |
| 736 EXPECT_EQ(2, num_draw_layers_); | |
| 737 EXPECT_EQ(2, num_animate_); | |
| 738 } | |
| 739 | |
| 740 private: | |
| 741 int num_animate_; | |
| 742 int num_draw_layers_; | |
| 743 }; | |
| 744 | |
| 745 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestForceRedraw); | |
| 746 | |
| 747 class LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit | |
| 748 : public LayerTreeHostAnimationTest { | |
| 749 public: | |
| 750 LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit() | |
| 751 : num_animate_(0), num_draw_layers_(0) {} | |
| 752 | |
| 753 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 754 | |
| 755 void BeginMainFrame(const BeginFrameArgs& args) override { | |
| 756 if (++num_animate_ <= 2) { | |
| 757 layer_tree_host()->SetNeedsCommit(); | |
| 758 layer_tree_host()->SetNeedsAnimate(); | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 void DrawLayersOnThread(LayerTreeHostImpl* impl) override { | |
| 763 if (++num_draw_layers_ == 2) | |
| 764 EndTest(); | |
| 765 } | |
| 766 | |
| 767 void AfterTest() override { | |
| 768 // The first commit will always draw; make sure the second draw triggered | |
| 769 // by the SetNeedsCommit was not cancelled. | |
| 770 EXPECT_EQ(2, num_draw_layers_); | |
| 771 EXPECT_GE(num_animate_, 2); | |
| 772 } | |
| 773 | |
| 774 private: | |
| 775 int num_animate_; | |
| 776 int num_draw_layers_; | |
| 777 }; | |
| 778 | |
| 779 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit); | |
| 780 | |
| 781 // Make sure the main thread can still execute animations when CanDraw() is not | |
| 782 // true. | |
| 783 class LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw | |
| 784 : public LayerTreeHostAnimationTest { | |
| 785 public: | |
| 786 LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw() : started_times_(0) {} | |
| 787 | |
| 788 void SetupTree() override { | |
| 789 LayerTreeHostAnimationTest::SetupTree(); | |
| 790 content_ = FakeContentLayer::Create(&client_); | |
| 791 content_->SetBounds(gfx::Size(4, 4)); | |
| 792 content_->set_layer_animation_delegate(this); | |
| 793 layer_tree_host()->root_layer()->AddChild(content_); | |
| 794 } | |
| 795 | |
| 796 void BeginTest() override { | |
| 797 layer_tree_host()->SetViewportSize(gfx::Size()); | |
| 798 PostAddAnimationToMainThread(content_.get()); | |
| 799 } | |
| 800 | |
| 801 void NotifyAnimationStarted(base::TimeTicks monotonic_time, | |
| 802 Animation::TargetProperty target_property, | |
| 803 int group) override { | |
| 804 started_times_++; | |
| 805 } | |
| 806 | |
| 807 void NotifyAnimationFinished(base::TimeTicks monotonic_time, | |
| 808 Animation::TargetProperty target_property, | |
| 809 int group) override { | |
| 810 EndTest(); | |
| 811 } | |
| 812 | |
| 813 void AfterTest() override { EXPECT_EQ(1, started_times_); } | |
| 814 | |
| 815 private: | |
| 816 int started_times_; | |
| 817 FakeContentLayerClient client_; | |
| 818 scoped_refptr<FakeContentLayer> content_; | |
| 819 }; | |
| 820 | |
| 821 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 822 LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw); | |
| 823 | |
| 824 // Make sure the main thread can still execute animations when the renderer is | |
| 825 // backgrounded. | |
| 826 class LayerTreeHostAnimationTestRunAnimationWhenNotVisible | |
| 827 : public LayerTreeHostAnimationTest { | |
| 828 public: | |
| 829 LayerTreeHostAnimationTestRunAnimationWhenNotVisible() : started_times_(0) {} | |
| 830 | |
| 831 void SetupTree() override { | |
| 832 LayerTreeHostAnimationTest::SetupTree(); | |
| 833 content_ = FakeContentLayer::Create(&client_); | |
| 834 content_->SetBounds(gfx::Size(4, 4)); | |
| 835 content_->set_layer_animation_delegate(this); | |
| 836 layer_tree_host()->root_layer()->AddChild(content_); | |
| 837 } | |
| 838 | |
| 839 void BeginTest() override { | |
| 840 visible_ = true; | |
| 841 PostAddAnimationToMainThread(content_.get()); | |
| 842 } | |
| 843 | |
| 844 void DidCommit() override { | |
| 845 visible_ = false; | |
| 846 layer_tree_host()->SetVisible(false); | |
| 847 } | |
| 848 | |
| 849 void NotifyAnimationStarted(base::TimeTicks monotonic_time, | |
| 850 Animation::TargetProperty target_property, | |
| 851 int group) override { | |
| 852 EXPECT_FALSE(visible_); | |
| 853 started_times_++; | |
| 854 } | |
| 855 | |
| 856 void NotifyAnimationFinished(base::TimeTicks monotonic_time, | |
| 857 Animation::TargetProperty target_property, | |
| 858 int group) override { | |
| 859 EXPECT_FALSE(visible_); | |
| 860 EXPECT_EQ(1, started_times_); | |
| 861 EndTest(); | |
| 862 } | |
| 863 | |
| 864 void AfterTest() override {} | |
| 865 | |
| 866 private: | |
| 867 bool visible_; | |
| 868 int started_times_; | |
| 869 FakeContentLayerClient client_; | |
| 870 scoped_refptr<FakeContentLayer> content_; | |
| 871 }; | |
| 872 | |
| 873 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 874 LayerTreeHostAnimationTestRunAnimationWhenNotVisible); | |
| 875 | |
| 876 // Animations should not be started when frames are being skipped due to | |
| 877 // checkerboard. | |
| 878 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations | |
| 879 : public LayerTreeHostAnimationTest { | |
| 880 void SetupTree() override { | |
| 881 LayerTreeHostAnimationTest::SetupTree(); | |
| 882 content_ = FakeContentLayer::Create(&client_); | |
| 883 content_->SetBounds(gfx::Size(4, 4)); | |
| 884 content_->set_layer_animation_delegate(this); | |
| 885 layer_tree_host()->root_layer()->AddChild(content_); | |
| 886 } | |
| 887 | |
| 888 void InitializeSettings(LayerTreeSettings* settings) override { | |
| 889 // Make sure that drawing many times doesn't cause a checkerboarded | |
| 890 // animation to start so we avoid flake in this test. | |
| 891 settings->timeout_and_draw_when_animation_checkerboards = false; | |
| 892 } | |
| 893 | |
| 894 void BeginTest() override { | |
| 895 prevented_draw_ = 0; | |
| 896 added_animations_ = 0; | |
| 897 started_times_ = 0; | |
| 898 | |
| 899 PostSetNeedsCommitToMainThread(); | |
| 900 } | |
| 901 | |
| 902 DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl, | |
| 903 LayerTreeHostImpl::FrameData* frame_data, | |
| 904 DrawResult draw_result) override { | |
| 905 if (added_animations_ < 2) | |
| 906 return draw_result; | |
| 907 if (TestEnded()) | |
| 908 return draw_result; | |
| 909 // Act like there is checkerboard when the second animation wants to draw. | |
| 910 ++prevented_draw_; | |
| 911 if (prevented_draw_ > 2) | |
| 912 EndTest(); | |
| 913 return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS; | |
| 914 } | |
| 915 | |
| 916 void DidCommitAndDrawFrame() override { | |
| 917 switch (layer_tree_host()->source_frame_number()) { | |
| 918 case 1: | |
| 919 // The animation is longer than 1 BeginFrame interval. | |
| 920 AddOpacityTransitionToLayer(content_.get(), 0.1, 0.2f, 0.8f, false); | |
| 921 added_animations_++; | |
| 922 break; | |
| 923 case 2: | |
| 924 // This second animation will not be drawn so it should not start. | |
| 925 AddAnimatedTransformToLayer(content_.get(), 0.1, 5, 5); | |
| 926 added_animations_++; | |
| 927 break; | |
| 928 } | |
| 929 } | |
| 930 | |
| 931 void NotifyAnimationStarted(base::TimeTicks monotonic_time, | |
| 932 Animation::TargetProperty target_property, | |
| 933 int group) override { | |
| 934 if (TestEnded()) | |
| 935 return; | |
| 936 started_times_++; | |
| 937 } | |
| 938 | |
| 939 void AfterTest() override { | |
| 940 // Make sure we tried to draw the second animation but failed. | |
| 941 EXPECT_LT(0, prevented_draw_); | |
| 942 // The first animation should be started, but the second should not because | |
| 943 // of checkerboard. | |
| 944 EXPECT_EQ(1, started_times_); | |
| 945 } | |
| 946 | |
| 947 int prevented_draw_; | |
| 948 int added_animations_; | |
| 949 int started_times_; | |
| 950 FakeContentLayerClient client_; | |
| 951 scoped_refptr<FakeContentLayer> content_; | |
| 952 }; | |
| 953 | |
| 954 MULTI_THREAD_TEST_F( | |
| 955 LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations); | |
| 956 | |
| 957 // Verifies that scroll offset animations are only accepted when impl-scrolling | |
| 958 // is supported, and that when scroll offset animations are accepted, | |
| 959 // scroll offset updates are sent back to the main thread. | |
| 960 class LayerTreeHostAnimationTestScrollOffsetChangesArePropagated | |
| 961 : public LayerTreeHostAnimationTest { | |
| 962 public: | |
| 963 LayerTreeHostAnimationTestScrollOffsetChangesArePropagated() {} | |
| 964 | |
| 965 void SetupTree() override { | |
| 966 LayerTreeHostAnimationTest::SetupTree(); | |
| 967 | |
| 968 scroll_layer_ = FakeContentLayer::Create(&client_); | |
| 969 scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id()); | |
| 970 scroll_layer_->SetBounds(gfx::Size(1000, 1000)); | |
| 971 scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20)); | |
| 972 layer_tree_host()->root_layer()->AddChild(scroll_layer_); | |
| 973 } | |
| 974 | |
| 975 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 976 | |
| 977 void DidCommit() override { | |
| 978 switch (layer_tree_host()->source_frame_number()) { | |
| 979 case 1: { | |
| 980 scoped_ptr<ScrollOffsetAnimationCurve> curve( | |
| 981 ScrollOffsetAnimationCurve::Create( | |
| 982 gfx::ScrollOffset(500.f, 550.f), | |
| 983 EaseInOutTimingFunction::Create())); | |
| 984 scoped_ptr<Animation> animation( | |
| 985 Animation::Create(curve.Pass(), 1, 0, Animation::SCROLL_OFFSET)); | |
| 986 animation->set_needs_synchronized_start_time(true); | |
| 987 bool animation_added = scroll_layer_->AddAnimation(animation.Pass()); | |
| 988 bool impl_scrolling_supported = | |
| 989 layer_tree_host()->proxy()->SupportsImplScrolling(); | |
| 990 EXPECT_EQ(impl_scrolling_supported, animation_added); | |
| 991 if (!impl_scrolling_supported) | |
| 992 EndTest(); | |
| 993 break; | |
| 994 } | |
| 995 default: | |
| 996 if (scroll_layer_->scroll_offset().x() > 10 && | |
| 997 scroll_layer_->scroll_offset().y() > 20) | |
| 998 EndTest(); | |
| 999 } | |
| 1000 } | |
| 1001 | |
| 1002 void AfterTest() override {} | |
| 1003 | |
| 1004 private: | |
| 1005 FakeContentLayerClient client_; | |
| 1006 scoped_refptr<FakeContentLayer> scroll_layer_; | |
| 1007 }; | |
| 1008 | |
| 1009 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 1010 LayerTreeHostAnimationTestScrollOffsetChangesArePropagated); | |
| 1011 | |
| 1012 // Verifies that when the main thread removes a scroll animation and sets a new | |
| 1013 // scroll position, the active tree takes on exactly this new scroll position | |
| 1014 // after activation, and the main thread doesn't receive a spurious scroll | |
| 1015 // delta. | |
| 1016 class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval | |
| 1017 : public LayerTreeHostAnimationTest { | |
| 1018 public: | |
| 1019 LayerTreeHostAnimationTestScrollOffsetAnimationRemoval() | |
| 1020 : final_postion_(50.0, 100.0) {} | |
| 1021 | |
| 1022 void SetupTree() override { | |
| 1023 LayerTreeHostAnimationTest::SetupTree(); | |
| 1024 | |
| 1025 scroll_layer_ = FakeContentLayer::Create(&client_); | |
| 1026 scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id()); | |
| 1027 scroll_layer_->SetBounds(gfx::Size(10000, 10000)); | |
| 1028 scroll_layer_->SetScrollOffset(gfx::ScrollOffset(100.0, 200.0)); | |
| 1029 layer_tree_host()->root_layer()->AddChild(scroll_layer_); | |
| 1030 | |
| 1031 scoped_ptr<ScrollOffsetAnimationCurve> curve( | |
| 1032 ScrollOffsetAnimationCurve::Create(gfx::ScrollOffset(6500.f, 7500.f), | |
| 1033 EaseInOutTimingFunction::Create())); | |
| 1034 scoped_ptr<Animation> animation( | |
| 1035 Animation::Create(curve.Pass(), 1, 0, Animation::SCROLL_OFFSET)); | |
| 1036 animation->set_needs_synchronized_start_time(true); | |
| 1037 scroll_layer_->AddAnimation(animation.Pass()); | |
| 1038 } | |
| 1039 | |
| 1040 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 1041 | |
| 1042 void BeginMainFrame(const BeginFrameArgs& args) override { | |
| 1043 switch (layer_tree_host()->source_frame_number()) { | |
| 1044 case 0: | |
| 1045 break; | |
| 1046 case 1: { | |
| 1047 Animation* animation = | |
| 1048 scroll_layer_->layer_animation_controller()->GetAnimation( | |
| 1049 Animation::SCROLL_OFFSET); | |
| 1050 scroll_layer_->layer_animation_controller()->RemoveAnimation( | |
| 1051 animation->id()); | |
| 1052 scroll_layer_->SetScrollOffset(final_postion_); | |
| 1053 break; | |
| 1054 } | |
| 1055 default: | |
| 1056 EXPECT_EQ(final_postion_, scroll_layer_->scroll_offset()); | |
| 1057 } | |
| 1058 } | |
| 1059 | |
| 1060 void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override { | |
| 1061 if (host_impl->settings().impl_side_painting) | |
| 1062 host_impl->BlockNotifyReadyToActivateForTesting(true); | |
| 1063 } | |
| 1064 | |
| 1065 void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl, | |
| 1066 const BeginFrameArgs& args) override { | |
| 1067 if (!host_impl->pending_tree()) | |
| 1068 return; | |
| 1069 | |
| 1070 if (!host_impl->active_tree()->root_layer()) { | |
| 1071 host_impl->BlockNotifyReadyToActivateForTesting(false); | |
| 1072 return; | |
| 1073 } | |
| 1074 | |
| 1075 LayerImpl* scroll_layer_impl = | |
| 1076 host_impl->active_tree()->root_layer()->children()[0]; | |
| 1077 Animation* animation = | |
| 1078 scroll_layer_impl->layer_animation_controller()->GetAnimation( | |
| 1079 Animation::SCROLL_OFFSET); | |
| 1080 | |
| 1081 if (!animation || animation->run_state() != Animation::RUNNING) { | |
| 1082 host_impl->BlockNotifyReadyToActivateForTesting(false); | |
| 1083 return; | |
| 1084 } | |
| 1085 | |
| 1086 // Block activation until the running animation has a chance to produce a | |
| 1087 // scroll delta. | |
| 1088 gfx::Vector2dF scroll_delta = scroll_layer_impl->ScrollDelta(); | |
| 1089 if (scroll_delta.x() < 1.f || scroll_delta.y() < 1.f) | |
| 1090 return; | |
| 1091 | |
| 1092 host_impl->BlockNotifyReadyToActivateForTesting(false); | |
| 1093 } | |
| 1094 | |
| 1095 void WillActivateTreeOnThread(LayerTreeHostImpl* host_impl) override { | |
| 1096 if (!host_impl->settings().impl_side_painting) | |
| 1097 return; | |
| 1098 if (host_impl->pending_tree()->source_frame_number() != 1) | |
| 1099 return; | |
| 1100 LayerImpl* scroll_layer_impl = | |
| 1101 host_impl->pending_tree()->root_layer()->children()[0]; | |
| 1102 EXPECT_EQ(final_postion_, scroll_layer_impl->CurrentScrollOffset()); | |
| 1103 } | |
| 1104 | |
| 1105 void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override { | |
| 1106 if (host_impl->active_tree()->source_frame_number() != 1) | |
| 1107 return; | |
| 1108 LayerImpl* scroll_layer_impl = | |
| 1109 host_impl->active_tree()->root_layer()->children()[0]; | |
| 1110 EXPECT_EQ(final_postion_, scroll_layer_impl->CurrentScrollOffset()); | |
| 1111 EndTest(); | |
| 1112 } | |
| 1113 | |
| 1114 void AfterTest() override { | |
| 1115 EXPECT_EQ(final_postion_, scroll_layer_->scroll_offset()); | |
| 1116 } | |
| 1117 | |
| 1118 private: | |
| 1119 FakeContentLayerClient client_; | |
| 1120 scoped_refptr<FakeContentLayer> scroll_layer_; | |
| 1121 const gfx::ScrollOffset final_postion_; | |
| 1122 }; | |
| 1123 | |
| 1124 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestScrollOffsetAnimationRemoval); | |
| 1125 | |
| 1126 // When animations are simultaneously added to an existing layer and to a new | |
| 1127 // layer, they should start at the same time, even when there's already a | |
| 1128 // running animation on the existing layer. | |
| 1129 class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers | |
| 1130 : public LayerTreeHostAnimationTest { | |
| 1131 public: | |
| 1132 LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers() | |
| 1133 : frame_count_with_pending_tree_(0) {} | |
| 1134 | |
| 1135 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 1136 | |
| 1137 void DidCommit() override { | |
| 1138 if (layer_tree_host()->source_frame_number() == 1) { | |
| 1139 AddAnimatedTransformToLayer(layer_tree_host()->root_layer(), 4, 1, 1); | |
| 1140 } else if (layer_tree_host()->source_frame_number() == 2) { | |
| 1141 AddOpacityTransitionToLayer( | |
| 1142 layer_tree_host()->root_layer(), 1, 0.f, 0.5f, true); | |
| 1143 | |
| 1144 scoped_refptr<Layer> layer = Layer::Create(); | |
| 1145 layer_tree_host()->root_layer()->AddChild(layer); | |
| 1146 layer->set_layer_animation_delegate(this); | |
| 1147 layer->SetBounds(gfx::Size(4, 4)); | |
| 1148 AddOpacityTransitionToLayer(layer.get(), 1, 0.f, 0.5f, true); | |
| 1149 } | |
| 1150 } | |
| 1151 | |
| 1152 void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override { | |
| 1153 if (host_impl->settings().impl_side_painting) | |
| 1154 host_impl->BlockNotifyReadyToActivateForTesting(true); | |
| 1155 } | |
| 1156 | |
| 1157 void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override { | |
| 1158 // For the commit that added animations to new and existing layers, keep | |
| 1159 // blocking activation. We want to verify that even with activation blocked, | |
| 1160 // the animation on the layer that's already in the active tree won't get a | |
| 1161 // head start. | |
| 1162 if (host_impl->settings().impl_side_painting && | |
| 1163 host_impl->pending_tree()->source_frame_number() != 2) { | |
| 1164 host_impl->BlockNotifyReadyToActivateForTesting(false); | |
| 1165 } | |
| 1166 } | |
| 1167 | |
| 1168 void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl, | |
| 1169 const BeginFrameArgs& args) override { | |
| 1170 if (!host_impl->pending_tree() || | |
| 1171 host_impl->pending_tree()->source_frame_number() != 2) | |
| 1172 return; | |
| 1173 | |
| 1174 frame_count_with_pending_tree_++; | |
| 1175 if (frame_count_with_pending_tree_ == 2 && | |
| 1176 host_impl->settings().impl_side_painting) { | |
| 1177 host_impl->BlockNotifyReadyToActivateForTesting(false); | |
| 1178 } | |
| 1179 } | |
| 1180 | |
| 1181 void UpdateAnimationState(LayerTreeHostImpl* host_impl, | |
| 1182 bool has_unfinished_animation) override { | |
| 1183 LayerAnimationController* root_controller_impl = | |
| 1184 host_impl->active_tree()->root_layer()->layer_animation_controller(); | |
| 1185 Animation* root_animation = | |
| 1186 root_controller_impl->GetAnimation(Animation::OPACITY); | |
| 1187 if (!root_animation || root_animation->run_state() != Animation::RUNNING) | |
| 1188 return; | |
| 1189 | |
| 1190 LayerAnimationController* child_controller_impl = | |
| 1191 host_impl->active_tree()->root_layer()->children() | |
| 1192 [0]->layer_animation_controller(); | |
| 1193 Animation* child_animation = | |
| 1194 child_controller_impl->GetAnimation(Animation::OPACITY); | |
| 1195 EXPECT_EQ(Animation::RUNNING, child_animation->run_state()); | |
| 1196 EXPECT_EQ(root_animation->start_time(), child_animation->start_time()); | |
| 1197 root_controller_impl->AbortAnimations(Animation::OPACITY); | |
| 1198 root_controller_impl->AbortAnimations(Animation::TRANSFORM); | |
| 1199 child_controller_impl->AbortAnimations(Animation::OPACITY); | |
| 1200 EndTest(); | |
| 1201 } | |
| 1202 | |
| 1203 void AfterTest() override {} | |
| 1204 | |
| 1205 private: | |
| 1206 int frame_count_with_pending_tree_; | |
| 1207 }; | |
| 1208 | |
| 1209 SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F( | |
| 1210 LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers); | |
| 1211 | |
| 1212 class LayerTreeHostAnimationTestAddAnimationAfterAnimating | |
| 1213 : public LayerTreeHostAnimationTest { | |
| 1214 public: | |
| 1215 LayerTreeHostAnimationTestAddAnimationAfterAnimating() | |
| 1216 : num_swap_buffers_(0) {} | |
| 1217 | |
| 1218 void SetupTree() override { | |
| 1219 LayerTreeHostAnimationTest::SetupTree(); | |
| 1220 content_ = Layer::Create(); | |
| 1221 content_->SetBounds(gfx::Size(4, 4)); | |
| 1222 layer_tree_host()->root_layer()->AddChild(content_); | |
| 1223 } | |
| 1224 | |
| 1225 void BeginTest() override { PostSetNeedsCommitToMainThread(); } | |
| 1226 | |
| 1227 void DidCommit() override { | |
| 1228 switch (layer_tree_host()->source_frame_number()) { | |
| 1229 case 1: | |
| 1230 // First frame: add an animation to the root layer. | |
| 1231 AddAnimatedTransformToLayer(layer_tree_host()->root_layer(), 0.1, 5, 5); | |
| 1232 break; | |
| 1233 case 2: | |
| 1234 // Second frame: add an animation to the content layer. The root layer | |
| 1235 // animation has caused us to animate already during this frame. | |
| 1236 AddOpacityTransitionToLayer(content_.get(), 0.1, 5, 5, false); | |
| 1237 break; | |
| 1238 } | |
| 1239 } | |
| 1240 | |
| 1241 void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override { | |
| 1242 // After both animations have started, verify that they have valid | |
| 1243 // start times. | |
| 1244 num_swap_buffers_++; | |
| 1245 AnimationRegistrar::AnimationControllerMap controllers_copy = | |
| 1246 host_impl->animation_registrar() | |
| 1247 ->active_animation_controllers_for_testing(); | |
| 1248 if (controllers_copy.size() == 2u) { | |
| 1249 EndTest(); | |
| 1250 EXPECT_GE(num_swap_buffers_, 3); | |
| 1251 for (auto& it : controllers_copy) { | |
| 1252 int id = it.first; | |
| 1253 if (id == host_impl->RootLayer()->id()) { | |
| 1254 Animation* anim = it.second->GetAnimation(Animation::TRANSFORM); | |
| 1255 EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0); | |
| 1256 } else if (id == host_impl->RootLayer()->children()[0]->id()) { | |
| 1257 Animation* anim = it.second->GetAnimation(Animation::OPACITY); | |
| 1258 EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0); | |
| 1259 } | |
| 1260 } | |
| 1261 } | |
| 1262 } | |
| 1263 | |
| 1264 void AfterTest() override {} | |
| 1265 | |
| 1266 private: | |
| 1267 scoped_refptr<Layer> content_; | |
| 1268 int num_swap_buffers_; | |
| 1269 }; | |
| 1270 | |
| 1271 SINGLE_AND_MULTI_THREAD_TEST_F( | |
| 1272 LayerTreeHostAnimationTestAddAnimationAfterAnimating); | |
| 1273 | |
| 1274 } // namespace | |
| 1275 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master