Revert of Moving background animation ticking from LayerTreeHostImpl into the Scheduler.

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 35 matching lines @@
 
 void TestHooks::CreateResourceAndRasterWorkerPool(
     LayerTreeHostImpl* host_impl,
     scoped_ptr<RasterWorkerPool>* raster_worker_pool,
     scoped_ptr<ResourcePool>* resource_pool,
     scoped_ptr<ResourcePool>* staging_resource_pool) {
   host_impl->LayerTreeHostImpl::CreateResourceAndRasterWorkerPool(
       raster_worker_pool, resource_pool, staging_resource_pool);
 }
 
+base::TimeDelta TestHooks::LowFrequencyAnimationInterval() const {
+  return base::TimeDelta::FromMilliseconds(16);
+}
+
 // Adapts ThreadProxy for test. Injects test hooks for testing.
 class ThreadProxyForTest : public ThreadProxy {
  public:
   static scoped_ptr<Proxy> Create(
       TestHooks* test_hooks,
       LayerTreeHost* host,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     return make_scoped_ptr(new ThreadProxyForTest(
         test_hooks, host, main_task_runner, impl_task_runner));
@@ skipping 192 matching lines @@
         active_animation_controllers().begin();
     for (; iter != active_animation_controllers().end(); ++iter) {
       if (iter->second->HasActiveAnimation()) {
         has_unfinished_animation = true;
         break;
       }
     }
     test_hooks_->UpdateAnimationState(this, has_unfinished_animation);
   }
 
+  base::TimeDelta LowFrequencyAnimationInterval() const override {
+    return test_hooks_->LowFrequencyAnimationInterval();
+  }
+
  private:
   TestHooks* test_hooks_;
   bool block_notify_ready_to_activate_for_testing_;
   bool notify_ready_to_activate_was_blocked_;
 };
 
 // Implementation of LayerTreeHost callback interface.
 class LayerTreeHostClientForTesting : public LayerTreeHostClient,
                                       public LayerTreeHostSingleThreadClient {
  public:
@@ skipping 382 matching lines @@
     ASSERT_TRUE(impl_thread_->Start());
   }
 
   main_task_runner_ = base::MessageLoopProxy::current();
 
   delegating_renderer_ = delegating_renderer;
 
   // Spend less time waiting for BeginFrame because the output is
   // mocked out.
   settings_.refresh_rate = 200.0;
-  settings_.background_animation_rate = 200.0;
   settings_.impl_side_painting = impl_side_painting;
   InitializeSettings(&settings_);
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   if (timeout_seconds_) {
     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
     main_task_runner_->PostDelayedTask(
@@ skipping 58 matching lines @@
   return -1;
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_ = nullptr;
 }
 
 }  // namespace cc