CC Animations: Redirect all compositor animation requests to AnimationHost.

cc/trees/layer_tree_host.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/trees/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 103 matching lines @@
       did_complete_scale_animation_(false),
       in_paint_layer_contents_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(params->shared_bitmap_manager),
       gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
       task_graph_runner_(params->task_graph_runner),
       surface_id_namespace_(0u),
       next_surface_sequence_(1u) {
   DCHECK(task_graph_runner_);
-  if (settings_.accelerated_animation_enabled)
-    animation_registrar_ = AnimationRegistrar::Create();
+
+  if (settings_.accelerated_animation_enabled) {
+    if (settings_.use_compositor_animation_timelines) {
+      animation_host_ = AnimationHost::Create(ThreadInstance::MAIN);
+      animation_host_->SetMutatorHostClient(this);
+    } else {
+      animation_registrar_ = AnimationRegistrar::Create();
+    }
+  }
+
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
-
-  if (settings_.use_compositor_animation_timelines) {
-    animation_host_ = AnimationHost::Create(ThreadInstance::MAIN);
-    animation_host_->SetMutatorHostClient(this);
-  }
 }
 
 void LayerTreeHost::InitializeThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   InitializeProxy(ThreadProxy::Create(this,
                                       main_task_runner,
                                       impl_task_runner,
                                       external_begin_frame_source.Pass()));
@@ skipping 13 matching lines @@
 void LayerTreeHost::InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing) {
   InitializeProxy(proxy_for_testing.Pass());
 }
 
 void LayerTreeHost::InitializeProxy(scoped_ptr<Proxy> proxy) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
 
   proxy_ = proxy.Pass();
   proxy_->Start();
   if (settings_.accelerated_animation_enabled) {
-    animation_registrar_->set_supports_scroll_animations(
-        proxy_->SupportsImplScrolling());
+    if (animation_host_)
+      animation_host_->SetSupportsScrollAnimations(
+          proxy_->SupportsImplScrolling());
+    else
+      animation_registrar_->set_supports_scroll_animations(
+          proxy_->SupportsImplScrolling());
   }
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
 
   if (animation_host_)
     animation_host_->SetMutatorHostClient(nullptr);
 
   if (root_layer_.get())
@@ skipping 328 matching lines @@
   proxy_->SetNextCommitWaitsForActivation();
 }
 
 void LayerTreeHost::SetNextCommitForcesRedraw() {
   next_commit_forces_redraw_ = true;
 }
 
 void LayerTreeHost::SetAnimationEvents(
     scoped_ptr<AnimationEventsVector> events) {
   DCHECK(proxy_->IsMainThread());
-  animation_registrar_->SetAnimationEvents(events.Pass());
+  if (animation_host_)
+    animation_host_->SetAnimationEvents(events.Pass());
+  else
+    animation_registrar_->SetAnimationEvents(events.Pass());
 }
 
 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
   if (root_layer_.get() == root_layer.get())
     return;
 
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
   root_layer_ = root_layer;
   if (root_layer_.get()) {
@@ skipping 387 matching lines @@
                  constraints,
                  current,
                  animate));
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
   AnimationEventsVector events;
-  if (animation_registrar_->AnimateLayers(monotonic_time)) {
-    animation_registrar_->UpdateAnimationState(true, &events);
-    if (!events.empty())
-      property_trees_.needs_rebuild = true;
+  if (animation_host_) {
+    if (animation_host_->AnimateLayers(monotonic_time))
+      animation_host_->UpdateAnimationState(true, &events);
+  } else {
+    if (animation_registrar_->AnimateLayers(monotonic_time))
+      animation_registrar_->UpdateAnimationState(true, &events);
   }
+
+  if (!events.empty())
+    property_trees_.needs_rebuild = true;
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
   DCHECK(client);
 
   UIResourceId next_id = next_ui_resource_id_++;
   DCHECK(ui_resource_client_map_.find(next_id) ==
          ui_resource_client_map_.end());
 
   bool resource_lost = false;
@@ skipping 188 matching lines @@
 
 void LayerTreeHost::SetLayerScrollOffsetMutated(
     int layer_id,
     LayerTreeType tree_type,
     const gfx::ScrollOffset& scroll_offset) {
   LayerAnimationValueObserver* layer = LayerById(layer_id);
   DCHECK(layer);
   layer->OnScrollOffsetAnimated(scroll_offset);
 }
 
+bool LayerTreeHost::ScrollOffsetAnimationWasInterrupted(
+    const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->ScrollOffsetAnimationWasInterrupted(layer->id())
+             : false;
+}
+
+bool LayerTreeHost::IsAnimatingFilterProperty(const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->IsAnimatingFilterProperty(layer->id())
+             : false;
+}
+
+bool LayerTreeHost::IsAnimatingOpacityProperty(const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->IsAnimatingOpacityProperty(layer->id())
+             : false;
+}
+
+bool LayerTreeHost::IsAnimatingTransformProperty(const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->IsAnimatingTransformProperty(layer->id())
+             : false;
+}
+
+bool LayerTreeHost::HasPotentiallyRunningOpacityAnimation(
+    const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->HasPotentiallyRunningOpacityAnimation(
+                   layer->id())
+             : false;
+}
+
+bool LayerTreeHost::HasPotentiallyRunningTransformAnimation(
+    const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->HasPotentiallyRunningTransformAnimation(
+                   layer->id())
+             : false;
+}
+
+bool LayerTreeHost::AnimationsPreserveAxisAlignment(const Layer* layer) const {
+  return animation_host_
+             ? animation_host_->AnimationsPreserveAxisAlignment(layer->id())
+             : true;
+}
+
+bool LayerTreeHost::HasAnyAnimation(const Layer* layer) const {
+  return animation_host_ ? animation_host_->HasAnyAnimation(layer->id())
+                         : false;
+}
+
+bool LayerTreeHost::HasActiveAnimation(const Layer* layer) const {
+  return animation_host_ ? animation_host_->HasActiveAnimation(layer->id())
+                         : false;
+}
+
 }  // namespace cc