blob: 52fa9a8dec724711a6d7d1df482da7341fc452f8 [file] [log] [blame]
// Copyright 2015 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_player.h"
#include "cc/animation/animation_delegate.h"
#include "cc/animation/animation_host.h"
#include "cc/animation/animation_timeline.h"
#include "cc/animation/element_animations.h"
#include "cc/animation/layer_animation_controller.h"
namespace cc {
scoped_refptr<AnimationPlayer> AnimationPlayer::Create(int id) {
return make_scoped_refptr(new AnimationPlayer(id));
}
AnimationPlayer::AnimationPlayer(int id)
: animation_host_(),
animation_timeline_(),
element_animations_(),
layer_animation_delegate_(),
id_(id),
layer_id_(0) {
DCHECK(id_);
}
AnimationPlayer::~AnimationPlayer() {
DCHECK(!animation_timeline_);
DCHECK(!element_animations_);
}
scoped_refptr<AnimationPlayer> AnimationPlayer::CreateImplInstance() const {
scoped_refptr<AnimationPlayer> player = AnimationPlayer::Create(id());
return player;
}
void AnimationPlayer::SetAnimationHost(AnimationHost* animation_host) {
animation_host_ = animation_host;
}
void AnimationPlayer::SetAnimationTimeline(AnimationTimeline* timeline) {
if (animation_timeline_ == timeline)
return;
// We need to unregister player to manage ElementAnimations and observers
// properly.
if (layer_id_ && element_animations_)
UnregisterPlayer();
animation_timeline_ = timeline;
// Register player only if layer AND host attached.
if (layer_id_ && animation_host_)
RegisterPlayer();
}
void AnimationPlayer::AttachLayer(int layer_id) {
DCHECK_EQ(layer_id_, 0);
DCHECK(layer_id);
layer_id_ = layer_id;
// Register player only if layer AND host attached.
if (animation_host_)
RegisterPlayer();
}
void AnimationPlayer::DetachLayer() {
DCHECK(layer_id_);
if (animation_host_)
UnregisterPlayer();
layer_id_ = 0;
}
void AnimationPlayer::RegisterPlayer() {
DCHECK(layer_id_);
DCHECK(animation_host_);
DCHECK(!element_animations_);
// Create LAC or re-use existing.
animation_host_->RegisterPlayerForLayer(layer_id_, this);
// Get local reference to shared LAC.
BindElementAnimations();
}
void AnimationPlayer::UnregisterPlayer() {
DCHECK(layer_id_);
DCHECK(animation_host_);
DCHECK(element_animations_);
UnbindElementAnimations();
// Destroy LAC or release it if it's still needed.
animation_host_->UnregisterPlayerForLayer(layer_id_, this);
}
void AnimationPlayer::BindElementAnimations() {
DCHECK(!element_animations_);
element_animations_ =
animation_host_->GetElementAnimationsForLayerId(layer_id_);
DCHECK(element_animations_);
// Pass all accumulated animations to LAC.
for (auto& animation : animations_) {
element_animations_->layer_animation_controller()->AddAnimation(
std::move(animation));
}
if (!animations_.empty())
SetNeedsCommit();
animations_.clear();
}
void AnimationPlayer::UnbindElementAnimations() {
element_animations_ = nullptr;
DCHECK(animations_.empty());
}
void AnimationPlayer::AddAnimation(scoped_ptr<Animation> animation) {
DCHECK(animation->target_property() != Animation::SCROLL_OFFSET ||
(animation_host_ && animation_host_->SupportsScrollAnimations()));
if (element_animations_) {
element_animations_->layer_animation_controller()->AddAnimation(
std::move(animation));
SetNeedsCommit();
} else {
animations_.push_back(std::move(animation));
}
}
void AnimationPlayer::PauseAnimation(int animation_id, double time_offset) {
DCHECK(element_animations_);
element_animations_->layer_animation_controller()->PauseAnimation(
animation_id, base::TimeDelta::FromSecondsD(time_offset));
SetNeedsCommit();
}
void AnimationPlayer::RemoveAnimation(int animation_id) {
if (element_animations_) {
element_animations_->layer_animation_controller()->RemoveAnimation(
animation_id);
SetNeedsCommit();
} else {
auto animations_to_remove =
std::remove_if(animations_.begin(), animations_.end(),
[animation_id](const scoped_ptr<Animation>& animation) {
return animation->id() == animation_id;
});
animations_.erase(animations_to_remove, animations_.end());
}
}
void AnimationPlayer::AbortAnimation(int animation_id) {
DCHECK(element_animations_);
element_animations_->layer_animation_controller()->AbortAnimation(
animation_id);
SetNeedsCommit();
}
void AnimationPlayer::AbortAnimations(
Animation::TargetProperty target_property) {
if (element_animations_) {
element_animations_->layer_animation_controller()->AbortAnimations(
target_property);
SetNeedsCommit();
} else {
auto animations_to_remove = std::remove_if(
animations_.begin(), animations_.end(),
[target_property](const scoped_ptr<Animation>& animation) {
return animation->target_property() == target_property;
});
animations_.erase(animations_to_remove, animations_.end());
}
}
void AnimationPlayer::PushPropertiesTo(AnimationPlayer* player_impl) {
if (layer_id_ != player_impl->layer_id()) {
if (player_impl->layer_id())
player_impl->DetachLayer();
if (layer_id_)
player_impl->AttachLayer(layer_id_);
}
}
void AnimationPlayer::NotifyAnimationStarted(
base::TimeTicks monotonic_time,
Animation::TargetProperty target_property,
int group) {
if (layer_animation_delegate_)
layer_animation_delegate_->NotifyAnimationStarted(monotonic_time,
target_property, group);
}
void AnimationPlayer::NotifyAnimationFinished(
base::TimeTicks monotonic_time,
Animation::TargetProperty target_property,
int group) {
if (layer_animation_delegate_)
layer_animation_delegate_->NotifyAnimationFinished(monotonic_time,
target_property, group);
}
void AnimationPlayer::NotifyAnimationAborted(
base::TimeTicks monotonic_time,
Animation::TargetProperty target_property,
int group) {
if (layer_animation_delegate_)
layer_animation_delegate_->NotifyAnimationAborted(monotonic_time,
target_property, group);
}
void AnimationPlayer::SetNeedsCommit() {
DCHECK(animation_host_);
animation_host_->SetNeedsCommit();
animation_host_->SetNeedsRebuildPropertyTrees();
}
} // namespace cc