cc/test/animation_test_common.cc

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