1 // Copyright 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.
5 #include "cc/animation/animation.h"
9 #include "base/debug/trace_event.h"
10 #include "base/strings/string_util.h"
11 #include "cc/animation/animation_curve.h"
15 // This should match the RunState enum.
16 static const char* const s_runStateNames[] = {
18 "WaitingForTargetAvailability",
19 "WaitingForStartTime",
28 COMPILE_ASSERT(static_cast<int>(cc::Animation::RunStateEnumSize) ==
29 arraysize(s_runStateNames),
30 RunState_names_match_enum);
32 // This should match the TargetProperty enum.
33 static const char* const s_targetPropertyNames[] = {
40 COMPILE_ASSERT(static_cast<int>(cc::Animation::TargetPropertyEnumSize) ==
41 arraysize(s_targetPropertyNames),
42 TargetProperty_names_match_enum);
48 scoped_ptr<Animation> Animation::Create(
49 scoped_ptr<AnimationCurve> curve,
52 TargetProperty target_property) {
53 return make_scoped_ptr(new Animation(curve.Pass(),
58 Animation::Animation(scoped_ptr<AnimationCurve> curve,
61 TargetProperty target_property)
62 : curve_(curve.Pass()),
65 target_property_(target_property),
66 run_state_(WaitingForTargetAvailability),
69 alternates_direction_(false),
71 needs_synchronized_start_time_(false),
72 received_finished_event_(false),
75 total_paused_time_(0),
76 is_controlling_instance_(false),
77 is_impl_only_(false) {}
79 Animation::~Animation() {
80 if (run_state_ == Running || run_state_ == Paused)
81 SetRunState(Aborted, 0);
84 void Animation::SetRunState(RunState run_state, double monotonic_time) {
88 char name_buffer[256];
89 base::snprintf(name_buffer,
92 s_targetPropertyNames[target_property_],
94 is_controlling_instance_ ? "(impl)" : "");
96 bool is_waiting_to_start = run_state_ == WaitingForNextTick ||
97 run_state_ == WaitingForTargetAvailability ||
98 run_state_ == WaitingForStartTime ||
99 run_state_ == Starting;
101 if (is_waiting_to_start && run_state == Running) {
102 TRACE_EVENT_ASYNC_BEGIN1(
103 "cc", "Animation", this, "Name", TRACE_STR_COPY(name_buffer));
106 bool was_finished = is_finished();
108 const char* old_run_state_name = s_runStateNames[run_state_];
110 if (run_state == Running && run_state_ == Paused)
111 total_paused_time_ += monotonic_time - pause_time_;
112 else if (run_state == Paused)
113 pause_time_ = monotonic_time;
114 run_state_ = run_state;
116 const char* new_run_state_name = s_runStateNames[run_state];
118 if (!was_finished && is_finished())
119 TRACE_EVENT_ASYNC_END0("cc", "Animation", this);
121 char state_buffer[256];
122 base::snprintf(state_buffer,
123 sizeof(state_buffer),
128 TRACE_EVENT_INSTANT2("cc",
129 "LayerAnimationController::SetRunState",
130 TRACE_EVENT_SCOPE_THREAD,
132 TRACE_STR_COPY(name_buffer),
134 TRACE_STR_COPY(state_buffer));
137 void Animation::Suspend(double monotonic_time) {
138 SetRunState(Paused, monotonic_time);
142 void Animation::Resume(double monotonic_time) {
144 SetRunState(Running, monotonic_time);
147 bool Animation::IsFinishedAt(double monotonic_time) const {
151 if (needs_synchronized_start_time_)
154 return run_state_ == Running &&
156 iterations_ * curve_->Duration() <= (monotonic_time -
161 double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
162 double trimmed = monotonic_time + time_offset_;
164 // If we're paused, time is 'stuck' at the pause time.
165 if (run_state_ == Paused)
166 trimmed = pause_time_;
168 // Returned time should always be relative to the start time and should
169 // subtract all time spent paused.
170 trimmed -= start_time_ + total_paused_time_;
172 // If we're just starting or we're waiting on receiving a start time,
173 // time is 'stuck' at the initial state.
174 if ((run_state_ == Starting && !has_set_start_time()) ||
175 needs_synchronized_start_time())
176 trimmed = time_offset_;
178 // Zero is always the start of the animation.
182 // Always return zero if we have no iterations.
186 // Don't attempt to trim if we have no duration.
187 if (curve_->Duration() <= 0)
190 // If less than an iteration duration, just return trimmed.
191 if (trimmed < curve_->Duration())
194 // If greater than or equal to the total duration, return iteration duration.
195 if (iterations_ >= 0 && trimmed >= curve_->Duration() * iterations_) {
196 if (alternates_direction_ && !(iterations_ % 2))
198 return curve_->Duration();
201 // We need to know the current iteration if we're alternating.
202 int iteration = static_cast<int>(trimmed / curve_->Duration());
204 // Calculate x where trimmed = x + n * curve_->Duration() for some positive
206 trimmed = fmod(trimmed, curve_->Duration());
208 // If we're alternating and on an odd iteration, reverse the direction.
209 if (alternates_direction_ && iteration % 2 == 1)
210 return curve_->Duration() - trimmed;
215 scoped_ptr<Animation> Animation::Clone() const {
216 return CloneAndInitialize(run_state_, start_time_);
219 scoped_ptr<Animation> Animation::CloneAndInitialize(RunState initial_run_state,
220 double start_time) const {
221 scoped_ptr<Animation> to_return(
222 new Animation(curve_->Clone(), id_, group_, target_property_));
223 to_return->run_state_ = initial_run_state;
224 to_return->iterations_ = iterations_;
225 to_return->start_time_ = start_time;
226 to_return->pause_time_ = pause_time_;
227 to_return->total_paused_time_ = total_paused_time_;
228 to_return->time_offset_ = time_offset_;
229 to_return->alternates_direction_ = alternates_direction_;
230 DCHECK(!to_return->is_controlling_instance_);
231 to_return->is_controlling_instance_ = true;
232 return to_return.Pass();
235 void Animation::PushPropertiesTo(Animation* other) const {
236 // Currently, we only push changes due to pausing and resuming animations on
238 if (run_state_ == Animation::Paused ||
239 other->run_state_ == Animation::Paused) {
240 other->run_state_ = run_state_;
241 other->pause_time_ = pause_time_;
242 other->total_paused_time_ = total_paused_time_;