LayerTreeHost::SetAnimationEvents should use AnimationRegistrar

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "cc/animation/animation.h"
@@ skipping 37 matching lines @@
       contents_opaque_(false),
       double_sided_(true),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       force_render_surface_(false),
       replica_layer_(NULL),
       raster_scale_(1.f),
       automatically_compute_raster_scale_(false),
       bounds_contain_page_scale_(false),
-      layer_animation_delegate_(NULL),
       layer_scroll_client_(NULL) {
   if (layer_id_ < 0) {
     s_next_layer_id = 1;
     layer_id_ = s_next_layer_id++;
   }
 
   layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
-  layer_animation_controller_->AddObserver(this);
-  AddLayerAnimationEventObserver(layer_animation_controller_.get());
+  layer_animation_controller_->AddValueObserver(this);
 }
 
 Layer::~Layer() {
   // Our parent should be holding a reference to us so there should be no
   // way for us to be destroyed while we still have a parent.
   DCHECK(!parent());
 
-  layer_animation_controller_->RemoveObserver(this);
+  layer_animation_controller_->RemoveValueObserver(this);
 
   // Remove the parent reference from all children and dependents.
   RemoveAllChildren();
   if (mask_layer_) {
     DCHECK_EQ(this, mask_layer_->parent());
     mask_layer_->RemoveFromParent();
   }
   if (replica_layer_) {
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
   }
 }
 
 void Layer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host_ == host)
     return;
 
   layer_tree_host_ = host;
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SetLayerTreeHost(host);
 
   if (mask_layer_)
     mask_layer_->SetLayerTreeHost(host);
   if (replica_layer_)
     replica_layer_->SetLayerTreeHost(host);
 
-  layer_animation_controller_->SetAnimationRegistrar(
-      host ? host->animation_registrar() : NULL);
+  if (host) {
+    layer_animation_controller_->SetAnimationRegistrar(
+        host->animation_registrar());
+  }
 
   if (host && layer_animation_controller_->has_any_animation())
     host->SetNeedsCommit();
   if (host &&
       (!filters_.isEmpty() || !background_filters_.isEmpty() || filter_))
     layer_tree_host_->set_needs_filter_context();
 }
 
 void Layer::SetNeedsCommit() {
   if (ignore_set_needs_commit_)
@@ skipping 622 matching lines @@
 void Layer::PauseAnimation(int animation_id, double time_offset) {
   layer_animation_controller_->PauseAnimation(animation_id, time_offset);
   SetNeedsCommit();
 }
 
 void Layer::RemoveAnimation(int animation_id) {
   layer_animation_controller_->RemoveAnimation(animation_id);
   SetNeedsCommit();
 }
 
+void Layer::TransferAnimationsTo(Layer* layer) {
+  layer_animation_controller_->TransferAnimationsTo(
+      layer->layer_animation_controller());
+}
+
 void Layer::SuspendAnimations(double monotonic_time) {
   layer_animation_controller_->SuspendAnimations(monotonic_time);
   SetNeedsCommit();
 }
 
 void Layer::ResumeAnimations(double monotonic_time) {
   layer_animation_controller_->ResumeAnimations(monotonic_time);
   SetNeedsCommit();
 }
 
-void Layer::SetLayerAnimationController(
+void Layer::SetLayerAnimationControllerForTest(
     scoped_refptr<LayerAnimationController> controller) {
-  RemoveLayerAnimationEventObserver(layer_animation_controller_.get());
-  layer_animation_controller_->RemoveObserver(this);
+  layer_animation_controller_->RemoveValueObserver(this);
   layer_animation_controller_ = controller;
   layer_animation_controller_->set_force_sync();
-  layer_animation_controller_->AddObserver(this);
-  AddLayerAnimationEventObserver(layer_animation_controller_.get());
+  layer_animation_controller_->AddValueObserver(this);
   SetNeedsCommit();
 }
 
-scoped_refptr<LayerAnimationController>
-Layer::ReleaseLayerAnimationController() {
-  layer_animation_controller_->RemoveObserver(this);
-  scoped_refptr<LayerAnimationController> to_return =
-      layer_animation_controller_;
-  layer_animation_controller_ = LayerAnimationController::Create(id());
-  layer_animation_controller_->AddObserver(this);
-  layer_animation_controller_->SetAnimationRegistrar(
-      to_return->animation_registrar());
-  return to_return;
-}
-
 bool Layer::HasActiveAnimation() const {
   return layer_animation_controller_->HasActiveAnimation();
 }
 
-void Layer::NotifyAnimationStarted(const AnimationEvent& event,
-                                   double wall_clock_time) {
-  FOR_EACH_OBSERVER(LayerAnimationEventObserver, layer_animation_observers_,
-                    OnAnimationStarted(event));
-  if (layer_animation_delegate_)
-    layer_animation_delegate_->notifyAnimationStarted(wall_clock_time);
-}
-
-void Layer::NotifyAnimationFinished(double wall_clock_time) {
-  if (layer_animation_delegate_)
-    layer_animation_delegate_->notifyAnimationFinished(wall_clock_time);
-}
-
-void Layer::NotifyAnimationPropertyUpdate(const AnimationEvent& event) {
-  if (event.target_property == Animation::Opacity)
-    SetOpacity(event.opacity);
-  else
-    SetTransform(event.transform);
-}
-
 void Layer::AddLayerAnimationEventObserver(
     LayerAnimationEventObserver* animation_observer) {
-  if (!layer_animation_observers_.HasObserver(animation_observer))
-    layer_animation_observers_.AddObserver(animation_observer);
+  layer_animation_controller_->AddEventObserver(animation_observer);
 }
 
 void Layer::RemoveLayerAnimationEventObserver(
     LayerAnimationEventObserver* animation_observer) {
-  layer_animation_observers_.RemoveObserver(animation_observer);
+  layer_animation_controller_->RemoveEventObserver(animation_observer);
 }
 
 Region Layer::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return visible_content_rect();
   return Region();
 }
 
 ScrollbarLayer* Layer::ToScrollbarLayer() {
   return NULL;
 }
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 }  // namespace cc