CC Animations: Redirect all compositor animation requests to AnimationHost.

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 "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/animation.h"
+#include "cc/animation/animation_host.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/begin_frame_args_test.h"
@@ skipping 318 matching lines @@
 
   void AnimateLayers(base::TimeTicks monotonic_time) override {
     test_hooks_->WillAnimateLayers(this, monotonic_time);
     LayerTreeHostImpl::AnimateLayers(monotonic_time);
     test_hooks_->AnimateLayers(this, monotonic_time);
   }
 
   void UpdateAnimationState(bool start_ready_animations) override {
     LayerTreeHostImpl::UpdateAnimationState(start_ready_animations);
     bool has_unfinished_animation = false;
+    AnimationRegistrar* registrar =
+        animation_registrar() ? animation_registrar()
+                              : animation_host()->animation_registrar();
     for (const auto& it :
-         animation_registrar()->active_animation_controllers_for_testing()) {
+         registrar->active_animation_controllers_for_testing()) {
       if (it.second->HasActiveAnimation()) {
         has_unfinished_animation = true;
         break;
       }
     }
     test_hooks_->UpdateAnimationState(this, has_unfinished_animation);
   }
 
   void NotifyTileStateChanged(const Tile* tile) override {
     LayerTreeHostImpl::NotifyTileStateChanged(tile);
@@ skipping 227 matching lines @@
 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::PostAddAnimationToMainThreadPlayer(
+    AnimationPlayer* player_to_receive_animation) {
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeTest::DispatchAddAnimationToPlayer,
+                 main_thread_weak_ptr_,
+                 base::Unretained(player_to_receive_animation), 0.000004));
+}
+
+void LayerTreeTest::PostAddInstantAnimationToMainThreadPlayer(
+    AnimationPlayer* player_to_receive_animation) {
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeTest::DispatchAddAnimationToPlayer,
+                 main_thread_weak_ptr_,
+                 base::Unretained(player_to_receive_animation), 0.0));
+}
+
+void LayerTreeTest::PostAddLongAnimationToMainThreadPlayer(
+    AnimationPlayer* player_to_receive_animation) {
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeTest::DispatchAddAnimationToPlayer,
+                 main_thread_weak_ptr_,
+                 base::Unretained(player_to_receive_animation), 1.0));
+}
+
 void LayerTreeTest::PostSetDeferCommitsToMainThread(bool defer_commits) {
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchSetDeferCommits,
                  main_thread_weak_ptr_, defer_commits));
 }
 
 void LayerTreeTest::PostSetNeedsCommitToMainThread() {
   main_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&LayerTreeTest::DispatchSetNeedsCommit,
@@ skipping 117 matching lines @@
 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, animation_duration, 0, 0.5, true);
   }
 }
 
+void LayerTreeTest::DispatchAddAnimationToPlayer(
+    AnimationPlayer* player_to_receive_animation,
+    double animation_duration) {
+  DCHECK(!proxy() || proxy()->IsMainThread());
+
+  if (player_to_receive_animation) {
+    AddOpacityTransitionToPlayer(player_to_receive_animation,
+                                 animation_duration, 0, 0.5, true);
+  }
+}
+
 void LayerTreeTest::DispatchSetDeferCommits(bool defer_commits) {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeTest::DispatchSetNeedsCommit() {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
@@ skipping 143 matching lines @@
 LayerTreeHost* LayerTreeTest::layer_tree_host() {
   // We check for a null proxy here as we sometimes ask for the layer tree host
   // when the proxy does not exist, often for checking settings after a test has
   // completed. For example, LTHPixelResourceTest::RunPixelResourceTest. See
   // elsewhere in this file for other examples.
   DCHECK(!proxy() || proxy()->IsMainThread() || proxy()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 }  // namespace cc