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"
 #include "ui/gfx/compositor/compositor.h"
+#include "ui/gfx/compositor/dummy_layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 
 namespace ui {
 
 class LayerAnimator;
 
 namespace {
 
@@ skipping 31 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 {
+  DummyLayerAnimationDelegate dummy(*delegate_);
+  SetTarget(&dummy);
+  return dummy.GetTransformForAnimation();
+}
+
 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 {
+  DummyLayerAnimationDelegate dummy(*delegate_);
+  SetTarget(&dummy);
+  return dummy.GetBoundsForAnimation();
+}
+
 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 {
+  DummyLayerAnimationDelegate dummy(*delegate_);
+  SetTarget(&dummy);
+  return dummy.GetOpacityForAnimation();
+}
+
 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::SetTarget(LayerAnimationDelegate* delegate) const {
+  for (RunningAnimations::const_iterator iter = running_animations_.begin();
+       iter != running_animations_.end(); ++iter) {
+    (*iter).sequence->SetTarget(delegate);
+  }
+
+  for (AnimationQueue::const_iterator iter = animation_queue_.begin();
+       iter != animation_queue_.end(); ++iter) {
+    (*iter)->SetTarget(delegate);
+  }
+}
+
 }  // namespace ui