animation_test_common.cc revision f2477e01787aa58f445919b809d89e252beef54f 
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/test/animation_test_common.h"
6
7#include "cc/animation/animation_id_provider.h"
8#include "cc/animation/keyframed_animation_curve.h"
9#include "cc/animation/layer_animation_controller.h"
10#include "cc/animation/transform_operations.h"
11#include "cc/layers/layer.h"
12#include "cc/layers/layer_impl.h"
13
14using cc::Animation;
15using cc::AnimationCurve;
16using cc::EaseTimingFunction;
17using cc::FloatKeyframe;
18using cc::KeyframedFloatAnimationCurve;
19using cc::KeyframedTransformAnimationCurve;
20using cc::TimingFunction;
21using cc::TransformKeyframe;
22
23namespace cc {
24
25template <class Target>
26int AddOpacityTransition(Target* target,
27                         double duration,
28                         float start_opacity,
29                         float end_opacity,
30                         bool use_timing_function) {
31  scoped_ptr<KeyframedFloatAnimationCurve>
32      curve(KeyframedFloatAnimationCurve::Create());
33
34  scoped_ptr<TimingFunction> func;
35  if (!use_timing_function)
36    func = EaseTimingFunction::Create();
37  if (duration > 0.0)
38    curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
39  curve->AddKeyframe(FloatKeyframe::Create(duration,
40                                           end_opacity,
41                                           scoped_ptr<cc::TimingFunction>()));
42
43  int id = AnimationIdProvider::NextAnimationId();
44
45  scoped_ptr<Animation> animation(Animation::Create(
46      curve.PassAs<AnimationCurve>(),
47      id,
48      AnimationIdProvider::NextGroupId(),
49      Animation::Opacity));
50  animation->set_needs_synchronized_start_time(true);
51
52  target->AddAnimation(animation.Pass());
53  return id;
54}
55
56template <class Target>
57int AddAnimatedTransform(Target* target,
58                         double duration,
59                         int delta_x,
60                         int delta_y) {
61  scoped_ptr<KeyframedTransformAnimationCurve>
62      curve(KeyframedTransformAnimationCurve::Create());
63
64  if (duration > 0.0) {
65    TransformOperations start_operations;
66    start_operations.AppendTranslate(delta_x, delta_y, 0.0);
67    curve->AddKeyframe(TransformKeyframe::Create(
68        0.0,
69        start_operations,
70        scoped_ptr<cc::TimingFunction>()));
71  }
72
73  TransformOperations operations;
74  operations.AppendTranslate(delta_x, delta_y, 0.0);
75  curve->AddKeyframe(TransformKeyframe::Create(
76      duration,
77      operations,
78      scoped_ptr<cc::TimingFunction>()));
79
80  int id = AnimationIdProvider::NextAnimationId();
81
82  scoped_ptr<Animation> animation(Animation::Create(
83      curve.PassAs<AnimationCurve>(),
84      id,
85      AnimationIdProvider::NextGroupId(),
86      Animation::Transform));
87  animation->set_needs_synchronized_start_time(true);
88
89  target->AddAnimation(animation.Pass());
90  return id;
91}
92
93template <class Target>
94int AddAnimatedFilter(Target* target,
95                      double duration,
96                      float start_brightness,
97                      float end_brightness) {
98  scoped_ptr<KeyframedFilterAnimationCurve>
99      curve(KeyframedFilterAnimationCurve::Create());
100
101  if (duration > 0.0) {
102    FilterOperations start_filters;
103    start_filters.Append(
104        FilterOperation::CreateBrightnessFilter(start_brightness));
105    curve->AddKeyframe(FilterKeyframe::Create(
106        0.0, start_filters, scoped_ptr<cc::TimingFunction>()));
107  }
108
109  FilterOperations filters;
110  filters.Append(FilterOperation::CreateBrightnessFilter(end_brightness));
111  curve->AddKeyframe(FilterKeyframe::Create(
112      duration, filters, scoped_ptr<cc::TimingFunction>()));
113
114  int id = AnimationIdProvider::NextAnimationId();
115
116  scoped_ptr<Animation> animation(Animation::Create(
117      curve.PassAs<AnimationCurve>(),
118      id,
119      AnimationIdProvider::NextGroupId(),
120      Animation::Filter));
121  animation->set_needs_synchronized_start_time(true);
122
123  target->AddAnimation(animation.Pass());
124  return id;
125}
126
127FakeFloatAnimationCurve::FakeFloatAnimationCurve()
128    : duration_(1.0) {}
129
130FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
131    : duration_(duration) {}
132
133FakeFloatAnimationCurve::~FakeFloatAnimationCurve() {}
134
135double FakeFloatAnimationCurve::Duration() const {
136  return duration_;
137}
138
139float FakeFloatAnimationCurve::GetValue(double now) const {
140  return 0.0f;
141}
142
143scoped_ptr<cc::AnimationCurve> FakeFloatAnimationCurve::Clone() const {
144  return make_scoped_ptr(
145      new FakeFloatAnimationCurve).PassAs<cc::AnimationCurve>();
146}
147
148FakeTransformTransition::FakeTransformTransition(double duration)
149    : duration_(duration) {}
150
151FakeTransformTransition::~FakeTransformTransition() {}
152
153double FakeTransformTransition::Duration() const {
154  return duration_;
155}
156
157gfx::Transform FakeTransformTransition::GetValue(double time) const {
158  return gfx::Transform();
159}
160
161bool FakeTransformTransition::AnimatedBoundsForBox(const gfx::BoxF& box,
162                                                   gfx::BoxF* bounds) const {
163  return false;
164}
165
166scoped_ptr<cc::AnimationCurve> FakeTransformTransition::Clone() const {
167  return make_scoped_ptr(
168      new FakeTransformTransition(*this)).PassAs<cc::AnimationCurve>();
169}
170
171
172FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
173    : duration_(duration), from_(from), to_(to) {}
174
175FakeFloatTransition::~FakeFloatTransition() {}
176
177double FakeFloatTransition::Duration() const {
178  return duration_;
179}
180
181float FakeFloatTransition::GetValue(double time) const {
182  time /= duration_;
183  if (time >= 1.0)
184    time = 1.0;
185  return (1.0 - time) * from_ + time * to_;
186}
187
188FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
189    : opacity_(0.0f),
190      animation_waiting_for_deletion_(false) {}
191
192FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {}
193
194void FakeLayerAnimationValueObserver::OnFilterAnimated(
195    const FilterOperations& filters) {
196  filters_ = filters;
197}
198
199void FakeLayerAnimationValueObserver::OnOpacityAnimated(float opacity) {
200  opacity_ = opacity;
201}
202
203void FakeLayerAnimationValueObserver::OnTransformAnimated(
204    const gfx::Transform& transform) {
205  transform_ = transform;
206}
207
208void FakeLayerAnimationValueObserver::OnAnimationWaitingForDeletion() {
209  animation_waiting_for_deletion_ = true;
210}
211
212bool FakeLayerAnimationValueObserver::IsActive() const {
213  return true;
214}
215
216bool FakeInactiveLayerAnimationValueObserver::IsActive() const {
217  return false;
218}
219
220scoped_ptr<cc::AnimationCurve> FakeFloatTransition::Clone() const {
221  return make_scoped_ptr(
222      new FakeFloatTransition(*this)).PassAs<cc::AnimationCurve>();
223}
224
225int AddOpacityTransitionToController(cc::LayerAnimationController* controller,
226                                     double duration,
227                                     float start_opacity,
228                                     float end_opacity,
229                                     bool use_timing_function) {
230  return AddOpacityTransition(controller,
231                              duration,
232                              start_opacity,
233                              end_opacity,
234                              use_timing_function);
235}
236
237int AddAnimatedTransformToController(cc::LayerAnimationController* controller,
238                                     double duration,
239                                     int delta_x,
240                                     int delta_y) {
241  return AddAnimatedTransform(controller,
242                              duration,
243                              delta_x,
244                              delta_y);
245}
246
247int AddAnimatedFilterToController(cc::LayerAnimationController* controller,
248                                  double duration,
249                                  float start_brightness,
250                                  float end_brightness) {
251  return AddAnimatedFilter(
252      controller, duration, start_brightness, end_brightness);
253}
254
255int AddOpacityTransitionToLayer(cc::Layer* layer,
256                                double duration,
257                                float start_opacity,
258                                float end_opacity,
259                                bool use_timing_function) {
260  return AddOpacityTransition(layer,
261                              duration,
262                              start_opacity,
263                              end_opacity,
264                              use_timing_function);
265}
266
267int AddOpacityTransitionToLayer(cc::LayerImpl* layer,
268                                double duration,
269                                float start_opacity,
270                                float end_opacity,
271                                bool use_timing_function) {
272  return AddOpacityTransition(layer->layer_animation_controller(),
273                              duration,
274                              start_opacity,
275                              end_opacity,
276                              use_timing_function);
277}
278
279int AddAnimatedTransformToLayer(cc::Layer* layer,
280                                double duration,
281                                int delta_x,
282                                int delta_y) {
283  return AddAnimatedTransform(layer, duration, delta_x, delta_y);
284}
285
286int AddAnimatedTransformToLayer(cc::LayerImpl* layer,
287                                double duration,
288                                int delta_x,
289                                int delta_y) {
290  return AddAnimatedTransform(layer->layer_animation_controller(),
291                              duration,
292                              delta_x,
293                              delta_y);
294}
295
296int AddAnimatedFilterToLayer(cc::Layer* layer,
297                             double duration,
298                             float start_brightness,
299                             float end_brightness) {
300  return AddAnimatedFilter(layer, duration, start_brightness, end_brightness);
301}
302
303int AddAnimatedFilterToLayer(cc::LayerImpl* layer,
304                             double duration,
305                             float start_brightness,
306                             float end_brightness) {
307  return AddAnimatedFilter(layer->layer_animation_controller(),
308                           duration,
309                           start_brightness,
310                           end_brightness);
311}
312
313}  // namespace cc
314