Explicit animation support

ui/gfx/compositor/layer.cc

 // Copyright (c) 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 "ui/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation.h"
-#include "ui/gfx/compositor/layer_animator.h"
+#include "ui/gfx/compositor/layer_animation_manager.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/point3.h"
 
 namespace {
 
 const float EPSILON = 1e-3f;
 
 bool IsApproximateMultilpleOf(float value, float base) {
   float remainder = fmod(fabs(value), base);
@@ skipping 79 matching lines @@
   for (const Layer* parent = other; parent; parent = parent->parent()) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
 void Layer::SetAnimation(Animation* animation) {
   if (animation) {
     if (!animator_.get())
-      animator_.reset(new LayerAnimator(this));
+      animator_.reset(new LayerAnimationManager(this));
     animation->Start();
     animator_->SetAnimation(animation);
   } else {
     animator_.reset();
   }
 }
 
 void Layer::SetTransform(const ui::Transform& transform) {
-  StopAnimatingIfNecessary(LayerAnimator::TRANSFORM);
+  StopAnimatingIfNecessary(LayerAnimationManager::TRANSFORM);
   if (animator_.get() && animator_->IsRunning()) {
     animator_->AnimateTransform(transform);
     return;
   }
   SetTransformImmediately(transform);
 }
 
 void Layer::SetBounds(const gfx::Rect& bounds) {
-  StopAnimatingIfNecessary(LayerAnimator::LOCATION);
+  StopAnimatingIfNecessary(LayerAnimationManager::LOCATION);
   if (animator_.get() && animator_->IsRunning() &&
       bounds.size() == bounds_.size()) {
     animator_->AnimateToPoint(bounds.origin());
     return;
   }
   SetBoundsImmediately(bounds);
 }
 
 gfx::Rect Layer::GetTargetBounds() const {
   if (animator_.get() && animator_->IsRunning())
     return gfx::Rect(animator_->GetTargetPoint(), bounds_.size());
   return bounds_;
 }
 
 void Layer::SetOpacity(float opacity) {
-  StopAnimatingIfNecessary(LayerAnimator::OPACITY);
+  StopAnimatingIfNecessary(LayerAnimationManager::OPACITY);
   if (animator_.get() && animator_->IsRunning()) {
     animator_->AnimateOpacity(opacity);
     return;
   }
   SetOpacityImmediately(opacity);
 }
 
 void Layer::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
@@ skipping 275 matching lines @@
   for (; p && p != ancestor; p = p->parent()) {
     if (p->transform().HasChange())
       transform->ConcatTransform(p->transform());
     transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
                                static_cast<float>(p->bounds().y()));
   }
   return p == ancestor;
 }
 
 void Layer::StopAnimatingIfNecessary(
-    LayerAnimator::AnimationProperty property) {
+    LayerAnimationManager::AnimationProperty property) {
   if (!animator_.get() || !animator_->IsRunning() ||
       !animator_->got_initial_tick()) {
     return;
   }
 
-  if (property != LayerAnimator::LOCATION &&
-      animator_->IsAnimating(LayerAnimator::LOCATION)) {
+  if (property != LayerAnimationManager::LOCATION &&
+      animator_->IsAnimating(LayerAnimationManager::LOCATION)) {
     SetBoundsImmediately(
         gfx::Rect(animator_->GetTargetPoint(), bounds_.size()));
   }
-  if (property != LayerAnimator::OPACITY &&
-      animator_->IsAnimating(LayerAnimator::OPACITY)) {
+  if (property != LayerAnimationManager::OPACITY &&
+      animator_->IsAnimating(LayerAnimationManager::OPACITY)) {
     SetOpacityImmediately(animator_->GetTargetOpacity());
   }
-  if (property != LayerAnimator::TRANSFORM &&
-      animator_->IsAnimating(LayerAnimator::TRANSFORM)) {
+  if (property != LayerAnimationManager::TRANSFORM &&
+      animator_->IsAnimating(LayerAnimationManager::TRANSFORM)) {
     SetTransformImmediately(animator_->GetTargetTransform());
   }
   animator_.reset();
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
   if (parent())
     parent()->RecomputeHole();
@@ skipping 34 matching lines @@
 
 void Layer::SetTransformFromAnimator(const Transform& transform) {
   SetTransformImmediately(transform);
 }
 
 void Layer::SetOpacityFromAnimator(float opacity) {
   SetOpacityImmediately(opacity);
 }
 
 }  // namespace ui