cc/animation/animation.cc

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