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 #include "cc/animation/layer_animation_value_provider.h" 13 #include "cc/output/filter_operations.h" 14 #include "cc/test/geometry_test_utils.h" 15 16 namespace cc { 17 class LayerImpl; 18 class Layer; 19 } 20 21 namespace cc { 22 23 class FakeFloatAnimationCurve : public FloatAnimationCurve { 24 public: 25 FakeFloatAnimationCurve(); 26 explicit FakeFloatAnimationCurve(double duration); 27 virtual ~FakeFloatAnimationCurve(); 28 29 virtual double Duration() const OVERRIDE; 30 virtual float GetValue(double now) const OVERRIDE; 31 virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE; 32 33 private: 34 double duration_; 35 }; 36 37 class FakeTransformTransition : public TransformAnimationCurve { 38 public: 39 explicit FakeTransformTransition(double duration); 40 virtual ~FakeTransformTransition(); 41 42 virtual double Duration() const OVERRIDE; 43 virtual gfx::Transform GetValue(double time) const OVERRIDE; 44 virtual bool AnimatedBoundsForBox(const gfx::BoxF& box, 45 gfx::BoxF* bounds) const OVERRIDE; 46 virtual bool AffectsScale() const OVERRIDE; 47 virtual bool IsTranslation() const OVERRIDE; 48 virtual bool MaximumTargetScale(bool forward_direction, 49 float* max_scale) const OVERRIDE; 50 51 virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE; 52 53 private: 54 double duration_; 55 }; 56 57 class FakeFloatTransition : public FloatAnimationCurve { 58 public: 59 FakeFloatTransition(double duration, float from, float to); 60 virtual ~FakeFloatTransition(); 61 62 virtual double Duration() const OVERRIDE; 63 virtual float GetValue(double time) const OVERRIDE; 64 65 virtual scoped_ptr<AnimationCurve> Clone() const OVERRIDE; 66 67 private: 68 double duration_; 69 float from_; 70 float to_; 71 }; 72 73 class FakeLayerAnimationValueObserver : public LayerAnimationValueObserver { 74 public: 75 FakeLayerAnimationValueObserver(); 76 virtual ~FakeLayerAnimationValueObserver(); 77 78 // LayerAnimationValueObserver implementation 79 virtual void OnFilterAnimated(const FilterOperations& filters) OVERRIDE; 80 virtual void OnOpacityAnimated(float opacity) OVERRIDE; 81 virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE; 82 virtual void OnScrollOffsetAnimated( 83 const gfx::Vector2dF& scroll_offset) OVERRIDE; 84 virtual void OnAnimationWaitingForDeletion() OVERRIDE; 85 virtual bool IsActive() const OVERRIDE; 86 filters()87 const FilterOperations& filters() const { return filters_; } opacity()88 float opacity() const { return opacity_; } transform()89 const gfx::Transform& transform() const { return transform_; } scroll_offset()90 gfx::Vector2dF scroll_offset() { return scroll_offset_; } 91 animation_waiting_for_deletion()92 bool animation_waiting_for_deletion() { 93 return animation_waiting_for_deletion_; 94 } 95 96 private: 97 FilterOperations filters_; 98 float opacity_; 99 gfx::Transform transform_; 100 gfx::Vector2dF scroll_offset_; 101 bool animation_waiting_for_deletion_; 102 }; 103 104 class FakeInactiveLayerAnimationValueObserver 105 : public FakeLayerAnimationValueObserver { 106 public: 107 virtual bool IsActive() const OVERRIDE; 108 }; 109 110 class FakeLayerAnimationValueProvider : public LayerAnimationValueProvider { 111 public: 112 virtual gfx::Vector2dF ScrollOffsetForAnimation() const OVERRIDE; 113 set_scroll_offset(const gfx::Vector2dF & scroll_offset)114 void set_scroll_offset(const gfx::Vector2dF& scroll_offset) { 115 scroll_offset_ = scroll_offset; 116 } 117 118 private: 119 gfx::Vector2dF scroll_offset_; 120 }; 121 122 int AddOpacityTransitionToController(LayerAnimationController* controller, 123 double duration, 124 float start_opacity, 125 float end_opacity, 126 bool use_timing_function); 127 128 int AddAnimatedTransformToController(LayerAnimationController* controller, 129 double duration, 130 int delta_x, 131 int delta_y); 132 133 int AddAnimatedFilterToController(LayerAnimationController* controller, 134 double duration, 135 float start_brightness, 136 float end_brightness); 137 138 int AddOpacityTransitionToLayer(Layer* layer, 139 double duration, 140 float start_opacity, 141 float end_opacity, 142 bool use_timing_function); 143 144 int AddOpacityTransitionToLayer(LayerImpl* layer, 145 double duration, 146 float start_opacity, 147 float end_opacity, 148 bool use_timing_function); 149 150 int AddAnimatedTransformToLayer(Layer* layer, 151 double duration, 152 int delta_x, 153 int delta_y); 154 155 int AddAnimatedTransformToLayer(LayerImpl* layer, 156 double duration, 157 int delta_x, 158 int delta_y); 159 160 int AddAnimatedTransformToLayer(Layer* layer, 161 double duration, 162 TransformOperations start_operations, 163 TransformOperations operations); 164 165 int AddAnimatedTransformToLayer(LayerImpl* layer, 166 double duration, 167 TransformOperations start_operations, 168 TransformOperations operations); 169 170 int AddAnimatedFilterToLayer(Layer* layer, 171 double duration, 172 float start_brightness, 173 float end_brightness); 174 175 int AddAnimatedFilterToLayer(LayerImpl* layer, 176 double duration, 177 float start_brightness, 178 float end_brightness); 179 180 } // namespace cc 181 182 #endif // CC_TEST_ANIMATION_TEST_COMMON_H_ 183