Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(235)

Side by Side Diff: cc/animation/animation_player.cc

Issue 947033002: CC Animations: Establish AnimationHost, AnimationTimeline and AnimationPlayer (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase. Add comments. Created 5 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Copyright 2015 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_player.h"
6
7 #include "cc/animation/animation_host.h"
8 #include "cc/animation/animation_registrar.h"
9 #include "cc/animation/animation_timeline.h"
10 #include "cc/layers/layer.h"
11 #include "cc/trees/layer_tree_mutators_client.h"
12
13 namespace cc {
14
15 class AnimationPlayer::ValueObserver : public LayerAnimationValueObserver {
16 public:
17 ValueObserver(AnimationPlayer* player, bool is_active)
18 : player_(player), is_active_(is_active) {
Ian Vollick 2015/05/05 03:52:06 Just to make sure I'm understanding this correctly
loyso (OOO) 2015/05/05 06:51:18 Yes, that's absolutely correct.
19 DCHECK(player_);
20 }
21
22 // LayerAnimationValueObserver implementation.
23 void OnFilterAnimated(const FilterOperations& filters) override {
24 player_->SetFilterMutated(is_active_, filters);
25 }
26
27 void OnOpacityAnimated(float opacity) override {
28 player_->SetOpacityMutated(is_active_, opacity);
29 }
30
31 void OnTransformAnimated(const gfx::Transform& transform) override {
32 player_->SetTransformMutated(is_active_, transform);
33 }
34
35 void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) override {
36 player_->SetScrollOffsetMutated(is_active_, scroll_offset);
37 }
38
39 void OnAnimationWaitingForDeletion() override {
40 // TODO(loyso): implement it.
Ian Vollick 2015/05/05 03:52:06 Why's it ok to put this off?
loyso (OOO) 2015/05/05 06:51:18 It's in separate CL for scroll offset. https://cod
Ian Vollick 2015/05/07 13:58:42 My questions is more about staging. Will the code
loyso (OOO) 2015/05/08 01:04:34 We don't run this code path w/o --enable_composito
Ian Vollick 2015/05/08 14:58:22 K, great.
41 }
42
43 bool IsActive() const override { return is_active_; }
44
45 private:
46 AnimationPlayer* player_;
47 bool is_active_;
48
49 DISALLOW_COPY_AND_ASSIGN(ValueObserver);
50 };
51
52 scoped_refptr<AnimationPlayer> AnimationPlayer::Create(int id) {
53 return make_scoped_refptr(new AnimationPlayer(id));
54 }
55
56 AnimationPlayer::AnimationPlayer(int id)
57 : animation_host_(),
58 animation_timeline_(),
59 layer_animation_delegate_(),
60 id_(id),
61 layer_id_(0) {
62 DCHECK(id_);
63 }
64
65 AnimationPlayer::~AnimationPlayer() {
66 DCHECK(!animation_timeline_);
67 DCHECK(!layer_animation_controller_);
68 DCHECK(!layer_id_);
69 }
70
71 scoped_refptr<AnimationPlayer> AnimationPlayer::CreateImplInstance() const {
72 scoped_refptr<AnimationPlayer> to_return = AnimationPlayer::Create(id());
73 return to_return;
74 }
75
76 void AnimationPlayer::SetAnimationHost(AnimationHost* animation_host) {
77 animation_host_ = animation_host;
78 }
79
80 void AnimationPlayer::SetAnimationTimeline(AnimationTimeline* timeline) {
81 if (animation_timeline_ == timeline)
82 return;
83
84 if (layer_id_ && animation_timeline_)
85 RemoveControllerFromTimeline();
Ian Vollick 2015/05/05 03:52:06 Can you add a comment explaining why you need to r
loyso (OOO) 2015/05/05 06:51:18 Acknowledged.
loyso (OOO) 2015/06/22 07:48:51 Done.
86
87 animation_timeline_ = timeline;
88
89 if (layer_id_ && animation_timeline_)
90 AddControllerToTimeline();
91 }
92
93 void AnimationPlayer::set_layer_animation_delegate(
94 AnimationDelegate* delegate) {
95 layer_animation_delegate_ = delegate;
96 if (layer_animation_controller_)
97 layer_animation_controller_->set_layer_animation_delegate(delegate);
98 }
99
100 void AnimationPlayer::AttachLayer(int layer_id) {
101 DCHECK_EQ(layer_id_, 0);
102 DCHECK_NE(layer_id, 0);
103 DCHECK(!layer_animation_controller_);
104
105 layer_id_ = layer_id;
106
107 if (animation_timeline_)
108 AddControllerToTimeline();
109 }
110
111 void AnimationPlayer::DetachLayer() {
112 DCHECK_NE(layer_id_, 0);
113
114 if (animation_timeline_)
115 RemoveControllerFromTimeline();
116
117 layer_animation_controller_ = nullptr;
118 layer_id_ = 0;
119 }
120
121 void AnimationPlayer::AddControllerToTimeline() {
122 DCHECK(layer_id_);
123 DCHECK(animation_host_);
124
125 AnimationRegistrar* registrar = animation_host_->animation_registrar();
126 DCHECK(registrar);
127
128 layer_animation_controller_ =
129 registrar->GetAnimationControllerForId(layer_id_);
130 layer_animation_controller_->SetAnimationRegistrar(registrar);
131
132 DCHECK(animation_host_->layer_tree_mutators_client());
133 if (animation_host_->layer_tree_mutators_client()->IsLayerInActiveTree(
134 layer_id_))
135 CreateActiveValueObserver();
136 if (animation_host_->layer_tree_mutators_client()->IsLayerInPendingTree(
137 layer_id_))
138 CreatePendingValueObserver();
139
140 animation_host_->RegisterPlayerForLayer(layer_id_, this);
141 }
142
143 void AnimationPlayer::RemoveControllerFromTimeline() {
144 DCHECK(layer_id_);
145 DCHECK(animation_host_);
146 animation_host_->UnregisterPlayerForLayer(layer_id_, this);
147
148 DestroyPendingValueObserver();
149 DestroyActiveValueObserver();
150 if (layer_animation_controller_)
151 layer_animation_controller_->SetAnimationRegistrar(nullptr);
152 layer_animation_controller_ = nullptr;
153 }
154
155 void AnimationPlayer::LayerRegistered(int layer_id, bool is_active_tree) {
156 DCHECK_EQ(layer_id_, layer_id);
157 if (is_active_tree && layer_animation_controller_) {
158 if (!active_value_observer_)
159 CreateActiveValueObserver();
160 } else {
161 if (!pending_value_observer_)
162 CreatePendingValueObserver();
163 }
164 }
165
166 void AnimationPlayer::LayerUnregistered(int layer_id, bool is_active_tree) {
167 DCHECK_EQ(layer_id_, layer_id);
168 is_active_tree ? DestroyActiveValueObserver() : DestroyPendingValueObserver();
169 }
170
171 void AnimationPlayer::AddAnimation(scoped_ptr<Animation> animation) {
172 DCHECK(layer_animation_controller_);
173 layer_animation_controller_->AddAnimation(animation.Pass());
174 SetNeedsCommit();
175 }
176
177 void AnimationPlayer::PauseAnimation(int animation_id, double time_offset) {
178 DCHECK(layer_animation_controller_);
179 layer_animation_controller_->PauseAnimation(
180 animation_id, base::TimeDelta::FromSecondsD(time_offset));
181 SetNeedsCommit();
182 }
183
184 void AnimationPlayer::RemoveAnimation(int animation_id) {
185 if (layer_animation_controller_) {
186 layer_animation_controller_->RemoveAnimation(animation_id);
187 SetNeedsCommit();
188 }
189 }
190
191 void AnimationPlayer::PushPropertiesTo(AnimationPlayer* player_impl) {
192 if (!layer_animation_controller()) {
193 if (player_impl->layer_animation_controller())
194 player_impl->DetachLayer();
195 return;
196 }
197
198 DCHECK_NE(layer_id_, 0);
199 if (!player_impl->layer_animation_controller())
200 player_impl->AttachLayer(layer_id_);
201
202 DCHECK(player_impl->layer_animation_controller());
203 layer_animation_controller_->PushAnimationUpdatesTo(
204 player_impl->layer_animation_controller());
205 }
206
207 void AnimationPlayer::SetNeedsCommit() {
208 DCHECK(animation_host_);
209 animation_host_->SetNeedsCommit();
210 }
211
212 void AnimationPlayer::SetFilterMutated(bool active_tree,
213 const FilterOperations& filters) {
214 DCHECK(layer_id_);
215 if (animation_host()) {
216 DCHECK(animation_host()->layer_tree_mutators_client());
217 animation_host()->layer_tree_mutators_client()->SetLayerFilterMutated(
218 layer_id_, active_tree, filters);
219 }
220 }
221
222 void AnimationPlayer::SetOpacityMutated(bool active_tree, float opacity) {
223 DCHECK(layer_id_);
224 if (animation_host()) {
225 DCHECK(animation_host()->layer_tree_mutators_client());
226 animation_host()->layer_tree_mutators_client()->SetLayerOpacityMutated(
227 layer_id_, active_tree, opacity);
228 }
229 }
230
231 void AnimationPlayer::SetTransformMutated(bool active_tree,
232 const gfx::Transform& transform) {
233 DCHECK(layer_id_);
234 if (animation_host()) {
235 DCHECK(animation_host()->layer_tree_mutators_client());
236 animation_host()->layer_tree_mutators_client()->SetLayerTransformMutated(
Ian Vollick 2015/05/05 03:52:06 If I understand correctly, this will cause us to f
loyso (OOO) 2015/05/05 06:51:18 Yes, that's a hash_map look up. We discussed that
Ian Vollick 2015/05/07 13:58:42 I think you're right that we won't have that many
loyso (OOO) 2015/05/08 01:04:34 May I set this as a separate perf and optimization
Ian Vollick 2015/05/08 14:58:22 Since these results could affect the design of thi
loyso (OOO) 2015/06/22 07:48:51 Done. https://codereview.chromium.org/1172583003/
237 layer_id_, active_tree, transform);
238 }
239 }
240
241 void AnimationPlayer::SetScrollOffsetMutated(
242 bool active_tree,
243 const gfx::ScrollOffset& scroll_offset) {
244 DCHECK(layer_id_);
245 if (animation_host()) {
246 DCHECK(animation_host()->layer_tree_mutators_client());
247 animation_host()->layer_tree_mutators_client()->SetLayerScrollOffsetMutated(
248 layer_id_, active_tree, scroll_offset);
249 }
250 }
251
252 void AnimationPlayer::CreateActiveValueObserver() {
253 DCHECK(layer_animation_controller_);
254 DCHECK(!active_value_observer_);
255 active_value_observer_ = make_scoped_ptr(new ValueObserver(this, true));
256 layer_animation_controller_->AddValueObserver(active_value_observer_.get());
257
258 layer_animation_controller_->set_value_provider(this);
259 layer_animation_controller_->set_layer_animation_delegate(
260 layer_animation_delegate_);
261 }
262
263 void AnimationPlayer::DestroyActiveValueObserver() {
264 if (layer_animation_controller_ && active_value_observer_)
265 layer_animation_controller_->RemoveValueObserver(
266 active_value_observer_.get());
267 active_value_observer_ = nullptr;
268
269 if (layer_animation_controller_) {
270 layer_animation_controller_->remove_value_provider(this);
271 layer_animation_controller_->remove_layer_animation_delegate(
272 layer_animation_delegate_);
273 }
274 }
275
276 void AnimationPlayer::CreatePendingValueObserver() {
277 DCHECK(layer_animation_controller_);
278 DCHECK(!pending_value_observer_);
279 pending_value_observer_ = make_scoped_ptr(new ValueObserver(this, false));
280 layer_animation_controller_->AddValueObserver(pending_value_observer_.get());
281 }
282
283 void AnimationPlayer::DestroyPendingValueObserver() {
284 if (layer_animation_controller_ && pending_value_observer_)
285 layer_animation_controller_->RemoveValueObserver(
286 pending_value_observer_.get());
287 pending_value_observer_ = nullptr;
288 }
289
290 gfx::ScrollOffset AnimationPlayer::ScrollOffsetForAnimation() const {
291 // TODO(loyso): implement it.
292 return gfx::ScrollOffset();
293 }
294
295 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698