Explicit animation support

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 {
+
+class Pause : public LayerAnimationElement {
+ public:
+  Pause(const AnimatableProperties& properties, base::TimeDelta duration)
+      : properties_(properties),
+        duration_(duration) {
+  }
+
+  virtual ~Pause() {}
+
+ private:
+  virtual void Progress(double t, LayerAnimationDelegate* delegate) OVERRIDE {}
+
+  virtual void Abort() OVERRIDE {}
+
+  virtual const AnimatableProperties& Properties() const OVERRIDE {
+    return properties_;
+  }
+
+  virtual base::TimeDelta Duration() const OVERRIDE {
+    return duration_;
+  }
+
+  AnimatableProperties properties_;

[sky, 2011/10/19 00:06:33]

As mentioned, promote these to LayerAnimationElement and make them const.

+  base::TimeDelta duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(Pause);
+};
+
+class TransitionBase : public LayerAnimationElement {

[sky, 2011/10/19 00:06:33]

Add a description of this class. Maybe it should be called
BaseLayerAnimationElement or something.

+ public:
+  TransitionBase(LayerAnimationElement::AnimatableProperty property,
+                 base::TimeDelta duration)
+      : first_frame_(true),
+        duration_(duration) {
+    properties_.insert(property);
+  }
+
+  virtual ~TransitionBase() {}
+
+ protected:
+  virtual void OnProgress(double t, LayerAnimationDelegate* delegate) = 0;
+  bool first_frame() const { return first_frame_; }

[sky, 2011/10/19 00:06:33]

Add a description.

+
+ private:
+  virtual void Progress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+    OnProgress(t, delegate);

[sky, 2011/10/19 00:06:33]

It looks like all subclasses care about OnProgress when first_frame_ is true.
Maybe you should have a separate method that this calls rather than
first_frame(). Maybe OnPrepare or something.

+    delegate->ScheduleDrawForAnimation();
+    first_frame_ = t == 1.0; // when we've completed, reset to first frame.
+  }
+
+  virtual void Abort() OVERRIDE {
+    // reset.
+    first_frame_ = true;
+  }
+
+  virtual const AnimatableProperties& Properties() const OVERRIDE {
+    return properties_;
+  }
+
+  virtual base::TimeDelta Duration() const OVERRIDE {
+    return duration_;
+  }
+
+  bool first_frame_;
+  AnimatableProperties properties_;
+  base::TimeDelta duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(TransitionBase);
+};
+
+class TransformTransition : public TransitionBase {
+ public:
+  TransformTransition(const Transform& target, base::TimeDelta duration)
+      : TransitionBase(LayerAnimationElement::TRANSFORM, duration),
+        target_(target) {
+  }
+  virtual ~TransformTransition() {}
+
+ protected:
+  virtual void OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+    if (first_frame())
+      start_ = delegate->GetTransformForAnimation();
+    delegate->SetTransformFromAnimation(
+        Tween::ValueBetween(t, start_, target_));
+  }
+
+ private:
+  Transform start_;
+  Transform target_;
+
+  DISALLOW_COPY_AND_ASSIGN(TransformTransition);
+};
+
+class BoundsTransition : public TransitionBase {
+ public:
+  BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
+      : TransitionBase(LayerAnimationElement::BOUNDS, duration),
+        target_(target) {
+  }
+  virtual ~BoundsTransition() {}
+
+ protected:
+  virtual void OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+    if (first_frame())
+      start_ = delegate->GetBoundsForAnimation();
+    delegate->SetBoundsFromAnimation(Tween::ValueBetween(t, start_, target_));
+  }
+
+ private:
+  gfx::Rect start_;
+  gfx::Rect target_;
+};

[sky, 2011/10/19 00:06:33]

DISALLOW_COPY_AND_ASSIGN

+
+class OpacityTransition : public TransitionBase {
+ public:
+  OpacityTransition(float target, base::TimeDelta duration)
+      : TransitionBase(LayerAnimationElement::OPACITY, duration),
+        target_(target) {
+  }
+  virtual ~OpacityTransition() {}
+
+ protected:
+  virtual void OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
+    if (first_frame())
+      start_ = delegate->GetOpacityForAnimation();
+    delegate->SetOpacityFromAnimation(Tween::ValueBetween(t, start_, target_));
+  }
+
+ private:
+  float start_;
+  float target_;
+
+  DISALLOW_COPY_AND_ASSIGN(OpacityTransition);
+};
+
+}  // namespace
+
+/* static */
+LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
+    const Transform& transform, base::TimeDelta duration) {
+  return new TransformTransition(transform, duration);
+}
+
+/* static */
+LayerAnimationElement* LayerAnimationElement::CreateBoundsElement(
+    const gfx::Rect& bounds, base::TimeDelta duration) {
+  return new BoundsTransition(bounds, duration);
+}
+
+/* static */
+LayerAnimationElement* LayerAnimationElement::CreateOpacityElement(
+    float opacity, base::TimeDelta duration) {
+  return new OpacityTransition(opacity, duration);
+}
+
+/* static */
+LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
+    const AnimatableProperties& properties, base::TimeDelta duration) {
+  return new Pause(properties, duration);
+}
+
+}  // namespace ui