Reland r107720 - Enable the new layer animation framework.

ui/gfx/compositor/layer_animator.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 "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation_container.h"
@@ skipping 42 matching lines @@
 
 void LayerAnimator::SetTransform(const Transform& transform) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetTransformFromAnimation(transform);
   else
     StartAnimation(new LayerAnimationSequence(
         LayerAnimationElement::CreateTransformElement(transform,
                                                       transition_duration_)));
 }
 
+Transform LayerAnimator::GetTargetTransform() const {
+  LayerAnimationElement::TargetValue target;
+  GetTargetValue(&target);
+  return target.transform;
+}
+
 void LayerAnimator::SetBounds(const gfx::Rect& bounds) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetBoundsFromAnimation(bounds);
   else
     StartAnimation(new LayerAnimationSequence(
         LayerAnimationElement::CreateBoundsElement(bounds,
                                                    transition_duration_)));
 }
 
+gfx::Rect LayerAnimator::GetTargetBounds() const {
+  LayerAnimationElement::TargetValue target;
+  GetTargetValue(&target);
+  return target.bounds;
+}
+
 void LayerAnimator::SetOpacity(float opacity) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetOpacityFromAnimation(opacity);
   else
     StartAnimation(new LayerAnimationSequence(
         LayerAnimationElement::CreateOpacityElement(opacity,
                                                     transition_duration_)));
 }
 
+float LayerAnimator::GetTargetOpacity() const {
+  LayerAnimationElement::TargetValue target;
+  GetTargetValue(&target);
+  return target.opacity;
+}
+
 void LayerAnimator::SetDelegate(LayerAnimationDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
   if (!StartSequenceImmediately(animation)) {
     // Attempt to preempt a running animation.
     switch (preemption_strategy_) {
       case IMMEDIATELY_SET_NEW_TARGET:
@@ skipping 342 matching lines @@
 
   // Need to keep a reference to the animation.
   AddToQueueIfNotPresent(sequence);
 
   // Ensure that animations get stepped at their start time.
   Step(start_time);
 
   return true;
 }
 
+void LayerAnimator::GetTargetValue(
+    LayerAnimationElement::TargetValue* target) const {
+  for (RunningAnimations::const_iterator iter = running_animations_.begin();
+       iter != running_animations_.end(); ++iter) {
+    (*iter).sequence->GetTargetValue(target);
+  }
+
+  for (AnimationQueue::const_iterator iter = animation_queue_.begin();
+       iter != animation_queue_.end(); ++iter) {
+    (*iter)->GetTargetValue(target);
+  }
+}
+
 }  // namespace ui