CC Animations: Rewrite unit tests to work with AnimationPlayer.

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"
@@ skipping 32 matching lines @@
     player_->set_animation_delegate(this);
   }
 
   void AttachPlayersToTimeline() {
     layer_tree()->animation_host()->AddAnimationTimeline(timeline_.get());
     layer_tree()->SetElementIdsForTesting();
     timeline_->AttachPlayer(player_.get());
     timeline_->AttachPlayer(player_child_.get());
   }
 
+  void GetImplTimelineAndPlayerByID(const LayerTreeHostImpl& host_impl) {
+    AnimationHost* animation_host_impl = host_impl.animation_host();
+    timeline_impl_ = animation_host_impl->GetTimelineById(timeline_id_);
+    EXPECT_TRUE(timeline_impl_);
+    player_impl_ = timeline_impl_->GetPlayerById(player_id_);
+    EXPECT_TRUE(player_impl_);
+    player_child_impl_ = timeline_impl_->GetPlayerById(player_child_id_);
+    EXPECT_TRUE(player_child_impl_);
+  }
+
  protected:
   scoped_refptr<AnimationTimeline> timeline_;
   scoped_refptr<AnimationPlayer> player_;
   scoped_refptr<AnimationPlayer> player_child_;
 
+  scoped_refptr<AnimationTimeline> timeline_impl_;
+  scoped_refptr<AnimationPlayer> player_impl_;
+  scoped_refptr<AnimationPlayer> player_child_impl_;
+
   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:
@@ skipping 87 matching lines @@
                             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);
 
-    Animation* animation =
-        player_->element_animations()->GetAnimation(TargetProperty::OPACITY);
+    Animation* animation = player_->GetAnimation(TargetProperty::OPACITY);
     if (animation)
       player_->RemoveAnimation(animation->id());
 
     EndTest();
   }
 
   void AfterTest() override { EXPECT_TRUE(update_animation_state_was_called_); }
 
  private:
   bool update_animation_state_was_called_;
@@ skipping 112 matching lines @@
     // 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_);
 
     Animation* animation =
-        player_child_impl->element_animations()->GetAnimation(
-            TargetProperty::OPACITY);
+        player_child_impl->GetAnimation(TargetProperty::OPACITY);
 
     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 30 matching lines @@
     player_child_->AttachElement(picture_->element_id());
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThreadPlayer(player_child_.get());
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
-    Animation* animation = player_child_->element_animations()->GetAnimation(
-        TargetProperty::OPACITY);
+    Animation* animation = player_child_->GetAnimation(TargetProperty::OPACITY);
     main_start_time_ = animation->start_time();
-    player_child_->element_animations()->RemoveAnimation(animation->id());
+    player_child_->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_);
 
     Animation* animation =
-        player_child_impl->element_animations()->GetAnimation(
-            TargetProperty::OPACITY);
+        player_child_impl->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_);
   }
@@ skipping 14 matching lines @@
  public:
   void BeginTest() override {
     AttachPlayersToTimeline();
     player_->AttachElement(layer_tree()->root_layer()->element_id());
     PostAddInstantAnimationToMainThreadPlayer(player_.get());
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                int group) override {
-    Animation* animation =
-        player_->element_animations()->GetAnimation(TargetProperty::OPACITY);
+    Animation* animation = player_->GetAnimation(TargetProperty::OPACITY);
     if (animation)
-      player_->element_animations()->RemoveAnimation(animation->id());
+      player_->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
@@ skipping 18 matching lines @@
   void BeginTest() override {
     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_);
 
-    Animation* animation_impl = player_impl->element_animations()->GetAnimation(
-        TargetProperty::OPACITY);
-    player_impl->element_animations()->RemoveAnimation(animation_impl->id());
+    Animation* animation_impl =
+        player_impl->GetAnimation(TargetProperty::OPACITY);
+    player_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());
 
     // clear update_check_layer_ so LayerTreeHost dies.
     update_check_layer_ = NULL;
@@ skipping 376 matching lines @@
     LayerTreeHostAnimationTest::SetupTree();
 
     scroll_layer_ = FakePictureLayer::Create(&client_);
     scroll_layer_->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     scroll_layer_->SetScrollClipLayerId(layer_tree()->root_layer()->id());
     layer_tree()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(scroll_layer_->element_id());
+  }
+
+  AnimationPlayer& ScrollOffsetPlayer(
+      const LayerTreeHostImpl& host_impl,
+      scoped_refptr<FakePictureLayer> layer) const {
+    scoped_refptr<ElementAnimations> element_animations =
+        host_impl.animation_host()->GetElementAnimationsForElementId(
+            layer->element_id());
+    DCHECK(element_animations);
+    DCHECK(element_animations->players_list().might_have_observers());
+
+    ElementAnimations::PlayersList::Iterator it(
+        &element_animations->players_list());
+    AnimationPlayer* player = it.GetNext();
+    DCHECK(player);
+    return *player;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->SourceFrameNumber() == 1) {
       // Add an update after the first commit to trigger the animation update
       // path.
       layer_tree()
           ->animation_host()
@@ skipping 10 matching lines @@
                        ->animation_host()
                        ->scroll_offset_animations()
                        .HasUpdatesForTesting());
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     // Note that the frame number gets incremented after BeginCommitOnThread but
     // before WillCommitCompleteOnThread and CommitCompleteOnThread.
     if (host_impl->sync_tree()->source_frame_number() == 0) {
+      GetImplTimelineAndPlayerByID(*host_impl);
       // This happens after the impl-only animation is added in
       // WillCommitCompleteOnThread.
-      Animation* animation =
-          host_impl->animation_host()
-              ->GetElementAnimationsForElementId(scroll_layer_->element_id())
-              ->GetAnimation(TargetProperty::SCROLL_OFFSET);
+      Animation* animation = ScrollOffsetPlayer(*host_impl, scroll_layer_)
+                                 .GetAnimation(TargetProperty::SCROLL_OFFSET);
+      DCHECK(animation);
       ScrollOffsetAnimationCurve* curve =
           animation->curve()->ToScrollOffsetAnimationCurve();
 
       // Verifiy the initial and target position before the scroll offset
       // update from MT.
       EXPECT_EQ(Animation::RunState::RUNNING, animation->run_state());
       EXPECT_EQ(gfx::ScrollOffset(10.f, 20.f),
                 curve->GetValue(base::TimeDelta()));
       EXPECT_EQ(gfx::ScrollOffset(650.f, 750.f), curve->target_value());
     }
   }
 
   void WillCommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 0) {
       host_impl->animation_host()->ImplOnlyScrollAnimationCreate(
           scroll_layer_->element_id(), gfx::ScrollOffset(650.f, 750.f),
           gfx::ScrollOffset(10, 20), base::TimeDelta());
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 1) {
-      Animation* animation =
-          host_impl->animation_host()
-              ->GetElementAnimationsForElementId(scroll_layer_->element_id())
-              ->GetAnimation(TargetProperty::SCROLL_OFFSET);
+      Animation* animation = ScrollOffsetPlayer(*host_impl, scroll_layer_)
+                                 .GetAnimation(TargetProperty::SCROLL_OFFSET);
+      DCHECK(animation);
       ScrollOffsetAnimationCurve* curve =
           animation->curve()->ToScrollOffsetAnimationCurve();
       // Verifiy the initial and target position after the scroll offset
       // update from MT
       EXPECT_EQ(Animation::RunState::STARTING, animation->run_state());
       EXPECT_EQ(gfx::ScrollOffset(110.f, 120.f),
                 curve->GetValue(base::TimeDelta()));
       EXPECT_EQ(gfx::ScrollOffset(750.f, 850.f), curve->target_value());
 
       EndTest();
@@ skipping 44 matching lines @@
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         break;
       case 1: {
         Animation* animation =
-            player_child_->element_animations()
-                ->GetAnimation(TargetProperty::SCROLL_OFFSET);
+            player_child_->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 {
@@ skipping 36 matching lines @@
     if (!host_impl->active_tree()->root_layer_for_testing())
       return false;
 
     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()->LayerById(scroll_layer_->id());
-    Animation* animation = player_impl->element_animations()->GetAnimation(
-        TargetProperty::SCROLL_OFFSET);
+    Animation* animation =
+        player_impl->GetAnimation(TargetProperty::SCROLL_OFFSET);
 
     if (!animation || animation->run_state() != Animation::RUNNING)
       return false;
 
     // 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() > 0.f || scroll_delta.y() > 0.f)
       return false;
 
@@ skipping 72 matching lines @@
         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;
 
-    Animation* root_animation = player_impl->element_animations()->GetAnimation(
-        TargetProperty::OPACITY);
+    Animation* root_animation =
+        player_impl->GetAnimation(TargetProperty::OPACITY);
     if (!root_animation || root_animation->run_state() != Animation::RUNNING)
       return;
 
     Animation* child_animation =
-        player_child_impl->element_animations()->GetAnimation(
-            TargetProperty::OPACITY);
+        player_child_impl->GetAnimation(TargetProperty::OPACITY);
     EXPECT_EQ(Animation::RUNNING, child_animation->run_state());
     EXPECT_EQ(root_animation->start_time(), child_animation->start_time());
-    player_impl->element_animations()->AbortAnimations(TargetProperty::OPACITY);
-    player_impl->element_animations()->AbortAnimations(
-        TargetProperty::TRANSFORM);
-    player_child_impl->element_animations()->AbortAnimations(
-        TargetProperty::OPACITY);
+    player_impl->AbortAnimations(TargetProperty::OPACITY, false);
+    player_impl->AbortAnimations(TargetProperty::TRANSFORM, false);
+    player_child_impl->AbortAnimations(TargetProperty::OPACITY, false);
     EndTest();
   }
 
   void AfterTest() override {}
 
  private:
   int frame_count_with_pending_tree_;
 };
 
 // This test blocks activation which is not supported for single thread mode.
@@ skipping 41 matching lines @@
     // 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_);
 
     LayerImpl* child = host_impl->sync_tree()->LayerById(layer_->id());
-    Animation* animation = player_impl->element_animations()->GetAnimation(
-        TargetProperty::TRANSFORM);
+    Animation* animation = player_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);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, child->DrawTransform());
     // And the sync tree layer should know it is animating.
     EXPECT_TRUE(child->screen_space_transform_is_animating());
 
-    player_impl->element_animations()->AbortAnimations(
-        TargetProperty::TRANSFORM);
+    player_impl->AbortAnimations(TargetProperty::TRANSFORM, false);
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 126 matching lines @@
     if (!TestEnded()) {
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE,
           base::Bind(&LayerTreeHostAnimationTestAddAnimationAfterAnimating::
                          CheckAnimations,
                      base::Unretained(this), host_impl));
     }
   }
 
   void CheckAnimations(LayerTreeHostImpl* host_impl) {
-    AnimationHost::ElementToAnimationsMap element_animations_copy =
-        host_impl->animation_host()->active_element_animations_for_testing();
-    EXPECT_EQ(2u, element_animations_copy.size());
-    for (auto& it : element_animations_copy) {
-      ElementId id = it.first;
-      if (id ==
-          host_impl->active_tree()->root_layer_for_testing()->element_id()) {
-        Animation* anim = it.second->GetAnimation(TargetProperty::TRANSFORM);
-        EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
-      } else if (id == layer_->element_id()) {
-        Animation* anim = it.second->GetAnimation(TargetProperty::OPACITY);
-        EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
-      }
-      EndTest();
-    }
+    GetImplTimelineAndPlayerByID(*host_impl);
+
+    EXPECT_EQ(2u, host_impl->animation_host()
+                      ->active_element_animations_for_testing()
+                      .size());
+
+    Animation* root_anim =
+        player_impl_->GetAnimation(TargetProperty::TRANSFORM);
+    EXPECT_GT((root_anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
+
+    Animation* anim = player_child_impl_->GetAnimation(TargetProperty::OPACITY);
+    EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
+
+    EndTest();
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationAfterAnimating);
@@ skipping 16 matching lines @@
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 5, 5);
         break;
       case 2:
         Animation* animation =
-            player_child_->element_animations()->GetAnimation(
-                TargetProperty::TRANSFORM);
+            player_child_->GetAnimation(TargetProperty::TRANSFORM);
         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
@@ skipping 56 matching lines @@
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         AddAnimatedTransformToPlayer(player_.get(), 1.0, 5, 5);
         break;
       case 2:
-        Animation* animation = player_->element_animations()->GetAnimation(
-            TargetProperty::TRANSFORM);
+        Animation* animation = player_->GetAnimation(TargetProperty::TRANSFORM);
         player_->RemoveAnimation(animation->id());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* child = host_impl->sync_tree()->LayerById(layer_->id());
     switch (host_impl->sync_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
@@ skipping 211 matching lines @@
   void DidCommit() override { PostSetNeedsCommitToMainThread(); }
 
   void WillBeginMainFrame() override {
     if (layer_tree_host()->SourceFrameNumber() == 2) {
       // Destroy player.
       timeline_->DetachPlayer(player_.get());
       player_ = nullptr;
       timeline_->AttachPlayer(player_child_.get());
       player_child_->AttachElement(layer_tree()->root_layer()->element_id());
       AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 10, 10);
-      Animation* animation = player_child_->element_animations()->GetAnimation(
-          TargetProperty::TRANSFORM);
+      Animation* animation =
+          player_child_->GetAnimation(TargetProperty::TRANSFORM);
       animation->set_start_time(base::TimeTicks::Now() +
                                 base::TimeDelta::FromSecondsD(1000));
       animation->set_fill_mode(Animation::FillMode::NONE);
     }
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestChangeAnimationPlayer);
@@ skipping 124 matching lines @@
  private:
   scoped_refptr<Layer> layer_;
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit);
 
 }  // namespace
 }  // namespace cc