CC Animations: Redirect all compositor animation requests to AnimationHost.

cc/layers/layer_utils.cc

 // Copyright 2014 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_utils.h"
 
 #include "cc/layers/layer_impl.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "ui/gfx/geometry/box_f.h"
 
 namespace cc {
 
 namespace {
 
 bool HasAnimationThatInflatesBounds(const LayerImpl& layer) {
-  return layer.layer_animation_controller()->HasAnimationThatInflatesBounds();
+  return layer.HasAnimationThatInflatesBounds();
 }
 
 bool HasFilterAnimationThatInflatesBounds(const LayerImpl& layer) {
-  return layer.layer_animation_controller()
-      ->HasFilterAnimationThatInflatesBounds();
+  return layer.HasFilterAnimationThatInflatesBounds();
 }
 
 bool HasTransformAnimationThatInflatesBounds(const LayerImpl& layer) {
-  return layer.layer_animation_controller()
-      ->HasTransformAnimationThatInflatesBounds();
+  return layer.HasTransformAnimationThatInflatesBounds();
 }
 
 inline bool HasAncestorTransformAnimation(const LayerImpl& layer) {
   return layer.screen_space_transform_is_animating();
 }
 
 inline bool HasAncestorFilterAnimation(const LayerImpl& layer) {
   for (const LayerImpl* current = &layer; current;
        current = current->parent()) {
     if (HasFilterAnimationThatInflatesBounds(*current))
@@ skipping 68 matching lines @@
 
     // We need to apply the inflation about the layer's anchor point. Rather
     // than doing this via transforms, we'll just shift the box directly.
     box.set_origin(box.origin() + gfx::Vector3dF(-transform_origin_x,
                                                  -transform_origin_y,
                                                  -transform_origin_z));
 
     // Perform the inflation
     if (HasFilterAnimationThatInflatesBounds(*layer)) {
       gfx::BoxF inflated;
-      if (!layer->layer_animation_controller()->FilterAnimationBoundsForBox(
-              box, &inflated))
+      if (!layer->FilterAnimationBoundsForBox(box, &inflated))
         return false;
       box = inflated;
     }
 
     if (HasTransformAnimationThatInflatesBounds(*layer)) {
       gfx::BoxF inflated;
-      if (!layer->layer_animation_controller()->TransformAnimationBoundsForBox(
-              box, &inflated))
+      if (!layer->TransformAnimationBoundsForBox(box, &inflated))
         return false;
       box = inflated;
     }
 
     // Apply step 3) mentioned above.
     box.set_origin(box.origin() +
                    gfx::Vector3dF(transform_origin_x + position.x(),
                                   transform_origin_y + position.y(),
                                   transform_origin_z));
   }
 
   // If we've got an unapplied coalesced transform at this point, it must still
   // be applied.
   if (!coalesced_transform.IsIdentity())
     coalesced_transform.TransformBox(&box);
 
   *out = box;
 
   return true;
 }
 
 }  // namespace cc