CC Animations: Establish AnimationHost, AnimationTimeline and AnimationPlayer

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 44b21adf28012b42de61ff5649204e3a34025348..1f81e51c414f4bd6a866f5ca3eba94ac5b538eba 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -15,6 +15,7 @@
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ -227,6 +228,11 @@ LayerTreeHostImpl::LayerTreeHostImpl(
       requires_high_res_to_draw_(false),
       is_likely_to_require_a_draw_(false),
       frame_timing_tracker_(FrameTimingTracker::Create()) {
+  if (settings.use_compositor_animation_timelines) {
+    animation_host_ = AnimationHost::Create(true);
+    animation_host_->SetLayerTreeMutatorsClient(this);
+  }
+
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
   animation_registrar_->set_supports_scroll_animations(
@@ -3378,4 +3384,115 @@ bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
 
   return true;
 }
+
+bool LayerTreeHostImpl::IsLayerInActiveTree(int layer_id) const {
+  return active_tree() ? active_tree()->LayerById(layer_id) != nullptr : false;
+}
+
+bool LayerTreeHostImpl::IsLayerInPendingTree(int layer_id) const {
+  if (pending_tree() && pending_tree()->LayerById(layer_id))
+    return true;
+  if (recycle_tree() && recycle_tree()->LayerById(layer_id))
+    return true;
+
+  return false;
+}
+
+void LayerTreeHostImpl::SetMutatorsNeedCommit() {
+  SetNeedsCommit();
+}
+
+void LayerTreeHostImpl::SetTreeLayerFilterMutated(
+    int layer_id,
+    LayerTreeImpl* tree,
+    const FilterOperations& filters) {
+  if (!tree)
+    return;
+
+  LayerAnimationValueObserver* layer = tree->LayerById(layer_id);
+  if (layer)
+    layer->OnFilterAnimated(filters);
+}
+
+void LayerTreeHostImpl::SetTreeLayerOpacityMutated(int layer_id,
+                                                   LayerTreeImpl* tree,
+                                                   float opacity) {
+  if (!tree)
+    return;
+
+  LayerAnimationValueObserver* layer = tree->LayerById(layer_id);
+  if (layer)
+    layer->OnOpacityAnimated(opacity);
+}
+
+void LayerTreeHostImpl::SetTreeLayerTransformMutated(
+    int layer_id,
+    LayerTreeImpl* tree,
+    const gfx::Transform& transform) {
+  if (!tree)
+    return;
+
+  LayerAnimationValueObserver* layer = tree->LayerById(layer_id);
+  if (layer)
+    layer->OnTransformAnimated(transform);
+}
+
+void LayerTreeHostImpl::SetTreeLayerScrollOffsetMutated(
+    int layer_id,
+    LayerTreeImpl* tree,
+    const gfx::ScrollOffset& scroll_offset) {
+  if (!tree)
+    return;
+
+  LayerAnimationValueObserver* layer = tree->LayerById(layer_id);
+  if (layer)
+    layer->OnScrollOffsetAnimated(scroll_offset);
+}
+
+void LayerTreeHostImpl::SetLayerFilterMutated(int layer_id,
+                                              bool affects_active_tree,
+                                              const FilterOperations& filters) {
+  if (affects_active_tree) {
+    SetTreeLayerFilterMutated(layer_id, active_tree(), filters);
+  } else {
+    SetTreeLayerFilterMutated(layer_id, pending_tree(), filters);
+    SetTreeLayerFilterMutated(layer_id, recycle_tree(), filters);
+  }
+}
+
+void LayerTreeHostImpl::SetLayerOpacityMutated(int layer_id,
+                                               bool affects_active_tree,
+                                               float opacity) {
+  if (affects_active_tree) {

[ajuma, 2015/04/22 15:47:18]

This logic doesn't seem to handle the case where an animation affects both the
pending tree and the active tree. Once an animation starts affecting the active
tree, it should continue affecting the pending tree too, until it finishes or is
removed during a commit.

[loyso (OOO), 2015/04/30 06:40:21]

Each cc::AnimationPlayer has up to two AnimationPlayer::ValueObservers.
SetLayerOpacityMutated is called twice with affects_active_tree as true/false.

[ajuma, 2015/04/30 13:17:53]

Ah, ok, that makes sense. But I'm not seeing how these ValueObservers are
created/destroyed at tree activation time, which part should I look at for this?
Thanks for bearing with me here :)

[loyso (OOO), 2015/05/01 00:46:55]

No worries. That's a key detail.
AnimationPlayer receives notification on active OR pending LayerImpl creation.
(see AnimationPlayer::LayerRegistered, AnimationPlayer::LayerUnregistered). This
completely mimics the old behavior with the LAC and observers creation in the
LayerImpl constructor.

[ajuma, 2015/05/01 14:45:40]

Thanks for the explanation. Just to make sure I understand,
LayerAnimationController will still be responsible for using the
affects_active_observers_ and affects_pending_observers_ bools on each Animation
to decide which AnimationPlayer::ValueObservers get notified (in
LAC::NotifyObservers*Animated)?

+    SetTreeLayerOpacityMutated(layer_id, active_tree(), opacity);
+  } else {
+    SetTreeLayerOpacityMutated(layer_id, pending_tree(), opacity);
+    SetTreeLayerOpacityMutated(layer_id, recycle_tree(), opacity);
+  }
+}
+
+void LayerTreeHostImpl::SetLayerTransformMutated(
+    int layer_id,
+    bool affects_active_tree,
+    const gfx::Transform& transform) {
+  if (affects_active_tree) {
+    SetTreeLayerTransformMutated(layer_id, active_tree(), transform);
+  } else {
+    SetTreeLayerTransformMutated(layer_id, pending_tree(), transform);
+    SetTreeLayerTransformMutated(layer_id, recycle_tree(), transform);
+  }
+}
+
+void LayerTreeHostImpl::SetLayerScrollOffsetMutated(
+    int layer_id,
+    bool affects_active_tree,
+    const gfx::ScrollOffset& scroll_offset) {
+  if (affects_active_tree) {
+    SetTreeLayerScrollOffsetMutated(layer_id, active_tree(), scroll_offset);
+  } else {
+    SetTreeLayerScrollOffsetMutated(layer_id, pending_tree(), scroll_offset);
+    SetTreeLayerScrollOffsetMutated(layer_id, recycle_tree(), scroll_offset);
+  }
+}
+
 }  // namespace cc