Explicit animation support

ui/gfx/compositor/layer_animation_sequence.h

Index: ui/gfx/compositor/layer_animation_sequence.h
diff --git a/ui/gfx/compositor/layer_animation_sequence.h b/ui/gfx/compositor/layer_animation_sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba64059bb8ac71d4baaf8dcae9e42359f9ef1c45
--- /dev/null
+++ b/ui/gfx/compositor/layer_animation_sequence.h
@@ -0,0 +1,83 @@
+// 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.
+
+#ifndef UI_GFX_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
+#define UI_GFX_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
+#pragma once
+
+#include <vector>
+
+#include "base/memory/scoped_vector.h"
+#include "base/time.h"
+#include "ui/gfx/compositor/compositor_export.h"
+#include "ui/gfx/compositor/layer_animation_element.h"
+
+namespace ui {
+
+class LayerAnimationDelegate;
+
+// Contains a collection of layer animation elements to be played one after
+// another. Although it has a similar interface to LayerAnimationElement, it is
+// not a LayerAnimationElement (i.e., it is not permitted to have a sequence in
+// a sequence). Sequences own their elements, and sequences are themselves owned
+// by a LayerAnimator.
+//
+// TODO(vollick) Create a 'blended' sequence for transitioning between
+// sequences.
+class COMPOSITOR_EXPORT LayerAnimationSequence {
+ public:
+  typedef ScopedVector<LayerAnimationElement> Elements;

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

Move this to the private section.

+
+  LayerAnimationSequence();
+  // Takes ownership of the given element and adds it to the sequence.
+  explicit LayerAnimationSequence(LayerAnimationElement* element);
+  virtual ~LayerAnimationSequence();
+
+

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

remove one of these lines.

+  // Updates the delegate to the appropriate value for |elapsed|, which is in
+  // the range [0, Duration()].  If the animation is not aborted, it is
+  // guaranteed that Animate will be called with elapsed = Duration().
+  void Progress(base::TimeDelta elapsed, LayerAnimationDelegate* delegate);
+
+  // Aborts the given animation.
+  void Abort();
+
+  // All properties modified by the sequence.
+  const LayerAnimationElement::AnimatableProperties& properties() const {
+    return properties_;
+  }
+
+  // The total, finite duration of one cycle of the sequence.
+  base::TimeDelta duration() const {
+    return duration_;
+  }
+
+  // Adds an element to the sequence. The sequences takes ownership of this
+  // element.
+  void AddElement(LayerAnimationElement* element);
+
+  // Sequences can be looped indefinitely.
+  void set_is_cyclic(bool is_cyclic) { is_cyclic_ = is_cyclic; }
+  bool is_cyclic() const { return is_cyclic_; }
+
+  // Returns true, if the sequences share a common property.

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

How about: returns true if this sequence has at least one element whose
properties match |other|.

+  bool HasCommonProperty(
+      const LayerAnimationElement::AnimatableProperties& other) const;
+
+ private:
+  base::TimeDelta duration_;
+  LayerAnimationElement::AnimatableProperties properties_;

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

Description?

+  Elements elements_;
+  bool is_cyclic_;
+
+  // these are used when animating to efficiently find the next element
+  Elements::size_type last_element_;
+  base::TimeDelta last_start_;
+
+  DISALLOW_COPY_AND_ASSIGN(LayerAnimationSequence);
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_