Explicit animation support

ui/gfx/compositor/layer_animation_manager.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_animator.h"
+#include "ui/gfx/compositor/layer_animation_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/base/animation/animation.h"
 #include "ui/base/animation/tween.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animator_delegate.h"
 #include "ui/gfx/transform.h"
@@ skipping 10 matching lines @@
 SkMScalar GetMatrixElement(const SkMatrix44& matrix, int index) {
   int row = index / 4;
   int col = index % 4;
   return matrix.get(row, col);
 }
 
 } // anonymous namespace
 
 namespace ui {
 
-LayerAnimator::LayerAnimator(Layer* layer)
+LayerAnimationManager::LayerAnimationManager(Layer* layer)
     : layer_(layer),
       got_initial_tick_(false) {
 }
 
-LayerAnimator::~LayerAnimator() {
+LayerAnimationManager::~LayerAnimationManager() {
 }
 
-void LayerAnimator::SetAnimation(Animation* animation) {
+void LayerAnimationManager::SetAnimation(Animation* animation) {
   animation_.reset(animation);
   if (animation_.get()) {
     static ui::AnimationContainer* container = NULL;
     if (!container) {
       container = new AnimationContainer;
       container->AddRef();
     }
     animation_->set_delegate(this);
     animation_->SetContainer(container);
     got_initial_tick_ = false;
   }
 }
 
-void LayerAnimator::AnimateToPoint(const gfx::Point& target) {
+void LayerAnimationManager::AnimateToPoint(const gfx::Point& target) {
   StopAnimating(LOCATION);
   const gfx::Rect& layer_bounds = layer_->bounds();
   if (target == layer_bounds.origin())
     return;  // Already there.
 
   Params& element = elements_[LOCATION];
   element.location.target_x = target.x();
   element.location.target_y = target.y();
   element.location.start_x = layer_bounds.origin().x();
   element.location.start_y = layer_bounds.origin().y();
 }
 
-void LayerAnimator::AnimateTransform(const Transform& transform) {
+void LayerAnimationManager::AnimateTransform(const Transform& transform) {
   StopAnimating(TRANSFORM);
   const Transform& layer_transform = layer_->transform();
   if (transform == layer_transform)
     return;  // Already there.
 
   Params& element = elements_[TRANSFORM];
   for (int i = 0; i < 16; ++i) {
     element.transform.start[i] =
         GetMatrixElement(layer_transform.matrix(), i);
     element.transform.target[i] =
         GetMatrixElement(transform.matrix(), i);
   }
 }
 
-void LayerAnimator::AnimateOpacity(float target_opacity) {
+void LayerAnimationManager::AnimateOpacity(float target_opacity) {
   StopAnimating(OPACITY);
   if (layer_->opacity() == target_opacity)
     return;
 
   Params& element = elements_[OPACITY];
   element.opacity.start = layer_->opacity();
   element.opacity.target = target_opacity;
 }
 
-gfx::Point LayerAnimator::GetTargetPoint() {
+gfx::Point LayerAnimationManager::GetTargetPoint() {
   return IsAnimating(LOCATION) ?
       gfx::Point(elements_[LOCATION].location.target_x,
                  elements_[LOCATION].location.target_y) :
       layer_->bounds().origin();
 }
 
-float LayerAnimator::GetTargetOpacity() {
+float LayerAnimationManager::GetTargetOpacity() {
   return IsAnimating(OPACITY) ?
       elements_[OPACITY].opacity.target : layer_->opacity();
 }
 
-ui::Transform LayerAnimator::GetTargetTransform() {
+ui::Transform LayerAnimationManager::GetTargetTransform() {
   if (IsAnimating(TRANSFORM)) {
     Transform transform;
     for (int i = 0; i < 16; ++i) {
       SetMatrixElement(transform.matrix(), i,
                        elements_[TRANSFORM].transform.target[i]);
     }
     return transform;
   }
   return layer_->transform();
 }
 
-bool LayerAnimator::IsAnimating(AnimationProperty property) const {
+bool LayerAnimationManager::IsAnimating(AnimationProperty property) const {
   return elements_.count(property) > 0;
 }
 
-bool LayerAnimator::IsRunning() const {
+bool LayerAnimationManager::IsRunning() const {
   return animation_.get() && animation_->is_animating();
 }
 
-void LayerAnimator::AnimationProgressed(const ui::Animation* animation) {
+void LayerAnimationManager::AnimationProgressed(
+    const ui::Animation* animation) {
   got_initial_tick_ = true;
   for (Elements::const_iterator i = elements_.begin(); i != elements_.end();
        ++i) {
     switch (i->first) {
       case LOCATION: {
         const gfx::Rect& current_bounds(layer_->bounds());
         gfx::Rect new_bounds = animation_->CurrentValueBetween(
             gfx::Rect(gfx::Point(i->second.location.start_x,
                                  i->second.location.start_y),
                       current_bounds.size()),
@@ skipping 22 matching lines @@
         break;
       }
 
       default:
         NOTREACHED();
     }
   }
   layer_->ScheduleDraw();
 }
 
-void LayerAnimator::AnimationEnded(const ui::Animation* animation) {
+void LayerAnimationManager::AnimationEnded(const ui::Animation* animation) {
   AnimationProgressed(animation);
-  if (layer_->delegate())
-    layer_->delegate()->OnLayerAnimationEnded(animation);
 }
 
-void LayerAnimator::StopAnimating(AnimationProperty property) {
+void LayerAnimationManager::StopAnimating(AnimationProperty property) {
   if (!IsAnimating(property))
     return;
 
   elements_.erase(property);
 }
 
-LayerAnimatorDelegate* LayerAnimator::delegate() {
+LayerAnimatorDelegate* LayerAnimationManager::delegate() {
   return static_cast<LayerAnimatorDelegate*>(layer_);
 }
 
 }  // namespace ui