cc: Push Animation Finished State and Use Finished State for IsCompleted

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 <climits>
 
 #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/scroll_offset_animation_curve.h"
 #include "cc/animation/scroll_offset_animations.h"
 #include "cc/animation/timing_function.h"
@@ skipping 1378 matching lines @@
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
     player_->AttachElement(layer_tree_host()->root_layer()->element_id());
     player_child_->AttachElement(layer_->element_id());
   }
 
-  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+  void BeginTest() override {
+    animation_stopped_ = false;
+    last_frame_number_ = INT_MAX;
+    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_->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
         // animation still had its own transform node). But nodes can only get
         // added/deleted when something triggers a rebuild. Adding a layer
         // triggers a rebuild, and since the layer that had an animation before
         // no longer has one, it doesn't get a transform node in the rebuild.
         layer_->AddChild(Layer::Create());
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
+    GetImplTimelineAndPlayerByID(*host_impl);
     LayerImpl* child = host_impl->active_tree()->LayerById(layer_->id());
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
         break;
       case 1:
         // Animation is started.
         EXPECT_TRUE(child->screen_space_transform_is_animating());
         break;
       case 2: {
-        // The animation is removed, the transform that was set afterward is
+        // The animation is stopped, the transform that was set afterward is
         // applied.
         gfx::Transform expected_transform;
         expected_transform.Translate(10.f, 10.f);
         EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                         child->DrawTransform());
         EXPECT_FALSE(child->screen_space_transform_is_animating());
-        EndTest();
+        animation_stopped_ = true;
+        PostSetNeedsCommitToMainThread();
         break;
       }
-      default:
-        NOTREACHED();
     }
   }
 
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    if (host_impl->sync_tree()->source_frame_number() >= last_frame_number_) {
+      // Check that eventurally the animation is removed.

[ajuma, 2017/04/11 23:32:02]

'eventually'

+      EXPECT_FALSE(player_child_impl_->has_any_animation());
+      EndTest();
+    }
+  }
+
+  void UpdateAnimationState(LayerTreeHostImpl* host_impl,
+                            bool has_unfinished_animation) override {
+    // Non impl only animations are removed during commit. After the animation
+    // is fully stopped on compositor thread, make sure another commit happens.
+    if (animation_stopped_ && !has_unfinished_animation) {
+      last_frame_number_ =
+          std::min(last_frame_number_,
+                   host_impl->active_tree()->source_frame_number() + 1);
+      PostSetNeedsCommitToMainThread();
+    }
+  }
+
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
   FakeContentLayerClient client_;
+
+  int last_frame_number_;
+  bool animation_stopped_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestRemoveAnimation);
 
 class LayerTreeHostAnimationTestIsAnimating
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(&client_);
@@ skipping 385 matching lines @@
  private:
   scoped_refptr<Layer> layer_;
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit);
 
 }  // namespace
 }  // namespace cc