Reland r107720 - Enable the new layer animation framework.

ui/gfx/compositor/layer_animation_element.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_animation_element.h"
 
 #include "base/compiler_specific.h"
 #include "ui/base/animation/tween.h"
 #include "ui/gfx/compositor/layer_animation_delegate.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/transform.h"
 
 namespace ui {
 
 namespace {
 
 // Pause -----------------------------------------------------------------------
 class Pause : public LayerAnimationElement {
  public:
   Pause(const AnimatableProperties& properties, base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~Pause() {}
 
  private:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {}
   virtual void OnProgress(double t,
                           LayerAnimationDelegate* delegate) OVERRIDE {}
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
   virtual void OnAbort() OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(Pause);
 };
 
 // TransformTransition ---------------------------------------------------------
 
 class TransformTransition : public LayerAnimationElement {
  public:
   TransformTransition(const Transform& target, base::TimeDelta duration)
       : LayerAnimationElement(GetProperties(), duration),
         target_(target) {
   }
   virtual ~TransformTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetTransformForAnimation();
   }
 
   virtual void OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetTransformFromAnimation(
         Tween::ValueBetween(t, start_, target_));
   }
 
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+    target->transform = target_;
+  }
+
   virtual void OnAbort() OVERRIDE {}
 
  private:
   static const AnimatableProperties& GetProperties() {
     static AnimatableProperties properties;
     if (properties.size() == 0)
       properties.insert(LayerAnimationElement::TRANSFORM);
     return properties;
   }
 
@@ skipping 15 matching lines @@
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetBoundsForAnimation();
   }
 
   virtual void OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetBoundsFromAnimation(Tween::ValueBetween(t, start_, target_));
   }
 
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+    target->bounds = target_;
+  }
+
   virtual void OnAbort() OVERRIDE {}
 
  private:
   static const AnimatableProperties& GetProperties() {
     static AnimatableProperties properties;
     if (properties.size() == 0)
       properties.insert(LayerAnimationElement::BOUNDS);
     return properties;
   }
 
@@ skipping 13 matching lines @@
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetOpacityForAnimation();
   }
 
   virtual void OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetOpacityFromAnimation(Tween::ValueBetween(t, start_, target_));
   }
 
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+    target->opacity = target_;
+  }
+
   virtual void OnAbort() OVERRIDE {}
 
  private:
   static const AnimatableProperties& GetProperties() {
     static AnimatableProperties properties;
     if (properties.size() == 0)
       properties.insert(LayerAnimationElement::OPACITY);
     return properties;
   }
 
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(OpacityTransition);
 };
 
 }  // namespace
 
+// LayerAnimationElement::TargetValue ------------------------------------------
+
+LayerAnimationElement::TargetValue::TargetValue() : opacity(0.0f) {
+}
+
 // LayerAnimationElement -------------------------------------------------------
 
 LayerAnimationElement::LayerAnimationElement(
     const AnimatableProperties& properties,
     base::TimeDelta duration)
     : first_frame_(true),
       properties_(properties),
       duration_(duration) {
 }
 
 LayerAnimationElement::~LayerAnimationElement() {
 }
 
 void LayerAnimationElement::Progress(double t,
                                      LayerAnimationDelegate* delegate) {
   if (first_frame_)
     OnStart(delegate);
   OnProgress(t, delegate);
+  delegate->ScheduleDrawForAnimation();
   first_frame_ = t == 1.0;
 }
 
+void LayerAnimationElement::GetTargetValue(TargetValue* target) const {
+  OnGetTarget(target);
+}
+
 void LayerAnimationElement::Abort() {
   first_frame_ = true;
   OnAbort();
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
     const Transform& transform, base::TimeDelta duration) {
   return new TransformTransition(transform, duration);
 }
@@ skipping 10 matching lines @@
   return new OpacityTransition(opacity, duration);
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
     const AnimatableProperties& properties, base::TimeDelta duration) {
   return new Pause(properties, duration);
 }
 
 }  // namespace ui