CC Animation: Make AnimationRegistrar a private member of AnimationHost.

cc/animation/element_animations.cc

 // Copyright 2015 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/animation/element_animations.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_player.h"
-#include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/trees/mutator_host_client.h"
 
 namespace cc {
 
 class ElementAnimations::ValueObserver : public LayerAnimationValueObserver {
  public:
   ValueObserver(ElementAnimations* element_animation, LayerTreeType tree_type)
       : element_animations_(element_animation), tree_type_(tree_type) {
     DCHECK(element_animations_);
@@ skipping 47 matching lines @@
 
 ElementAnimations::~ElementAnimations() {
   DCHECK(!layer_animation_controller_);
 }
 
 void ElementAnimations::CreateLayerAnimationController(int layer_id) {
   DCHECK(layer_id);
   DCHECK(!layer_animation_controller_);
   DCHECK(animation_host_);
 
-  AnimationRegistrar* registrar = animation_host_->animation_registrar();
-  DCHECK(registrar);
-
   layer_animation_controller_ =
-      registrar->GetAnimationControllerForId(layer_id);
-  layer_animation_controller_->SetAnimationRegistrar(registrar);
+      animation_host_->GetAnimationControllerForId(layer_id);
+  animation_host_->SetAnimationRegistrarFor(layer_animation_controller_);
   layer_animation_controller_->set_layer_animation_delegate(this);
   layer_animation_controller_->set_value_provider(this);
 
   DCHECK(animation_host_->mutator_host_client());
   if (animation_host_->mutator_host_client()->IsLayerInTree(
           layer_id, LayerTreeType::ACTIVE))
     CreateActiveValueObserver();
   if (animation_host_->mutator_host_client()->IsLayerInTree(
           layer_id, LayerTreeType::PENDING))
     CreatePendingValueObserver();
 }
 
 void ElementAnimations::DestroyLayerAnimationController() {
   DCHECK(animation_host_);
 
   if (active_value_observer_)
     SetTransformIsPotentiallyAnimatingChanged(LayerTreeType::ACTIVE, false);
   if (pending_value_observer_)
     SetTransformIsPotentiallyAnimatingChanged(LayerTreeType::PENDING, false);
 
   DestroyPendingValueObserver();
   DestroyActiveValueObserver();
 
   if (layer_animation_controller_) {
     layer_animation_controller_->remove_value_provider(this);
     layer_animation_controller_->remove_layer_animation_delegate(this);
-    layer_animation_controller_->SetAnimationRegistrar(nullptr);
+    animation_host_->ResetAnimationRegistrarFor(layer_animation_controller_);
     layer_animation_controller_ = nullptr;
   }
 }
 
 void ElementAnimations::LayerRegistered(int layer_id, LayerTreeType tree_type) {
   DCHECK(layer_animation_controller_);
   DCHECK_EQ(layer_animation_controller_->id(), layer_id);
 
   if (tree_type == LayerTreeType::ACTIVE) {
     if (!active_value_observer_)
@@ skipping 171 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         layer_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc