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 258 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_) {
+    host_impl->SetAnimationTimeline(
+        animation_timeline_ ? AnimationTimeline::Create() : nullptr);
+
     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 190 matching lines @@
           break;
 
         case AnimationEvent::PropertyUpdate:
           (*iter).second->NotifyAnimationPropertyUpdate((*events)[event_index]);
           break;
       }
     }
   }
 }
 
+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 777 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();
+}
+
+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