ui/compositor/layer_animation_sequence.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
   6 #define UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
   7
   8 #include <vector>
   9
  10 #include "base/gtest_prod_util.h"
  11 #include "base/memory/linked_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/observer_list.h"
  14 #include "base/time.h"
  15 #include "ui/compositor/compositor_export.h"
  16 #include "ui/compositor/layer_animation_element.h"
  17
  18 namespace ui {
  19
  20 class LayerAnimationDelegate;
  21 class LayerAnimationObserver;
  22
  23 // Contains a collection of layer animation elements to be played one after
  24 // another. Although it has a similar interface to LayerAnimationElement, it is
  25 // not a LayerAnimationElement (i.e., it is not permitted to have a sequence in
  26 // a sequence). Sequences own their elements, and sequences are themselves owned
  27 // by a LayerAnimator.
  28 //
  29 // TODO(vollick) Create a 'blended' sequence for transitioning between
  30 // sequences.
  31 // TODO(vollick) Eventually, the LayerAnimator will switch to a model where new
  32 // work is scheduled rather than calling methods directly. This should make it
  33 // impossible for temporary pointers to running animations to go stale. When
  34 // this happens, there will be no need for LayerAnimationSequences to support
  35 // weak pointers.
  36 class COMPOSITOR_EXPORT LayerAnimationSequence
  37     : public base::SupportsWeakPtr<LayerAnimationSequence> {
  38  public:
  39   LayerAnimationSequence();
  40   // Takes ownership of the given element and adds it to the sequence.
  41   explicit LayerAnimationSequence(LayerAnimationElement* element);
  42   virtual ~LayerAnimationSequence();
  43
  44   // Sets the start time for the animation. This must be called before the
  45   // first call to {Start, IsFinished}. Once the animation is finished, this
  46   // must be called again in order to restart the animation.
  47   void set_start_time(base::TimeTicks start_time) { start_time_ = start_time; }
  48   base::TimeTicks start_time() const { return start_time_; }
  49
  50   // Sets a flag indicating that this sequence will start together with other
  51   // sequences, and at least one of the sequences in this group has a threaded
  52   // first element.
  53   void set_waiting_for_group_start(bool waiting) {
  54     waiting_for_group_start_ = waiting;
  55   }
  56   bool waiting_for_group_start() { return waiting_for_group_start_; }
  57
  58   // This must be called before the first call to Progress. If starting the
  59   // animation involves dispatching to another thread, then this will proceed
  60   // with that dispatch, ultimately resulting in the animation getting an
  61   // effective start time (the time the animation starts on the other thread).
  62   void Start(LayerAnimationDelegate* delegate);
  63
  64   // Updates the delegate to the appropriate value for |now|. Requests a
  65   // redraw if it is required.
  66   void Progress(base::TimeTicks now, LayerAnimationDelegate* delegate);
  67
  68   // Returns true if calling Progress now, with the given time, will finish
  69   // the animation.
  70   bool IsFinished(base::TimeTicks time);
  71
  72   // Updates the delegate to the end of the animation; if this sequence is
  73   // cyclic, updates the delegate to the end of one cycle of the sequence.
  74   void ProgressToEnd(LayerAnimationDelegate* delegate);
  75
  76   // Sets the target value to the value that would have been set had
  77   // the sequence completed. Does nothing if the sequence is cyclic.
  78   void GetTargetValue(LayerAnimationElement::TargetValue* target) const;
  79
  80   // Aborts the given animation.
  81   void Abort(LayerAnimationDelegate* delegate);
  82
  83   // All properties modified by the sequence.
  84   const LayerAnimationElement::AnimatableProperties& properties() const {
  85     return properties_;
  86   }
  87
  88   // Adds an element to the sequence. The sequences takes ownership of this
  89   // element.
  90   void AddElement(LayerAnimationElement* element);
  91
  92   // Sequences can be looped indefinitely.
  93   void set_is_cyclic(bool is_cyclic) { is_cyclic_ = is_cyclic; }
  94   bool is_cyclic() const { return is_cyclic_; }
  95
  96   // Returns true if this sequence has at least one element conflicting with a
  97   // property in |other|.
  98   bool HasConflictingProperty(
  99       const LayerAnimationElement::AnimatableProperties& other) const;
 100
 101   // Returns true if the first element animates on the compositor thread.
 102   bool IsFirstElementThreaded() const;
 103
 104   // Used to identify groups of sequences that are supposed to start together.
 105   int animation_group_id() const { return animation_group_id_; }
 106   void set_animation_group_id(int id) { animation_group_id_ = id; }
 107
 108   // These functions are used for adding or removing observers from the observer
 109   // list. The observers are notified when animations end.
 110   void AddObserver(LayerAnimationObserver* observer);
 111   void RemoveObserver(LayerAnimationObserver* observer);
 112
 113   // Called when a threaded animation is actually started.
 114   void OnThreadedAnimationStarted(const cc::AnimationEvent& event);
 115
 116   // Called when the animator schedules this sequence.
 117   void OnScheduled();
 118
 119   // Called when the animator is destroyed.
 120   void OnAnimatorDestroyed();
 121
 122   // The last_progressed_fraction of the element most recently progressed by
 123   // by this sequence. Returns 0.0 if no elements have been progressed.
 124   double last_progressed_fraction() const { return last_progressed_fraction_; }
 125
 126  private:
 127   friend class LayerAnimatorTestController;
 128
 129   typedef std::vector<linked_ptr<LayerAnimationElement> > Elements;
 130
 131   FRIEND_TEST_ALL_PREFIXES(LayerAnimatorTest,
 132                            ObserverReleasedBeforeAnimationSequenceEnds);
 133
 134   // Notifies the observers that this sequence has been scheduled.
 135   void NotifyScheduled();
 136
 137   // Notifies the observers that this sequence has ended.
 138   void NotifyEnded();
 139
 140   // Notifies the observers that this sequence has been aborted.
 141   void NotifyAborted();
 142
 143   // The currently animating element.
 144   LayerAnimationElement* CurrentElement();
 145
 146   // The union of all the properties modified by all elements in the sequence.
 147   LayerAnimationElement::AnimatableProperties properties_;
 148
 149   // The elements in the sequence.
 150   Elements elements_;
 151
 152   // True if the sequence should be looped forever.
 153   bool is_cyclic_;
 154
 155   // These are used when animating to efficiently find the next element.
 156   size_t last_element_;
 157   base::TimeTicks last_start_;
 158
 159   // The start time of the current run of the sequence.
 160   base::TimeTicks start_time_;
 161
 162   // True if this sequence will start together with other sequences, and at
 163   // least one of the sequences in this group has a threaded first element.
 164   bool waiting_for_group_start_;
 165
 166   // Identifies groups of sequences that are supposed to start together.
 167   int animation_group_id_;
 168
 169   // These parties are notified when layer animations end.
 170   ObserverList<LayerAnimationObserver> observers_;
 171
 172   // Tracks the last_progressed_fraction() of the most recently progressed
 173   // element.
 174   double last_progressed_fraction_;
 175
 176   DISALLOW_COPY_AND_ASSIGN(LayerAnimationSequence);
 177 };
 178
 179 }  // namespace ui
 180
 181 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_