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#ifndef CC_TEST_ANIMATION_TEST_COMMON_H_
6#define CC_TEST_ANIMATION_TEST_COMMON_H_
7
8#include "cc/animation/animation.h"
9#include "cc/animation/animation_curve.h"
10#include "cc/animation/layer_animation_controller.h"
11#include "cc/animation/layer_animation_value_observer.h"
12
13namespace cc {
14class LayerImpl;
15class Layer;
16}
17
18namespace cc {
19
20class FakeFloatAnimationCurve : public FloatAnimationCurve {
21 public:
22  FakeFloatAnimationCurve();
23  explicit FakeFloatAnimationCurve(double duration);
24  virtual ~FakeFloatAnimationCurve();
25
26  virtual double Duration() const OVERRIDE;
27  virtual float GetValue(double now) const OVERRIDE;
28  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
29
30 private:
31  double duration_;
32};
33
34class FakeTransformTransition : public TransformAnimationCurve {
35 public:
36  explicit FakeTransformTransition(double duration);
37  virtual ~FakeTransformTransition();
38
39  virtual double Duration() const OVERRIDE;
40  virtual gfx::Transform GetValue(double time) const OVERRIDE;
41
42  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
43
44 private:
45  double duration_;
46};
47
48class FakeFloatTransition : public FloatAnimationCurve {
49 public:
50  FakeFloatTransition(double duration, float from, float to);
51  virtual ~FakeFloatTransition();
52
53  virtual double Duration() const OVERRIDE;
54  virtual float GetValue(double time) const OVERRIDE;
55
56  virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE;
57
58 private:
59  double duration_;
60  float from_;
61  float to_;
62};
63
64class FakeLayerAnimationValueObserver : public LayerAnimationValueObserver {
65 public:
66  FakeLayerAnimationValueObserver();
67  virtual ~FakeLayerAnimationValueObserver();
68
69  // LayerAnimationValueObserver implementation
70  virtual void OnOpacityAnimated(float opacity) OVERRIDE;
71  virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE;
72  virtual bool IsActive() const OVERRIDE;
73
74  float opacity() const  { return opacity_; }
75  const gfx::Transform& transform() const { return transform_; }
76
77 private:
78  float opacity_;
79  gfx::Transform transform_;
80};
81
82class FakeInactiveLayerAnimationValueObserver
83    : public FakeLayerAnimationValueObserver {
84 public:
85  virtual bool IsActive() const OVERRIDE;
86};
87
88int AddOpacityTransitionToController(LayerAnimationController* controller,
89                                     double duration,
90                                     float start_opacity,
91                                     float end_opacity,
92                                     bool use_timing_function);
93
94int AddAnimatedTransformToController(LayerAnimationController* controller,
95                                     double duration,
96                                     int delta_x,
97                                     int delta_y);
98
99int AddOpacityTransitionToLayer(Layer* layer,
100                                double duration,
101                                float start_opacity,
102                                float end_opacity,
103                                bool use_timing_function);
104
105int AddOpacityTransitionToLayer(LayerImpl* layer,
106                                double duration,
107                                float start_opacity,
108                                float end_opacity,
109                                bool use_timing_function);
110
111int AddAnimatedTransformToLayer(Layer* layer,
112                                double duration,
113                                int delta_x,
114                                int delta_y);
115
116int AddAnimatedTransformToLayer(LayerImpl* layer,
117                                double duration,
118                                int delta_x,
119                                int delta_y);
120
121}  // namespace cc
122
123#endif  // CC_TEST_ANIMATION_TEST_COMMON_H_
124