CC Animations: Establish AnimationHost, AnimationTimeline and AnimationPlayer

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>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_registrar.h"
+#include "cc/animation/animation_timeline.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
@@ skipping 257 matching lines @@
   LayerTreeImpl* sync_tree = host_impl->sync_tree();
 
   if (next_commit_forces_redraw_) {
     sync_tree->ForceRedrawNextActivation();
     next_commit_forces_redraw_ = false;
   }
 
   sync_tree->set_source_frame_number(source_frame_number());
 
   if (needs_full_tree_sync_) {
+    scoped_refptr<AnimationTimeline> timeline_impl;
+    if (animation_timeline_) {
+      timeline_impl = host_impl->animation_timeline();
+      if (!timeline_impl)
+        timeline_impl = AnimationTimeline::Create();
+    }
+    host_impl->SetAnimationTimeline(timeline_impl);
+
     sync_tree->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
         root_layer(), sync_tree->DetachLayerTree(), sync_tree));
   }
   sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
   needs_full_tree_sync_ = false;
 
   if (hud_layer_.get()) {
     LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
         sync_tree->root_layer(), hud_layer_->id());
     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
@@ skipping 53 matching lines @@
   if (new_impl_tree_has_no_evicted_resources) {
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
   sync_tree->set_has_ever_been_drawn(false);
 
   {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
     TreeSynchronizer::PushProperties(root_layer(), sync_tree->root_layer());
+
+    if (animation_timeline_) {
+      DCHECK(host_impl->animation_timeline());
+      animation_timeline_->PushPropertiesTo(host_impl->animation_timeline());
+    }
   }
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
 }
 
 void LayerTreeHost::WillCommit() {
   client_->WillCommit();
 }
 
 void LayerTreeHost::UpdateHudLayer() {
@@ skipping 162 matching lines @@
 void LayerTreeHost::SetNextCommitForcesRedraw() {
   next_commit_forces_redraw_ = true;
 }
 
 void LayerTreeHost::SetAnimationEvents(
     scoped_ptr<AnimationEventsVector> events) {
   DCHECK(proxy_->IsMainThread());
   animation_registrar_->SetAnimationEvents(events.Pass());
 }
 
+void LayerTreeHost::SetAnimationTimeline(
+    scoped_refptr<AnimationTimeline> timeline) {
+  if (animation_timeline_.get() == timeline.get())
+    return;
+
+  if (animation_timeline_.get())
+    animation_timeline_->SetLayerTreeMutatorsClient(nullptr);
+  animation_timeline_ = timeline;
+  if (animation_timeline_.get())
+    animation_timeline_->SetLayerTreeMutatorsClient(this);
+}
+
 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()) {
     DCHECK(!root_layer_->parent());
     root_layer_->SetLayerTreeHost(this);
@@ skipping 719 matching lines @@
 void LayerTreeHost::SetChildrenNeedBeginFrames(
     bool children_need_begin_frames) const {
   proxy_->SetChildrenNeedBeginFrames(children_need_begin_frames);
 }
 
 void LayerTreeHost::SendBeginFramesToChildren(
     const BeginFrameArgs& args) const {
   client_->SendBeginFramesToChildren(args);
 }
 
+Layer* LayerTreeHost::LayerById(int id) const {
+  LayerIdMap::const_iterator iter = layer_id_map_.find(id);
+  return iter != layer_id_map_.end() ? iter->second : NULL;
+}
+
+void LayerTreeHost::RegisterLayer(Layer* layer) {
+  DCHECK(!LayerById(layer->id()));
+  layer_id_map_[layer->id()] = layer;
+}
+
+void LayerTreeHost::UnregisterLayer(Layer* layer) {
+  DCHECK(LayerById(layer->id()));
+  layer_id_map_.erase(layer->id());
+}
+
+AnimationRegistrar* LayerTreeHost::GetAnimationRegistrar() const {
+  return animation_registrar_.get();
+}
+
+bool LayerTreeHost::IsLayerInActiveTree(int layer_id) const {
+  return true;
+}
+
+bool LayerTreeHost::IsLayerInPendingTree(int layer_id) const {
+  return false;
+}
+
+void LayerTreeHost::SetMutatorsNeedCommit() {
+  SetNeedsCommit();
+}
+
+void LayerTreeHost::SetLayerFilterMutated(int layer_id,
+                                          bool active_tree,
+                                          const FilterOperations& filters) {
+  LayerAnimationValueObserver* layer = LayerById(layer_id);
+  DCHECK(layer);
+  layer->OnFilterAnimated(filters);
+}
+
+void LayerTreeHost::SetLayerOpacityMutated(int layer_id,
+                                           bool active_tree,
+                                           float opacity) {
+  LayerAnimationValueObserver* layer = LayerById(layer_id);
+  DCHECK(layer);
+  layer->OnOpacityAnimated(opacity);
+}
+
+void LayerTreeHost::SetLayerTransformMutated(int layer_id,
+                                             bool active_tree,
+                                             const gfx::Transform& transform) {
+  LayerAnimationValueObserver* layer = LayerById(layer_id);
+  DCHECK(layer);
+  layer->OnTransformAnimated(transform);
+}
+
 }  // namespace cc