blob: 5c6fcd0f2a14048871980070547161ebacce640b [file] [log] [blame]
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/animation/animation.h"
#include <cmath>
#include "base/strings/string_util.h"
#include "base/trace_event/trace_event.h"
#include "cc/animation/animation_curve.h"
#include "cc/base/time_util.h"
namespace {
// This should match the RunState enum.
static const char* const s_runStateNames[] = {"WAITING_FOR_TARGET_AVAILABILITY",
"WAITING_FOR_DELETION",
"STARTING",
"RUNNING",
"PAUSED",
"FINISHED",
"ABORTED"};
static_assert(static_cast<int>(cc::Animation::LAST_RUN_STATE) + 1 ==
arraysize(s_runStateNames),
"RunStateEnumSize should equal the number of elements in "
"s_runStateNames");
} // namespace
namespace cc {
scoped_ptr<Animation> Animation::Create(scoped_ptr<AnimationCurve> curve,
int animation_id,
int group_id,
TargetProperty::Type target_property) {
return make_scoped_ptr(
new Animation(std::move(curve), animation_id, group_id, target_property));
}
Animation::Animation(scoped_ptr<AnimationCurve> curve,
int animation_id,
int group_id,
TargetProperty::Type target_property)
: curve_(std::move(curve)),
id_(animation_id),
group_(group_id),
target_property_(target_property),
run_state_(WAITING_FOR_TARGET_AVAILABILITY),
iterations_(1),
iteration_start_(0),
direction_(DIRECTION_NORMAL),
playback_rate_(1),
fill_mode_(FILL_MODE_BOTH),
needs_synchronized_start_time_(false),
received_finished_event_(false),
suspended_(false),
is_controlling_instance_(false),
is_impl_only_(false),
affects_active_observers_(true),
affects_pending_observers_(true) {}
Animation::~Animation() {
if (run_state_ == RUNNING || run_state_ == PAUSED)
SetRunState(ABORTED, base::TimeTicks());
}
void Animation::SetRunState(RunState run_state,
base::TimeTicks monotonic_time) {
if (suspended_)
return;
char name_buffer[256];
base::snprintf(name_buffer, sizeof(name_buffer), "%s-%d",
TargetProperty::GetName(target_property_), group_);
bool is_waiting_to_start =
run_state_ == WAITING_FOR_TARGET_AVAILABILITY || run_state_ == STARTING;
if (is_controlling_instance_ && is_waiting_to_start && run_state == RUNNING) {
TRACE_EVENT_ASYNC_BEGIN1(
"cc", "Animation", this, "Name", TRACE_STR_COPY(name_buffer));
}
bool was_finished = is_finished();
const char* old_run_state_name = s_runStateNames[run_state_];
if (run_state == RUNNING && run_state_ == PAUSED)
total_paused_time_ += (monotonic_time - pause_time_);
else if (run_state == PAUSED)
pause_time_ = monotonic_time;
run_state_ = run_state;
const char* new_run_state_name = s_runStateNames[run_state];
if (is_controlling_instance_ && !was_finished && is_finished())
TRACE_EVENT_ASYNC_END0("cc", "Animation", this);
char state_buffer[256];
base::snprintf(state_buffer,
sizeof(state_buffer),
"%s->%s",
old_run_state_name,
new_run_state_name);
TRACE_EVENT_INSTANT2("cc",
"LayerAnimationController::SetRunState",
TRACE_EVENT_SCOPE_THREAD,
"Name",
TRACE_STR_COPY(name_buffer),
"State",
TRACE_STR_COPY(state_buffer));
}
void Animation::Suspend(base::TimeTicks monotonic_time) {
SetRunState(PAUSED, monotonic_time);
suspended_ = true;
}
void Animation::Resume(base::TimeTicks monotonic_time) {
suspended_ = false;
SetRunState(RUNNING, monotonic_time);
}
bool Animation::IsFinishedAt(base::TimeTicks monotonic_time) const {
if (is_finished())
return true;
if (needs_synchronized_start_time_)
return false;
if (playback_rate_ == 0)
return false;
return run_state_ == RUNNING && iterations_ >= 0 &&
TimeUtil::Scale(curve_->Duration(),
iterations_ / std::abs(playback_rate_)) <=
(monotonic_time + time_offset_ - start_time_ - total_paused_time_);
}
bool Animation::InEffect(base::TimeTicks monotonic_time) const {
return ConvertToActiveTime(monotonic_time) >= base::TimeDelta() ||
(fill_mode_ == FILL_MODE_BOTH || fill_mode_ == FILL_MODE_BACKWARDS);
}
base::TimeDelta Animation::ConvertToActiveTime(
base::TimeTicks monotonic_time) const {
base::TimeTicks trimmed = monotonic_time + time_offset_;
// If we're paused, time is 'stuck' at the pause time.
if (run_state_ == PAUSED)
trimmed = pause_time_;
// Returned time should always be relative to the start time and should
// subtract all time spent paused.
trimmed -= (start_time_ - base::TimeTicks()) + total_paused_time_;
// If we're just starting or we're waiting on receiving a start time,
// time is 'stuck' at the initial state.
if ((run_state_ == STARTING && !has_set_start_time()) ||
needs_synchronized_start_time())
trimmed = base::TimeTicks() + time_offset_;
return (trimmed - base::TimeTicks());
}
base::TimeDelta Animation::TrimTimeToCurrentIteration(
base::TimeTicks monotonic_time) const {
// Check for valid parameters
DCHECK(playback_rate_);
DCHECK_GE(iteration_start_, 0);
base::TimeDelta active_time = ConvertToActiveTime(monotonic_time);
base::TimeDelta start_offset =
TimeUtil::Scale(curve_->Duration(), iteration_start_);
// Return start offset if we are before the start of the animation
if (active_time < base::TimeDelta())
return start_offset;
// Always return zero if we have no iterations.
if (!iterations_)
return base::TimeDelta();
// Don't attempt to trim if we have no duration.
if (curve_->Duration() <= base::TimeDelta())
return base::TimeDelta();
base::TimeDelta repeated_duration =
TimeUtil::Scale(curve_->Duration(), iterations_);
base::TimeDelta active_duration =
TimeUtil::Scale(repeated_duration, 1.0 / std::abs(playback_rate_));
// Check if we are past active duration
if (iterations_ > 0 && active_time >= active_duration)
active_time = active_duration;
// Calculate the scaled active time
base::TimeDelta scaled_active_time;
if (playback_rate_ < 0)
scaled_active_time =
TimeUtil::Scale((active_time - active_duration), playback_rate_) +
start_offset;
else
scaled_active_time =
TimeUtil::Scale(active_time, playback_rate_) + start_offset;
// Calculate the iteration time
base::TimeDelta iteration_time;
if (scaled_active_time - start_offset == repeated_duration &&
fmod(iterations_ + iteration_start_, 1) == 0)
iteration_time = curve_->Duration();
else
iteration_time = TimeUtil::Mod(scaled_active_time, curve_->Duration());
// Calculate the current iteration
int iteration;
if (scaled_active_time <= base::TimeDelta())
iteration = 0;
else if (iteration_time == curve_->Duration())
iteration = ceil(iteration_start_ + iterations_ - 1);
else
iteration = static_cast<int>(scaled_active_time / curve_->Duration());
// Check if we are running the animation in reverse direction for the current
// iteration
bool reverse =
(direction_ == DIRECTION_REVERSE) ||
(direction_ == DIRECTION_ALTERNATE && iteration % 2 == 1) ||
(direction_ == DIRECTION_ALTERNATE_REVERSE && iteration % 2 == 0);
// If we are running the animation in reverse direction, reverse the result
if (reverse)
iteration_time = curve_->Duration() - iteration_time;
return iteration_time;
}
scoped_ptr<Animation> Animation::CloneAndInitialize(
RunState initial_run_state) const {
scoped_ptr<Animation> to_return(
new Animation(curve_->Clone(), id_, group_, target_property_));
to_return->run_state_ = initial_run_state;
to_return->iterations_ = iterations_;
to_return->iteration_start_ = iteration_start_;
to_return->start_time_ = start_time_;
to_return->pause_time_ = pause_time_;
to_return->total_paused_time_ = total_paused_time_;
to_return->time_offset_ = time_offset_;
to_return->direction_ = direction_;
to_return->playback_rate_ = playback_rate_;
to_return->fill_mode_ = fill_mode_;
DCHECK(!to_return->is_controlling_instance_);
to_return->is_controlling_instance_ = true;
return to_return;
}
void Animation::PushPropertiesTo(Animation* other) const {
// Currently, we only push changes due to pausing and resuming animations on
// the main thread.
if (run_state_ == Animation::PAUSED ||
other->run_state_ == Animation::PAUSED) {
other->run_state_ = run_state_;
other->pause_time_ = pause_time_;
other->total_paused_time_ = total_paused_time_;
}
}
} // namespace cc