CC Animation: Erase old animation tests.

cc/trees/layer_tree_host_unittest_animation.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <stdint.h>
 
 #include "cc/animation/animation_curve.h"
+#include "cc/animation/animation_host.h"
+#include "cc/animation/animation_id_provider.h"
+#include "cc/animation/animation_player.h"
+#include "cc/animation/animation_timeline.h"
+#include "cc/animation/element_animations.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/completion_event.h"
 #include "cc/base/time_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostAnimationTest : public LayerTreeTest {
  public:
+  LayerTreeHostAnimationTest()
+      : timeline_id_(AnimationIdProvider::NextTimelineId()),
+        player_id_(AnimationIdProvider::NextPlayerId()),
+        player_child_id_(AnimationIdProvider::NextPlayerId()) {
+    timeline_ = AnimationTimeline::Create(timeline_id_);
+    player_ = AnimationPlayer::Create(player_id_);
+    player_child_ = AnimationPlayer::Create(player_child_id_);
+
+    player_->set_layer_animation_delegate(this);
+  }
+
   void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->use_compositor_animation_timelines = false;
+    settings->use_compositor_animation_timelines = true;
   }
 
   void InitializeLayerSettings(LayerSettings* layer_settings) override {
-    layer_settings->use_compositor_animation_timelines = false;
+    layer_settings->use_compositor_animation_timelines = true;
   }
 
-  void SetupTree() override {
-    LayerTreeTest::SetupTree();
-    layer_tree_host()->root_layer()->set_layer_animation_delegate(this);
+  void AttachPlayersToTimeline() {
+    layer_tree_host()->animation_host()->AddAnimationTimeline(timeline_.get());
+    timeline_->AttachPlayer(player_.get());
+    timeline_->AttachPlayer(player_child_.get());
   }
+
+ protected:
+  scoped_refptr<AnimationTimeline> timeline_;
+  scoped_refptr<AnimationPlayer> player_;
+  scoped_refptr<AnimationPlayer> player_child_;
+
+  const int timeline_id_;
+  const int player_id_;
+  const int player_child_id_;
 };
 
 // Makes sure that SetNeedsAnimate does not cause the CommitRequested() state to
 // be set.
 class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
       : num_commits_(0) {}
 
@@ skipping 68 matching lines @@
 
 // Add a layer animation and confirm that
 // LayerTreeHostImpl::UpdateAnimationState does get called.
 class LayerTreeHostAnimationTestAddAnimation
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
       : update_animation_state_was_called_(false) {}
 
   void BeginTest() override {
-    PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
+    AttachPlayersToTimeline();
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    PostAddInstantAnimationToMainThreadPlayer(player_.get());
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* host_impl,
                             bool has_unfinished_animation) override {
     EXPECT_FALSE(has_unfinished_animation);
     update_animation_state_was_called_ = true;
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
     EXPECT_LT(base::TimeTicks(), monotonic_time);
 
     LayerAnimationController* controller =
-        layer_tree_host()->root_layer()->layer_animation_controller();
+        player_->element_animations()->layer_animation_controller();
     Animation* animation = controller->GetAnimation(TargetProperty::OPACITY);
     if (animation)
-      controller->RemoveAnimation(animation->id());
+      player_->RemoveAnimation(animation->id());
 
     EndTest();
   }
 
   void AfterTest() override { EXPECT_TRUE(update_animation_state_was_called_); }
 
  private:
   bool update_animation_state_was_called_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation);
 
 // Add a layer animation to a layer, but continually fail to draw. Confirm that
 // after a while, we do eventually force a draw.
 class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
       : started_animating_(false) {}
 
   void BeginTest() override {
-    PostAddAnimationToMainThread(layer_tree_host()->root_layer());
+    AttachPlayersToTimeline();
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    PostAddAnimationToMainThreadPlayer(player_.get());
   }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     started_animating_ = true;
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (started_animating_)
       EndTest();
@@ skipping 15 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws);
 
 // Ensures that animations eventually get deleted.
 class LayerTreeHostAnimationTestAnimationsGetDeleted
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationsGetDeleted()
       : started_animating_(false) {}
 
   void BeginTest() override {
-    PostAddAnimationToMainThread(layer_tree_host()->root_layer());
+    AttachPlayersToTimeline();
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    PostAddAnimationToMainThreadPlayer(player_.get());
   }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
-    bool have_animations = !host_impl->animation_registrar()
+    bool have_animations = !host_impl->animation_host()
+                                ->animation_registrar()
                                 ->active_animation_controllers_for_testing()
                                 .empty();
     if (!started_animating_ && have_animations) {
       started_animating_ = true;
       return;
     }
 
     if (started_animating_ && !have_animations)
       EndTest();
   }
@@ skipping 17 matching lines @@
 // Ensure that an animation's timing function is respected.
 class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(layer_settings(), &client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
+
+    AttachPlayersToTimeline();
+    player_child_->AttachLayer(picture_->id());
   }
 
-  void BeginTest() override { PostAddAnimationToMainThread(picture_.get()); }
+  void BeginTest() override {
+    PostAddAnimationToMainThreadPlayer(player_child_.get());
+  }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     // TODO(ajuma): This test only checks the active tree. Add checks for
     // pending tree too.
     if (!host_impl->active_tree()->root_layer())
       return;
+
+    // Wait for the commit with the animation to happen.
+    if (host_impl->sync_tree()->source_frame_number() != 0)
+      return;
+
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        host_impl->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_child_impl =
+        timeline_impl->GetPlayerById(player_child_id_);
+
     LayerAnimationController* controller_impl =
-        host_impl->active_tree()->root_layer()->children()[0]->
-        layer_animation_controller();
+        player_child_impl->element_animations()->layer_animation_controller();
     Animation* animation =
         controller_impl->GetAnimation(TargetProperty::OPACITY);
-    if (!animation)
-      return;
 
     const FloatAnimationCurve* curve =
         animation->curve()->ToFloatAnimationCurve();
     float start_opacity = curve->GetValue(base::TimeDelta());
     float end_opacity = curve->GetValue(curve->Duration());
     float linearly_interpolated_opacity =
         0.25f * end_opacity + 0.75f * start_opacity;
     base::TimeDelta time = TimeUtil::Scale(curve->Duration(), 0.25f);
     // If the linear timing function associated with this animation was not
     // picked up, then the linearly interpolated opacity would be different
@@ skipping 15 matching lines @@
 // Ensures that main thread animations have their start times synchronized with
 // impl thread animations.
 class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(layer_settings(), &client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
-    picture_->set_layer_animation_delegate(this);
+
     layer_tree_host()->root_layer()->AddChild(picture_);
+
+    AttachPlayersToTimeline();
+    player_child_->set_layer_animation_delegate(this);
+    player_child_->AttachLayer(picture_->id());
   }
 
-  void BeginTest() override { PostAddAnimationToMainThread(picture_.get()); }
+  void BeginTest() override {
+    PostAddAnimationToMainThreadPlayer(player_child_.get());
+  }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
     LayerAnimationController* controller =
-        layer_tree_host()->root_layer()->children()[0]->
-        layer_animation_controller();
+        player_child_->element_animations()->layer_animation_controller();
     Animation* animation = controller->GetAnimation(TargetProperty::OPACITY);
     main_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
     EndTest();
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* impl_host,
                             bool has_unfinished_animation) override {
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        impl_host->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_child_impl =
+        timeline_impl->GetPlayerById(player_child_id_);
+
     LayerAnimationController* controller =
-        impl_host->active_tree()->root_layer()->children()[0]->
-        layer_animation_controller();
+        player_child_impl->element_animations()->layer_animation_controller();
     Animation* animation = controller->GetAnimation(TargetProperty::OPACITY);
     if (!animation)
       return;
 
     impl_start_time_ = animation->start_time();
   }
 
   void AfterTest() override {
     EXPECT_EQ(impl_start_time_, main_start_time_);
     EXPECT_LT(base::TimeTicks(), impl_start_time_);
   }
 
  private:
   base::TimeTicks main_start_time_;
   base::TimeTicks impl_start_time_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSynchronizeAnimationStartTimes);
 
 // Ensures that notify animation finished is called.
 class LayerTreeHostAnimationTestAnimationFinishedEvents
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override {
-    PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
+    AttachPlayersToTimeline();
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    PostAddInstantAnimationToMainThreadPlayer(player_.get());
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                int group) override {
     LayerAnimationController* controller =
-        layer_tree_host()->root_layer()->layer_animation_controller();
+        player_->element_animations()->layer_animation_controller();
     Animation* animation = controller->GetAnimation(TargetProperty::OPACITY);
     if (animation)
       controller->RemoveAnimation(animation->id());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimationFinishedEvents);
 
 // Ensures that when opacity is being animated, this value does not cause the
 // subtree to be skipped.
 class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity()
       : update_check_layer_() {}
 
   void SetupTree() override {
     update_check_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     update_check_layer_->SetOpacity(0.f);
     layer_tree_host()->SetRootLayer(update_check_layer_);
     client_.set_bounds(update_check_layer_->bounds());
     LayerTreeHostAnimationTest::SetupTree();
+
+    AttachPlayersToTimeline();
+    player_->AttachLayer(update_check_layer_->id());
   }
 
   void BeginTest() override {
-    PostAddAnimationToMainThread(update_check_layer_.get());
+    PostAddAnimationToMainThreadPlayer(player_.get());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        host_impl->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_impl =
+        timeline_impl->GetPlayerById(player_id_);
+
     LayerAnimationController* controller_impl =
-        host_impl->active_tree()->root_layer()->layer_animation_controller();
+        player_impl->element_animations()->layer_animation_controller();
     Animation* animation_impl =
         controller_impl->GetAnimation(TargetProperty::OPACITY);
     controller_impl->RemoveAnimation(animation_impl->id());
     EndTest();
   }
 
   void AfterTest() override {
     // Update() should have been called once, proving that the layer was not
     // skipped.
     EXPECT_EQ(1, update_check_layer_->update_count());
@@ skipping 12 matching lines @@
 
 // Layers added to tree with existing active animations should have the
 // animation correctly recognized.
 class LayerTreeHostAnimationTestLayerAddedWithAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
+      AttachPlayersToTimeline();
+
       scoped_refptr<Layer> layer = Layer::Create(layer_settings());
-      layer->set_layer_animation_delegate(this);
+      player_->AttachLayer(layer->id());
+      player_->set_layer_animation_delegate(this);
 
       // Any valid AnimationCurve will do here.
       scoped_ptr<AnimationCurve> curve(new FakeFloatAnimationCurve());
       scoped_ptr<Animation> animation(
           Animation::Create(std::move(curve), 1, 1, TargetProperty::OPACITY));
-      layer->layer_animation_controller()->AddAnimation(std::move(animation));
+      player_->AddAnimation(std::move(animation));
 
       // We add the animation *before* attaching the layer to the tree.
       layer_tree_host()->root_layer()->AddChild(layer);
     }
   }
 
   void AnimateLayers(LayerTreeHostImpl* impl_host,
                      base::TimeTicks monotonic_time) override {
     EndTest();
   }
@@ skipping 120 matching lines @@
 
 // Animations should not be started when frames are being skipped due to
 // checkerboard.
 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     : public LayerTreeHostAnimationTest {
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(layer_settings(), &client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
-    picture_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(picture_);
+
+    AttachPlayersToTimeline();
+    player_child_->AttachLayer(picture_->id());
+    player_child_->set_layer_animation_delegate(this);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
-    LayerTreeHostAnimationTest::InitializeSettings(settings);
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
+    LayerTreeHostAnimationTest::InitializeSettings(settings);
   }
 
   void BeginTest() override {
     prevented_draw_ = 0;
     started_times_ = 0;
 
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     // Don't checkerboard when the first animation wants to start.
     if (host_impl->active_tree()->source_frame_number() < 2)
       return draw_result;
     if (TestEnded())
       return draw_result;
     // Act like there is checkerboard when the second animation wants to draw.
     ++prevented_draw_;
     if (prevented_draw_ > 2)
       EndTest();
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The animation is longer than 1 BeginFrame interval.
-        AddOpacityTransitionToLayer(picture_.get(), 0.1, 0.2f, 0.8f, false);
+        AddOpacityTransitionToPlayer(player_child_.get(), 0.1, 0.2f, 0.8f,
+                                     false);
         break;
       case 2:
         // This second animation will not be drawn so it should not start.
-        AddAnimatedTransformToLayer(picture_.get(), 0.1, 5, 5);
+        AddAnimatedTransformToPlayer(player_child_.get(), 0.1, 5, 5);
         break;
     }
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
     if (TestEnded())
       return;
     started_times_++;
@@ skipping 24 matching lines @@
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
     scroll_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(1000, 1000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
+
+    AttachPlayersToTimeline();
+    player_child_->AttachLayer(scroll_layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         scoped_ptr<ScrollOffsetAnimationCurve> curve(
             ScrollOffsetAnimationCurve::Create(
                 gfx::ScrollOffset(500.f, 550.f),
                 EaseInOutTimingFunction::Create()));
         scoped_ptr<Animation> animation(Animation::Create(
             std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
         animation->set_needs_synchronized_start_time(true);
-        bool animation_added =
-            scroll_layer_->AddAnimation(std::move(animation));
         bool impl_scrolling_supported =
             layer_tree_host()->proxy()->SupportsImplScrolling();
-        EXPECT_EQ(impl_scrolling_supported, animation_added);
-        if (!impl_scrolling_supported)
+        if (impl_scrolling_supported)
+          player_child_->AddAnimation(std::move(animation));
+        else
           EndTest();
         break;
       }
       default:
         if (scroll_layer_->scroll_offset().x() > 10 &&
             scroll_layer_->scroll_offset().y() > 20)
           EndTest();
     }
   }
 
@@ skipping 26 matching lines @@
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(100.0, 200.0));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     scoped_ptr<ScrollOffsetAnimationCurve> curve(
         ScrollOffsetAnimationCurve::Create(gfx::ScrollOffset(6500.f, 7500.f),
                                            EaseInOutTimingFunction::Create()));
     scoped_ptr<Animation> animation(Animation::Create(
         std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
     animation->set_needs_synchronized_start_time(true);
-    scroll_layer_->AddAnimation(std::move(animation));
+
+    AttachPlayersToTimeline();
+    player_child_->AttachLayer(scroll_layer_->id());
+    player_child_->AddAnimation(std::move(animation));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
         Animation* animation =
-            scroll_layer_->layer_animation_controller()->GetAnimation(
-                TargetProperty::SCROLL_OFFSET);
-        scroll_layer_->layer_animation_controller()->RemoveAnimation(
-            animation->id());
+            player_child_->element_animations()
+                ->layer_animation_controller()
+                ->GetAnimation(TargetProperty::SCROLL_OFFSET);
+        player_child_->RemoveAnimation(animation->id());
         scroll_layer_->SetScrollOffset(final_postion_);
         break;
       }
       default:
         EXPECT_EQ(final_postion_, scroll_layer_->scroll_offset());
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
                                   const BeginFrameArgs& args) override {
     if (!host_impl->pending_tree())
       return;
 
     if (!host_impl->active_tree()->root_layer()) {
       host_impl->BlockNotifyReadyToActivateForTesting(false);
       return;
     }
 
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        host_impl->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_impl =
+        timeline_impl->GetPlayerById(player_child_id_);
+
     LayerImpl* scroll_layer_impl =
         host_impl->active_tree()->root_layer()->children()[0].get();
-    Animation* animation =
-        scroll_layer_impl->layer_animation_controller()->GetAnimation(
-            TargetProperty::SCROLL_OFFSET);
+    Animation* animation = player_impl->element_animations()
+                               ->layer_animation_controller()
+                               ->GetAnimation(TargetProperty::SCROLL_OFFSET);
 
     if (!animation || animation->run_state() != Animation::RUNNING) {
       host_impl->BlockNotifyReadyToActivateForTesting(false);
       return;
     }
 
     // Block activation until the running animation has a chance to produce a
     // scroll delta.
     gfx::Vector2dF scroll_delta = ScrollDelta(scroll_layer_impl);
     if (scroll_delta.x() < 1.f || scroll_delta.y() < 1.f)
@@ skipping 33 matching lines @@
 
 // When animations are simultaneously added to an existing layer and to a new
 // layer, they should start at the same time, even when there's already a
 // running animation on the existing layer.
 class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers()
       : frame_count_with_pending_tree_(0) {}
 
-  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+  void BeginTest() override {
+    AttachPlayersToTimeline();
+    PostSetNeedsCommitToMainThread();
+  }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
-      AddAnimatedTransformToLayer(layer_tree_host()->root_layer(), 4, 1, 1);
+      player_->AttachLayer(layer_tree_host()->root_layer()->id());
+      AddAnimatedTransformToPlayer(player_.get(), 4, 1, 1);
     } else if (layer_tree_host()->source_frame_number() == 2) {
-      AddOpacityTransitionToLayer(
-          layer_tree_host()->root_layer(), 1, 0.f, 0.5f, true);
+      AddOpacityTransitionToPlayer(player_.get(), 1, 0.f, 0.5f, true);
 
       scoped_refptr<Layer> layer = Layer::Create(layer_settings());
       layer_tree_host()->root_layer()->AddChild(layer);
-      layer->set_layer_animation_delegate(this);
       layer->SetBounds(gfx::Size(4, 4));
-      AddOpacityTransitionToLayer(layer.get(), 1, 0.f, 0.5f, true);
+
+      player_child_->AttachLayer(layer->id());
+      player_child_->set_layer_animation_delegate(this);
+      AddOpacityTransitionToPlayer(player_child_.get(), 1, 0.f, 0.5f, true);
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // For the commit that added animations to new and existing layers, keep
     // blocking activation. We want to verify that even with activation blocked,
@@ skipping 11 matching lines @@
       return;
 
     frame_count_with_pending_tree_++;
     if (frame_count_with_pending_tree_ == 2) {
       host_impl->BlockNotifyReadyToActivateForTesting(false);
     }
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* host_impl,
                             bool has_unfinished_animation) override {
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        host_impl->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_impl =
+        timeline_impl->GetPlayerById(player_id_);
+    scoped_refptr<AnimationPlayer> player_child_impl =
+        timeline_impl->GetPlayerById(player_child_id_);
+
+    // wait for tree activation.
+    if (!player_impl->element_animations())
+      return;
+
     LayerAnimationController* root_controller_impl =
-        host_impl->active_tree()->root_layer()->layer_animation_controller();
+        player_impl->element_animations()->layer_animation_controller();
     Animation* root_animation =
         root_controller_impl->GetAnimation(TargetProperty::OPACITY);
     if (!root_animation || root_animation->run_state() != Animation::RUNNING)
       return;
 
     LayerAnimationController* child_controller_impl =
-        host_impl->active_tree()->root_layer()->children()
-            [0]->layer_animation_controller();
+        player_child_impl->element_animations()->layer_animation_controller();
     Animation* child_animation =
         child_controller_impl->GetAnimation(TargetProperty::OPACITY);
     EXPECT_EQ(Animation::RUNNING, child_animation->run_state());
     EXPECT_EQ(root_animation->start_time(), child_animation->start_time());
     root_controller_impl->AbortAnimations(TargetProperty::OPACITY);
     root_controller_impl->AbortAnimations(TargetProperty::TRANSFORM);
     child_controller_impl->AbortAnimations(TargetProperty::OPACITY);
     EndTest();
   }
 
@@ skipping 15 matching lines @@
 
     layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(2, 2));
     client_.set_bounds(layer_->bounds());
     // Transform the layer to 4,4 to start.
     gfx::Transform start_transform;
     start_transform.Translate(4.0, 4.0);
     layer_->SetTransform(start_transform);
 
     layer_tree_host()->root_layer()->AddChild(layer_);
+    player_->AttachLayer(layer_->id());
+
+    AttachPlayersToTimeline();
   }
 
   void BeginTest() override {
     // Add a translate from 6,7 to 8,9.
     TransformOperations start;
     start.AppendTranslate(6.f, 7.f, 0.f);
     TransformOperations end;
     end.AppendTranslate(8.f, 9.f, 0.f);
-    AddAnimatedTransformToLayer(layer_.get(), 4.0, start, end);
+    AddAnimatedTransformToPlayer(player_.get(), 4.0, start, end);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void WillPrepareTiles(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() != 0)
       return;
 
     // After checking this on the sync tree, we will activate, which will cause
     // PrepareTiles to happen again (which races with the test exiting).
     if (TestEnded())
       return;
 
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        host_impl->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_impl =
+        timeline_impl->GetPlayerById(player_id_);
+
+    LayerAnimationController* controller_impl =
+        player_impl->element_animations()->layer_animation_controller();
+
     LayerImpl* root = host_impl->sync_tree()->root_layer();
     LayerImpl* child = root->children()[0].get();
-    LayerAnimationController* controller_impl =
-        child->layer_animation_controller();
     Animation* animation =
         controller_impl->GetAnimation(TargetProperty::TRANSFORM);
 
     // The animation should be starting for the first frame.
     EXPECT_EQ(Animation::STARTING, animation->run_state());
 
     // And the transform should be propogated to the sync tree layer, at its
     // starting state which is 6,7.
     gfx::Transform expected_transform;
     expected_transform.Translate(6.0, 7.0);
@@ skipping 17 matching lines @@
 // When a layer with an animation is removed from the tree and later re-added,
 // the animation should resume.
 class LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = Layer::Create(layer_settings());
     layer_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(layer_);
-    AddOpacityTransitionToLayer(layer_.get(), 10000.0, 0.1f, 0.9f, true);
+
+    layer_tree_host()->animation_host()->AddAnimationTimeline(timeline_.get());
+    timeline_->AttachPlayer(player_.get());
+    player_->AttachLayer(layer_->id());
+    DCHECK(player_->element_animations());
+
+    AddOpacityTransitionToPlayer(player_.get(), 10000.0, 0.1f, 0.9f, true);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
-        EXPECT_TRUE(
-            layer_tree_host()->animation_registrar()->needs_animate_layers());
+        EXPECT_TRUE(player_->element_animations()
+                        ->has_active_value_observer_for_testing());
+        EXPECT_FALSE(player_->element_animations()
+                         ->has_pending_value_observer_for_testing());
+        EXPECT_TRUE(layer_tree_host()
+                        ->animation_host()
+                        ->animation_registrar()
+                        ->needs_animate_layers());
         break;
       case 1:
         layer_->RemoveFromParent();
-        EXPECT_TRUE(
-            layer_tree_host()->animation_registrar()->needs_animate_layers());
+        EXPECT_FALSE(player_->element_animations()
+                         ->has_active_value_observer_for_testing());
+        EXPECT_FALSE(player_->element_animations()
+                         ->has_pending_value_observer_for_testing());
+        EXPECT_TRUE(layer_tree_host()
+                        ->animation_host()
+                        ->animation_registrar()
+                        ->needs_animate_layers());
         break;
       case 2:
         layer_tree_host()->root_layer()->AddChild(layer_);
-        EXPECT_TRUE(
-            layer_tree_host()->animation_registrar()->needs_animate_layers());
+        EXPECT_TRUE(player_->element_animations()
+                        ->has_active_value_observer_for_testing());
+        EXPECT_FALSE(player_->element_animations()
+                         ->has_pending_value_observer_for_testing());
+        EXPECT_TRUE(layer_tree_host()
+                        ->animation_host()
+                        ->animation_registrar()
+                        ->needs_animate_layers());
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
+    scoped_refptr<AnimationTimeline> timeline_impl =
+        host_impl->animation_host()->GetTimelineById(timeline_id_);
+    scoped_refptr<AnimationPlayer> player_impl =
+        timeline_impl->GetPlayerById(player_id_);
+
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_TRUE(host_impl->animation_registrar()->needs_animate_layers());
+        EXPECT_TRUE(player_impl->element_animations()
+                        ->has_active_value_observer_for_testing());
+        EXPECT_TRUE(host_impl->animation_host()
+                        ->animation_registrar()
+                        ->needs_animate_layers());
         break;
       case 1:
-        EXPECT_FALSE(host_impl->animation_registrar()->needs_animate_layers());
+        EXPECT_FALSE(player_impl->element_animations()
+                         ->has_active_value_observer_for_testing());
+        EXPECT_TRUE(host_impl->animation_host()
+                        ->animation_registrar()
+                        ->needs_animate_layers());
         break;
       case 2:
-        EXPECT_TRUE(host_impl->animation_registrar()->needs_animate_layers());
+        EXPECT_TRUE(player_impl->element_animations()
+                        ->has_active_value_observer_for_testing());
+        EXPECT_TRUE(host_impl->animation_host()
+                        ->animation_registrar()
+                        ->needs_animate_layers());
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded);
 
 class LayerTreeHostAnimationTestAddAnimationAfterAnimating
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = Layer::Create(layer_settings());
     layer_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(layer_);
+
+    AttachPlayersToTimeline();
+
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    player_child_->AttachLayer(layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // First frame: add an animation to the root layer.
-        AddAnimatedTransformToLayer(layer_tree_host()->root_layer(), 0.1, 5, 5);
+        AddAnimatedTransformToPlayer(player_.get(), 0.1, 5, 5);
         break;
       case 2:
         // Second frame: add an animation to the content layer. The root layer
         // animation has caused us to animate already during this frame.
-        AddOpacityTransitionToLayer(layer_.get(), 0.1, 5, 5, false);
+        AddOpacityTransitionToPlayer(player_child_.get(), 0.1, 5, 5, false);
         break;
     }
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     // After both animations have started, verify that they have valid
     // start times.
     if (host_impl->active_tree()->source_frame_number() < 2)
       return;
     AnimationRegistrar::AnimationControllerMap controllers_copy =
-        host_impl->animation_registrar()
+        host_impl->animation_host()
+            ->animation_registrar()
             ->active_animation_controllers_for_testing();
     EXPECT_EQ(2u, controllers_copy.size());
     for (auto& it : controllers_copy) {
       int id = it.first;
       if (id == host_impl->RootLayer()->id()) {
         Animation* anim = it.second->GetAnimation(TargetProperty::TRANSFORM);
         EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
       } else if (id == host_impl->RootLayer()->children()[0]->id()) {
         Animation* anim = it.second->GetAnimation(TargetProperty::OPACITY);
         EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
@@ skipping 13 matching lines @@
 
 class LayerTreeHostAnimationTestRemoveAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
+
+    AttachPlayersToTimeline();
+
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    player_child_->AttachLayer(layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
-        AddAnimatedTransformToLayer(layer_.get(), 1.0, 5, 5);
+        AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 5, 5);
         break;
       case 2:
         LayerAnimationController* controller =
-            layer_->layer_animation_controller();
+            player_child_->element_animations()->layer_animation_controller();
         Animation* animation =
             controller->GetAnimation(TargetProperty::TRANSFORM);
-        layer_->RemoveAnimation(animation->id());
+        player_child_->RemoveAnimation(animation->id());
         gfx::Transform transform;
         transform.Translate(10.f, 10.f);
         layer_->SetTransform(transform);
 
         // Do something that causes property trees to get rebuilt. This is
         // intended to simulate the conditions that caused the bug whose fix
         // this is testing (the test will pass without it but won't test what
         // we want it to). We were updating the wrong transform node at the end
         // of an animation (we were assuming the layer with the finished
         // animation still had its own transform node). But nodes can only get
@@ skipping 42 matching lines @@
 
 class LayerTreeHostAnimationTestIsAnimating
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
+
+    AttachPlayersToTimeline();
+    player_->AttachLayer(layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
-        AddAnimatedTransformToLayer(layer_.get(), 1.0, 5, 5);
+        AddAnimatedTransformToPlayer(player_.get(), 1.0, 5, 5);
         break;
       case 2:
         LayerAnimationController* controller =
-            layer_->layer_animation_controller();
+            player_->element_animations()->layer_animation_controller();
         Animation* animation =
             controller->GetAnimation(TargetProperty::TRANSFORM);
-        layer_->RemoveAnimation(animation->id());
+        player_->RemoveAnimation(animation->id());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->sync_tree()->root_layer();
     LayerImpl* child = root->children()[0].get();
     switch (host_impl->sync_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
@@ skipping 47 matching lines @@
  public:
   LayerTreeHostAnimationTestAnimationFinishesDuringCommit()
       : signalled_(false) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
+
+    AttachPlayersToTimeline();
+
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    player_child_->AttachLayer(layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1)
-      AddAnimatedTransformToLayer(layer_.get(), 0.04, 5, 5);
+      AddAnimatedTransformToPlayer(player_child_.get(), 0.04, 5, 5);
   }
 
   void WillCommit() override {
     if (layer_tree_host()->source_frame_number() == 2) {
       // Block until the animation finishes on the compositor thread. Since
       // animations have already been ticked on the main thread, when the commit
       // happens the state on the main thread will be consistent with having a
       // running animation but the state on the compositor thread will be
       // consistent with having only a finished animation.
       completion_.Wait();
@@ skipping 43 matching lines @@
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestNotifyAnimationFinished()
       : called_animation_started_(false), called_animation_finished_(false) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(layer_settings(), &client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
-    picture_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(picture_);
+
+    AttachPlayersToTimeline();
+    player_->AttachLayer(picture_->id());
+    player_->set_layer_animation_delegate(this);
   }
 
   void BeginTest() override {
-    PostAddLongAnimationToMainThread(picture_.get());
+    PostAddLongAnimationToMainThreadPlayer(player_.get());
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
     called_animation_started_ = true;
     layer_tree_host()->AnimateLayers(base::TimeTicks::FromInternalValue(
         std::numeric_limits<int64_t>::max()));
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 13 matching lines @@
  private:
   bool called_animation_started_;
   bool called_animation_finished_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestNotifyAnimationFinished);
 
+// Check that SetTransformIsPotentiallyAnimatingChanged is called
+// if we destroy LayerAnimationController and ElementAnimations.
+class LayerTreeHostAnimationTestSetPotentiallyAnimatingOnLacDestruction
+    : public LayerTreeHostAnimationTest {
+ public:
+  void SetupTree() override {
+    prev_screen_space_transform_is_animating_ = true;
+    screen_space_transform_animation_stopped_ = false;
+
+    LayerTreeHostAnimationTest::SetupTree();
+    AttachPlayersToTimeline();
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    AddAnimatedTransformToPlayer(player_.get(), 1.0, 5, 5);
+  }
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->pending_tree()->source_frame_number() <= 1) {
+      EXPECT_TRUE(host_impl->pending_tree()
+                      ->root_layer()
+                      ->screen_space_transform_is_animating());
+    } else {
+      EXPECT_FALSE(host_impl->pending_tree()
+                       ->root_layer()
+                       ->screen_space_transform_is_animating());
+    }
+  }
+
+  void DidCommit() override { PostSetNeedsCommitToMainThread(); }
+
+  void UpdateLayerTreeHost() override {
+    if (layer_tree_host()->source_frame_number() == 2) {
+      // Destroy player.
+      timeline_->DetachPlayer(player_.get());
+      player_ = nullptr;
+    }
+  }
+
+  DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   DrawResult draw_result) override {
+    const bool screen_space_transform_is_animating =
+        host_impl->active_tree()
+            ->root_layer()
+            ->screen_space_transform_is_animating();
+
+    // Check that screen_space_transform_is_animating changes only once.
+    if (screen_space_transform_is_animating &&
+        prev_screen_space_transform_is_animating_)
+      EXPECT_FALSE(screen_space_transform_animation_stopped_);
+    if (!screen_space_transform_is_animating &&
+        prev_screen_space_transform_is_animating_) {
+      EXPECT_FALSE(screen_space_transform_animation_stopped_);
+      screen_space_transform_animation_stopped_ = true;
+    }
+    if (!screen_space_transform_is_animating &&
+        !prev_screen_space_transform_is_animating_)
+      EXPECT_TRUE(screen_space_transform_animation_stopped_);
+
+    prev_screen_space_transform_is_animating_ =
+        screen_space_transform_is_animating;
+
+    return draw_result;
+  }
+
+  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->active_tree()->source_frame_number() >= 2)
+      EndTest();
+  }
+
+  void AfterTest() override {
+    EXPECT_TRUE(screen_space_transform_animation_stopped_);
+  }
+
+  bool prev_screen_space_transform_is_animating_;
+  bool screen_space_transform_animation_stopped_;
+};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostAnimationTestSetPotentiallyAnimatingOnLacDestruction);
+
+// Check that we invalidate property trees on AnimationPlayer::SetNeedsCommit.
+class LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit
+    : public LayerTreeHostAnimationTest {
+ public:
+  void SetupTree() override {
+    LayerTreeHostAnimationTest::SetupTree();
+    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_->SetBounds(gfx::Size(4, 4));
+    client_.set_bounds(layer_->bounds());
+    layer_tree_host()->root_layer()->AddChild(layer_);
+
+    AttachPlayersToTimeline();
+
+    player_->AttachLayer(layer_tree_host()->root_layer()->id());
+    player_child_->AttachLayer(layer_->id());
+  }
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void DidCommit() override {
+    if (layer_tree_host()->source_frame_number() == 1 ||
+        layer_tree_host()->source_frame_number() == 2)
+      PostSetNeedsCommitToMainThread();
+  }
+
+  void UpdateLayerTreeHost() override {
+    if (layer_tree_host()->source_frame_number() == 1) {
+      EXPECT_FALSE(layer_tree_host()->property_trees()->needs_rebuild);
+      AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 5, 5);
+    }
+
+    EXPECT_TRUE(layer_tree_host()->property_trees()->needs_rebuild);
+  }
+
+  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->active_tree()->source_frame_number() >= 2)
+      EndTest();
+  }
+
+  void AfterTest() override {}
+
+ private:
+  scoped_refptr<Layer> layer_;
+  FakeContentLayerClient client_;
+};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit);
+
 }  // namespace
 }  // namespace cc