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. 4 5 #include "cc/animation/animation.h" 6 7 #include <cmath> 8 9 #include "base/debug/trace_event.h" 10 #include "base/strings/string_util.h" 11 #include "cc/animation/animation_curve.h" 12 13 namespace { 14 15 // This should match the RunState enum. 16 static const char* const s_runStateNames[] = { 17 "WaitingForTargetAvailability", 18 "WaitingForDeletion", 19 "Starting", 20 "Running", 21 "Paused", 22 "Finished", 23 "Aborted" 24 }; 25 26 COMPILE_ASSERT(static_cast<int>(cc::Animation::RunStateEnumSize) == 27 arraysize(s_runStateNames), 28 RunState_names_match_enum); 29 30 // This should match the TargetProperty enum. 31 static const char* const s_targetPropertyNames[] = { 32 "Transform", 33 "Opacity", 34 "Filter", 35 "ScrollOffset", 36 "BackgroundColor" 37 }; 38 39 COMPILE_ASSERT(static_cast<int>(cc::Animation::TargetPropertyEnumSize) == 40 arraysize(s_targetPropertyNames), 41 TargetProperty_names_match_enum); 42 43 } // namespace 44 45 namespace cc { 46 47 scoped_ptr<Animation> Animation::Create( 48 scoped_ptr<AnimationCurve> curve, 49 int animation_id, 50 int group_id, 51 TargetProperty target_property) { 52 return make_scoped_ptr(new Animation(curve.Pass(), 53 animation_id, 54 group_id, 55 target_property)); } 56 57 Animation::Animation(scoped_ptr<AnimationCurve> curve, 58 int animation_id, 59 int group_id, 60 TargetProperty target_property) 61 : curve_(curve.Pass()), 62 id_(animation_id), 63 group_(group_id), 64 target_property_(target_property), 65 run_state_(WaitingForTargetAvailability), 66 iterations_(1), 67 iteration_start_(0), 68 direction_(Normal), 69 playback_rate_(1), 70 fill_mode_(FillModeBoth), 71 needs_synchronized_start_time_(false), 72 received_finished_event_(false), 73 suspended_(false), 74 is_controlling_instance_(false), 75 is_impl_only_(false), 76 affects_active_observers_(true), 77 affects_pending_observers_(true) { 78 } 79 80 Animation::~Animation() { 81 if (run_state_ == Running || run_state_ == Paused) 82 SetRunState(Aborted, base::TimeTicks()); 83 } 84 85 void Animation::SetRunState(RunState run_state, 86 base::TimeTicks monotonic_time) { 87 if (suspended_) 88 return; 89 90 char name_buffer[256]; 91 base::snprintf(name_buffer, 92 sizeof(name_buffer), 93 "%s-%d%s", 94 s_targetPropertyNames[target_property_], 95 group_, 96 is_controlling_instance_ ? "(impl)" : ""); 97 98 bool is_waiting_to_start = run_state_ == WaitingForTargetAvailability || 99 run_state_ == Starting; 100 101 if (is_waiting_to_start && run_state == Running) { 102 TRACE_EVENT_ASYNC_BEGIN1( 103 "cc", "Animation", this, "Name", TRACE_STR_COPY(name_buffer)); 104 } 105 106 bool was_finished = is_finished(); 107 108 const char* old_run_state_name = s_runStateNames[run_state_]; 109 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; 115 116 const char* new_run_state_name = s_runStateNames[run_state]; 117 118 if (!was_finished && is_finished()) 119 TRACE_EVENT_ASYNC_END0("cc", "Animation", this); 120 121 char state_buffer[256]; 122 base::snprintf(state_buffer, 123 sizeof(state_buffer), 124 "%s->%s", 125 old_run_state_name, 126 new_run_state_name); 127 128 TRACE_EVENT_INSTANT2("cc", 129 "LayerAnimationController::SetRunState", 130 TRACE_EVENT_SCOPE_THREAD, 131 "Name", 132 TRACE_STR_COPY(name_buffer), 133 "State", 134 TRACE_STR_COPY(state_buffer)); 135 } 136 137 void Animation::Suspend(base::TimeTicks monotonic_time) { 138 SetRunState(Paused, monotonic_time); 139 suspended_ = true; 140 } 141 142 void Animation::Resume(base::TimeTicks monotonic_time) { 143 suspended_ = false; 144 SetRunState(Running, monotonic_time); 145 } 146 147 bool Animation::IsFinishedAt(base::TimeTicks monotonic_time) const { 148 if (is_finished()) 149 return true; 150 151 if (needs_synchronized_start_time_) 152 return false; 153 154 if (playback_rate_ == 0) 155 return false; 156 157 return run_state_ == Running && iterations_ >= 0 && 158 iterations_ * curve_->Duration() / std::abs(playback_rate_) <= 159 (monotonic_time + time_offset_ - start_time_ - total_paused_time_) 160 .InSecondsF(); 161 } 162 163 bool Animation::InEffect(base::TimeTicks monotonic_time) const { 164 return ConvertToActiveTime(monotonic_time) >= 0 || 165 (fill_mode_ == FillModeBoth || fill_mode_ == FillModeBackwards); 166 } 167 168 double Animation::ConvertToActiveTime(base::TimeTicks monotonic_time) const { 169 base::TimeTicks trimmed = monotonic_time + time_offset_; 170 171 // If we're paused, time is 'stuck' at the pause time. 172 if (run_state_ == Paused) 173 trimmed = pause_time_; 174 175 // Returned time should always be relative to the start time and should 176 // subtract all time spent paused. 177 trimmed -= (start_time_ - base::TimeTicks()) + total_paused_time_; 178 179 // If we're just starting or we're waiting on receiving a start time, 180 // time is 'stuck' at the initial state. 181 if ((run_state_ == Starting && !has_set_start_time()) || 182 needs_synchronized_start_time()) 183 trimmed = base::TimeTicks() + time_offset_; 184 185 return (trimmed - base::TimeTicks()).InSecondsF(); 186 } 187 188 double Animation::TrimTimeToCurrentIteration( 189 base::TimeTicks monotonic_time) const { 190 // Check for valid parameters 191 DCHECK(playback_rate_); 192 DCHECK_GE(iteration_start_, 0); 193 194 double active_time = ConvertToActiveTime(monotonic_time); 195 double start_offset = iteration_start_ * curve_->Duration(); 196 197 // Return start offset if we are before the start of the animation 198 if (active_time < 0) 199 return start_offset; 200 201 // Always return zero if we have no iterations. 202 if (!iterations_) 203 return 0; 204 205 // Don't attempt to trim if we have no duration. 206 if (curve_->Duration() <= 0) 207 return 0; 208 209 double repeated_duration = iterations_ * curve_->Duration(); 210 double active_duration = repeated_duration / std::abs(playback_rate_); 211 212 // Check if we are past active duration 213 if (iterations_ > 0 && active_time >= active_duration) 214 active_time = active_duration; 215 216 // Calculate the scaled active time 217 double scaled_active_time; 218 if (playback_rate_ < 0) 219 scaled_active_time = 220 (active_time - active_duration) * playback_rate_ + start_offset; 221 else 222 scaled_active_time = active_time * playback_rate_ + start_offset; 223 224 // Calculate the iteration time 225 double iteration_time; 226 if (scaled_active_time - start_offset == repeated_duration && 227 fmod(iterations_ + iteration_start_, 1) == 0) 228 iteration_time = curve_->Duration(); 229 else 230 iteration_time = fmod(scaled_active_time, curve_->Duration()); 231 232 // Calculate the current iteration 233 int iteration; 234 if (scaled_active_time <= 0) 235 iteration = 0; 236 else if (iteration_time == curve_->Duration()) 237 iteration = ceil(iteration_start_ + iterations_ - 1); 238 else 239 iteration = static_cast<int>(scaled_active_time / curve_->Duration()); 240 241 // Check if we are running the animation in reverse direction for the current 242 // iteration 243 bool reverse = (direction_ == Reverse) || 244 (direction_ == Alternate && iteration % 2 == 1) || 245 (direction_ == AlternateReverse && iteration % 2 == 0); 246 247 // If we are running the animation in reverse direction, reverse the result 248 if (reverse) 249 iteration_time = curve_->Duration() - iteration_time; 250 251 return iteration_time; 252 } 253 254 scoped_ptr<Animation> Animation::CloneAndInitialize( 255 RunState initial_run_state) const { 256 scoped_ptr<Animation> to_return( 257 new Animation(curve_->Clone(), id_, group_, target_property_)); 258 to_return->run_state_ = initial_run_state; 259 to_return->iterations_ = iterations_; 260 to_return->iteration_start_ = iteration_start_; 261 to_return->start_time_ = start_time_; 262 to_return->pause_time_ = pause_time_; 263 to_return->total_paused_time_ = total_paused_time_; 264 to_return->time_offset_ = time_offset_; 265 to_return->direction_ = direction_; 266 to_return->playback_rate_ = playback_rate_; 267 to_return->fill_mode_ = fill_mode_; 268 DCHECK(!to_return->is_controlling_instance_); 269 to_return->is_controlling_instance_ = true; 270 return to_return.Pass(); 271 } 272 273 void Animation::PushPropertiesTo(Animation* other) const { 274 // Currently, we only push changes due to pausing and resuming animations on 275 // the main thread. 276 if (run_state_ == Animation::Paused || 277 other->run_state_ == Animation::Paused) { 278 other->run_state_ = run_state_; 279 other->pause_time_ = pause_time_; 280 other->total_paused_time_ = total_paused_time_; 281 } 282 } 283 284 } // namespace cc 285
