cc/test/animation_test_common.h

   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
  13 namespace cc {
  14 class LayerImpl;
  15 class Layer;
  16 }
  17
  18 namespace cc {
  19
  20 class 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
  34 class 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
  48 class 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
  64 class 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
  82 int AddOpacityTransitionToController(LayerAnimationController* controller,
  83                                      double duration,
  84                                      float start_opacity,
  85                                      float end_opacity,
  86                                      bool use_timing_function);
  87
  88 int AddAnimatedTransformToController(LayerAnimationController* controller,
  89                                      double duration,
  90                                      int delta_x,
  91                                      int delta_y);
  92
  93 int AddOpacityTransitionToLayer(Layer* layer,
  94                                 double duration,
  95                                 float start_opacity,
  96                                 float end_opacity,
  97                                 bool use_timing_function);
  98
  99 int AddOpacityTransitionToLayer(LayerImpl* layer,
 100                                 double duration,
 101                                 float start_opacity,
 102                                 float end_opacity,
 103                                 bool use_timing_function);
 104
 105 int AddAnimatedTransformToLayer(Layer* layer,
 106                                 double duration,
 107                                 int delta_x,
 108                                 int delta_y);
 109
 110 int AddAnimatedTransformToLayer(LayerImpl* layer,
 111                                 double duration,
 112                                 int delta_x,
 113                                 int delta_y);
 114
 115 }  // namespace cc
 116
 117 #endif  // CC_TEST_ANIMATION_TEST_COMMON_H_