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/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 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 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 // Once started, used to identify the sequence that owns a particular 106 // threaded animation. 107 int animation_group_id() const { return animation_group_id_; } 108 void set_animation_group_id(int id) { animation_group_id_ = id; } 109 110 // These functions are used for adding or removing observers from the observer 111 // list. The observers are notified when animations end. 112 void AddObserver(LayerAnimationObserver* observer); 113 void RemoveObserver(LayerAnimationObserver* observer); 114 115 // Called when a threaded animation is actually started. 116 void OnThreadedAnimationStarted(const cc::AnimationEvent& event); 117 118 // Called when the animator schedules this sequence. 119 void OnScheduled(); 120 121 // Called when the animator is destroyed. 122 void OnAnimatorDestroyed(); 123 124 // The last_progressed_fraction of the element most recently progressed by 125 // by this sequence. Returns 0.0 if no elements have been progressed. 126 double last_progressed_fraction() const { return last_progressed_fraction_; } 127 128 size_t size() const; 129 130 LayerAnimationElement* FirstElement() const; 131 132 private: 133 friend class LayerAnimatorTestController; 134 135 typedef std::vector<linked_ptr<LayerAnimationElement> > Elements; 136 137 FRIEND_TEST_ALL_PREFIXES(LayerAnimatorTest, 138 ObserverReleasedBeforeAnimationSequenceEnds); 139 140 // Notifies the observers that this sequence has been scheduled. 141 void NotifyScheduled(); 142 143 // Notifies the observers that this sequence has ended. 144 void NotifyEnded(); 145 146 // Notifies the observers that this sequence has been aborted. 147 void NotifyAborted(); 148 149 // The currently animating element. 150 LayerAnimationElement* CurrentElement() const; 151 152 // The union of all the properties modified by all elements in the sequence. 153 LayerAnimationElement::AnimatableProperties properties_; 154 155 // The elements in the sequence. 156 Elements elements_; 157 158 // True if the sequence should be looped forever. 159 bool is_cyclic_; 160 161 // These are used when animating to efficiently find the next element. 162 size_t last_element_; 163 base::TimeTicks last_start_; 164 165 // The start time of the current run of the sequence. 166 base::TimeTicks start_time_; 167 168 // True if this sequence will start together with other sequences, and at 169 // least one of the sequences in this group has a threaded first element. 170 bool waiting_for_group_start_; 171 172 // Identifies groups of sequences that are supposed to start together. 173 // Also used to identify the owner of a particular threaded animation; any 174 // in-progress threaded animation owned by this sequence will have this 175 // group id. 176 int animation_group_id_; 177 178 // These parties are notified when layer animations end. 179 ObserverList<LayerAnimationObserver> observers_; 180 181 // Tracks the last_progressed_fraction() of the most recently progressed 182 // element. 183 double last_progressed_fraction_; 184 185 base::WeakPtrFactory<LayerAnimationSequence> weak_ptr_factory_; 186 187 DISALLOW_COPY_AND_ASSIGN(LayerAnimationSequence); 188 }; 189 190 } // namespace ui 191 192 #endif // UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_ 193
