CC Animations: Establish AnimationHost, AnimationTimeline and AnimationPlayer

cc/trees/layer_tree_host.cc

Index: cc/trees/layer_tree_host.cc
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index f4780789394c447a1b3a56cfb5925ef325dec6a1..f4e4309d60f05003db55a05d0342498010c0081b 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -18,6 +18,7 @@
 #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"
@@ -296,6 +297,9 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   sync_tree->set_source_frame_number(source_frame_number());
 
   if (needs_full_tree_sync_) {
+    host_impl->SetAnimationTimeline(
+        animation_timeline_ ? AnimationTimeline::Create() : nullptr);
+
     sync_tree->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
         root_layer(), sync_tree->DetachLayerTree(), sync_tree));
   }
@@ -369,6 +373,11 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   {
     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);
@@ -579,6 +588,18 @@ void LayerTreeHost::SetAnimationEvents(
   }
 }
 
+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;
@@ -1376,4 +1397,51 @@ void LayerTreeHost::SendBeginFramesToChildren(
   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();
+}
+
+void LayerTreeHost::SetMutatorsNeedCommit() {
+  SetNeedsCommit();
+}
+
+void LayerTreeHost::SetLayerFilterMutated(int layer_id,
+                                          bool active_tree,
+                                          const FilterOperations& filters) {
+  LayerAnimationValueObserver* layer = LayerById(layer_id);
+  if (layer)

[ajuma, 2015/02/23 16:36:44]

In what situation would |layer| be null here? Should this be a DCHECK instead?

[loyso (OOO), 2015/02/25 04:37:03]

Active tree is a 'passive' view of pending tree. Object creation/deletion
updates propagate from main tree to impl pending tree to impl active tree in
non-deterministic way. We don't notify external mutators on all those multiple
copies of the entity. That's the decoupling point.

We could refine it at later stages, though. Via introduction of some sort of
proxy-layer object so we can keep weak references externally.

[ajuma, 2015/02/25 14:57:25]

I'm not sure I follow. LayerTreeHost is the main-thread side, so there is only a
single tree, not an active/pending pair. An external mutator trying to animate a
layer that no longer exists on the main thread seems like a bug at first glance.
Could you write a unit test (probably a LayerTreeHostAnimationTest) that fails
when this 'if' is changed to a DCHECK?

More generally, mutators cannot be ignorant of the progress of updates from the
main thread to the pending tree and then to the active tree, since we need to
preserve the atomicity of updates. For example, if some javascript code triggers
an animation and at the same time makes other changes to the page, the animation
must start at the same time as the other changes appear on screen.

[loyso (OOO), 2015/02/26 03:04:45]

Oh, sorry. I was commenting with LayerTreeHostImpl in mind. Yes, we need DCHECK
here.
 
We use needs_synchronized_start_time flag for that, don't we? Any other cases?

[ajuma, 2015/02/26 14:16:31]

needs_synchronized_start_time means "use the compositor's start time". It's
unrelated to ensuring that animations added during a commit don't start until
tree activation (rather than starting immediately after the commit). The logic
to ensure that animations propagate in-sync with tree activation is implemented
using the affects_active_observers and affects_pending_observers logic in
animation.cc and layer_animation_controller.cc. The comment at
https://code.google.com/p/chromium/codesearch#chromium/src/cc/animation/anima...
has a brief description of this logic.

[loyso (OOO), 2015/02/27 02:45:17]

Thank you so much Ali for pointing out that important issue. See the PatchSet#3
- AnimationPlayer now knows about layer tree activation.

+    layer->OnFilterAnimated(filters);
+}
+
+void LayerTreeHost::SetLayerOpacityMutated(int layer_id,
+                                           bool active_tree,
+                                           float opacity) {
+  LayerAnimationValueObserver* layer = LayerById(layer_id);
+  if (layer)
+    layer->OnOpacityAnimated(opacity);
+}
+
+void LayerTreeHost::SetLayerTransformMutated(int layer_id,
+                                             bool active_tree,
+                                             const gfx::Transform& transform) {
+  LayerAnimationValueObserver* layer = LayerById(layer_id);
+  if (layer)
+    layer->OnTransformAnimated(transform);
+}
+
 }  // namespace cc