De-activate LayerAnimationControllers when all animations are WaitingForDeletion

cc/test/layer_tree_test.cc

 // Copyright 2011 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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 357 matching lines @@
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&LayerTreeTest::EndTest, main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostAddAnimationToMainThread(
     Layer* layer_to_receive_animation) {
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchAddAnimation,
                  main_thread_weak_ptr_,
-                 base::Unretained(layer_to_receive_animation)));
+                 base::Unretained(layer_to_receive_animation),
+                 0.000001));
 }
 
 void LayerTreeTest::PostAddInstantAnimationToMainThread(
     Layer* layer_to_receive_animation) {
   main_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LayerTreeTest::DispatchAddInstantAnimation,
+      base::Bind(&LayerTreeTest::DispatchAddAnimation,
                  main_thread_weak_ptr_,
-                 base::Unretained(layer_to_receive_animation)));
+                 base::Unretained(layer_to_receive_animation),
+                 0.0));
+}
+
+void LayerTreeTest::PostAddLongAnimationToMainThread(
+    Layer* layer_to_receive_animation) {
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeTest::DispatchAddAnimation,
+                 main_thread_weak_ptr_,
+                 base::Unretained(layer_to_receive_animation),
+                 1.0));
 }
 
 void LayerTreeTest::PostSetNeedsCommitToMainThread() {
   main_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&LayerTreeTest::DispatchSetNeedsCommit,
                                          main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostReadbackToMainThread() {
   main_task_runner_->PostTask(
@@ skipping 97 matching lines @@
   if (layer_tree_host_ && proxy()->CommitPendingForTesting()) {
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
     return;
   }
 
   base::MessageLoop::current()->Quit();
 }
 
-void LayerTreeTest::DispatchAddInstantAnimation(
-    Layer* layer_to_receive_animation) {
+void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation,
+                                         double animation_duration) {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_to_receive_animation) {
     AddOpacityTransitionToLayer(layer_to_receive_animation,
-                                0,
-                                0,
-                                0.5,
-                                false);
-  }
-}
-
-void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation) {
-  DCHECK(!proxy() || proxy()->IsMainThread());
-
-  if (layer_to_receive_animation) {
-    AddOpacityTransitionToLayer(layer_to_receive_animation,
-                                0.000001,
+                                animation_duration,
                                 0,
                                 0.5,
                                 true);
   }
 }
 
 void LayerTreeTest::DispatchSetNeedsCommit() {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_tree_host_)
@@ skipping 134 matching lines @@
 }
 
 scoped_refptr<ContextProvider> LayerTreeTest::OffscreenContextProvider() {
   if (!compositor_contexts_.get() ||
       compositor_contexts_->DestroyedOnMainThread())
     compositor_contexts_ = TestContextProvider::Create();
   return compositor_contexts_;
 }
 
 }  // namespace cc