src/third_party/WebKit/Source/core/animation/CompositorAnimationsTest.cpp

   1 /*
   2  * Copyright (c) 2013, Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32
  33 #include "core/animation/CompositorAnimations.h"
  34
  35 #include "core/animation/CompositorAnimationsImpl.h"
  36 #include "core/animation/CompositorAnimationsTestHelper.h"
  37 #include "core/animation/animatable/AnimatableDouble.h"
  38 #include "core/animation/animatable/AnimatableFilterOperations.h"
  39 #include "core/animation/animatable/AnimatableTransform.h"
  40 #include "core/animation/animatable/AnimatableValueTestHelper.h"
  41 #include "platform/geometry/FloatBox.h"
  42 #include "platform/geometry/IntSize.h"
  43 #include "platform/graphics/filters/FilterOperations.h"
  44 #include "platform/transforms/TransformOperations.h"
  45 #include "platform/transforms/TranslateTransformOperation.h"
  46 #include "public/platform/WebCompositorAnimation.h"
  47 #include "wtf/HashFunctions.h"
  48 #include "wtf/OwnPtr.h"
  49 #include "wtf/PassOwnPtr.h"
  50 #include "wtf/PassRefPtr.h"
  51 #include "wtf/RefPtr.h"
  52
  53 #include <gmock/gmock.h>
  54 #include <gtest/gtest.h>
  55
  56 namespace blink {
  57
  58 using ::testing::CloneToPassOwnPtr;
  59 using ::testing::ExpectationSet;
  60 using ::testing::Ref;
  61 using ::testing::Return;
  62 using ::testing::_;
  63
  64 class AnimationCompositorAnimationsTest : public AnimationCompositorAnimationsTestBase {
  65 protected:
  66     RefPtr<TimingFunction> m_linearTimingFunction;
  67     RefPtr<TimingFunction> m_cubicEaseTimingFunction;
  68     RefPtr<TimingFunction> m_cubicCustomTimingFunction;
  69     RefPtr<TimingFunction> m_stepTimingFunction;
  70
  71     Timing m_timing;
  72     CompositorAnimationsImpl::CompositorTiming m_compositorTiming;
  73     OwnPtrWillBePersistent<AnimatableValueKeyframeVector> m_keyframeVector2;
  74     RefPtrWillBePersistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect2;
  75     OwnPtrWillBePersistent<AnimatableValueKeyframeVector> m_keyframeVector5;
  76     RefPtrWillBePersistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect5;
  77
  78     virtual void SetUp()
  79     {
  80         AnimationCompositorAnimationsTestBase::SetUp();
  81
  82         m_linearTimingFunction = LinearTimingFunction::shared();
  83         m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
  84         m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3, 4);
  85         m_stepTimingFunction = StepsTimingFunction::create(1, StepsTimingFunction::End);
  86
  87         m_timing = createCompositableTiming();
  88         m_compositorTiming = CompositorAnimationsImpl::CompositorTiming();
  89         // Make sure the CompositableTiming is really compositable, otherwise
  90         // most other tests will fail.
  91         ASSERT(convertTimingForCompositor(m_timing, m_compositorTiming));
  92
  93         m_keyframeVector2 = createCompositableFloatKeyframeVector(2);
  94         m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
  95
  96         m_keyframeVector5 = createCompositableFloatKeyframeVector(5);
  97         m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
  98     }
  99
 100 public:
 101
 102     bool convertTimingForCompositor(const Timing& t, CompositorAnimationsImpl::CompositorTiming& out)
 103     {
 104         return CompositorAnimationsImpl::convertTimingForCompositor(t, 0, out, 1);
 105     }
 106     bool isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect)
 107     {
 108         return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, effect, 1);
 109     }
 110     void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations)
 111     {
 112         return getAnimationOnCompositor(timing, effect, animations, 1);
 113     }
 114     void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations, double playerPlaybackRate)
 115     {
 116         return CompositorAnimationsImpl::getAnimationOnCompositor(timing, std::numeric_limits<double>::quiet_NaN(), 0, effect, animations, playerPlaybackRate);
 117     }
 118     bool getAnimationBounds(FloatBox& boundingBox, const AnimationEffect& effect, double minValue, double maxValue)
 119     {
 120         return CompositorAnimations::instance()->getAnimatedBoundingBox(boundingBox, effect, minValue, maxValue);
 121     }
 122
 123     bool duplicateSingleKeyframeAndTestIsCandidateOnResult(AnimatableValueKeyframe* frame)
 124     {
 125         EXPECT_EQ(frame->offset(), 0);
 126         AnimatableValueKeyframeVector frames;
 127         RefPtrWillBeRawPtr<Keyframe> second = frame->cloneWithOffset(1);
 128
 129         frames.append(frame);
 130         frames.append(toAnimatableValueKeyframe(second.get()));
 131         return isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(frames).get());
 132     }
 133
 134     // -------------------------------------------------------------------
 135
 136     Timing createCompositableTiming()
 137     {
 138         Timing timing;
 139         timing.startDelay = 0;
 140         timing.fillMode = Timing::FillModeNone;
 141         timing.iterationStart = 0;
 142         timing.iterationCount = 1;
 143         timing.iterationDuration = 1.0;
 144         timing.playbackRate = 1.0;
 145         timing.direction = Timing::PlaybackDirectionNormal;
 146         ASSERT(m_linearTimingFunction);
 147         timing.timingFunction = m_linearTimingFunction;
 148         return timing;
 149     }
 150
 151     PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> createReplaceOpKeyframe(CSSPropertyID id, AnimatableValue* value, double offset = 0)
 152     {
 153         RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframe = AnimatableValueKeyframe::create();
 154         keyframe->setPropertyValue(id, value);
 155         keyframe->setComposite(AnimationEffect::CompositeReplace);
 156         keyframe->setOffset(offset);
 157         keyframe->setEasing(LinearTimingFunction::shared());
 158         return keyframe;
 159     }
 160
 161     PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> createDefaultKeyframe(CSSPropertyID id, AnimationEffect::CompositeOperation op, double offset = 0)
 162     {
 163         RefPtrWillBeRawPtr<AnimatableValue> value = nullptr;
 164         if (id == CSSPropertyTransform)
 165             value = AnimatableTransform::create(TransformOperations());
 166         else
 167             value = AnimatableDouble::create(10.0);
 168
 169         RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframe = createReplaceOpKeyframe(id, value.get(), offset);
 170         keyframe->setComposite(op);
 171         return keyframe;
 172     }
 173
 174     PassOwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> createCompositableFloatKeyframeVector(size_t n)
 175     {
 176         Vector<double> values;
 177         for (size_t i = 0; i < n; i++) {
 178             values.append(static_cast<double>(i));
 179         }
 180         return createCompositableFloatKeyframeVector(values);
 181     }
 182
 183     PassOwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> createCompositableFloatKeyframeVector(Vector<double>& values)
 184     {
 185         OwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> frames = adoptPtrWillBeNoop(new AnimatableValueKeyframeVector);
 186         for (size_t i = 0; i < values.size(); i++) {
 187             double offset = 1.0 / (values.size() - 1) * i;
 188             RefPtrWillBeRawPtr<AnimatableDouble> value = AnimatableDouble::create(values[i]);
 189             frames->append(createReplaceOpKeyframe(CSSPropertyOpacity, value.get(), offset).get());
 190         }
 191         return frames.release();
 192     }
 193
 194     PassOwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> createCompositableTransformKeyframeVector(const Vector<TransformOperations>& values)
 195     {
 196         OwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> frames = adoptPtrWillBeNoop(new AnimatableValueKeyframeVector);
 197         for (size_t i = 0; i < values.size(); ++i) {
 198             double offset = 1.0f / (values.size() - 1) * i;
 199             RefPtrWillBeRawPtr<AnimatableTransform> value = AnimatableTransform::create(values[i]);
 200             frames->append(createReplaceOpKeyframe(CSSPropertyTransform, value.get(), offset).get());
 201         }
 202         return frames.release();
 203     }
 204
 205     PassRefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> createKeyframeEffectModel(PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpFrom, PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpTo, PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpC = nullptr, PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpD = nullptr)
 206     {
 207         RefPtrWillBeRawPtr<AnimatableValueKeyframe> from = prpFrom;
 208         RefPtrWillBeRawPtr<AnimatableValueKeyframe> to = prpTo;
 209         RefPtrWillBeRawPtr<AnimatableValueKeyframe> c = prpC;
 210         RefPtrWillBeRawPtr<AnimatableValueKeyframe> d = prpD;
 211
 212         EXPECT_EQ(from->offset(), 0);
 213         AnimatableValueKeyframeVector frames;
 214         frames.append(from);
 215         EXPECT_LE(from->offset(), to->offset());
 216         frames.append(to);
 217         if (c) {
 218             EXPECT_LE(to->offset(), c->offset());
 219             frames.append(c);
 220         }
 221         if (d) {
 222             frames.append(d);
 223             EXPECT_LE(c->offset(), d->offset());
 224             EXPECT_EQ(d->offset(), 1.0);
 225         } else {
 226             EXPECT_EQ(to->offset(), 1.0);
 227         }
 228         if (!HasFatalFailure()) {
 229             return AnimatableValueKeyframeEffectModel::create(frames);
 230         }
 231         return nullptr;
 232     }
 233
 234 };
 235
 236 // -----------------------------------------------------------------------
 237 // -----------------------------------------------------------------------
 238
 239 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeMultipleCSSProperties)
 240 {
 241     RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace);
 242     keyframeGoodMultiple->setPropertyValue(CSSPropertyTransform, AnimatableTransform::create(TransformOperations()).get());
 243     EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(keyframeGoodMultiple.get()));
 244
 245     RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframeBadMultipleID = createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace);
 246     keyframeBadMultipleID->setPropertyValue(CSSPropertyOpacity, AnimatableDouble::create(10.0).get());
 247     EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(keyframeBadMultipleID.get()));
 248 }
 249
 250 TEST_F(AnimationCompositorAnimationsTest, isNotCandidateForCompositorAnimationTransformDependsOnBoxSize)
 251 {
 252     TransformOperations ops;
 253     ops.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(2, Fixed), TransformOperation::TranslateX));
 254     RefPtrWillBeRawPtr<AnimatableValueKeyframe> goodKeyframe = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops).get());
 255     EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(goodKeyframe.get()));
 256
 257     ops.operations().append(TranslateTransformOperation::create(Length(50, Percent), Length(2, Fixed), TransformOperation::TranslateX));
 258     RefPtrWillBeRawPtr<AnimatableValueKeyframe> badKeyframe = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops).get());
 259     EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe.get()));
 260
 261     TransformOperations ops2;
 262     Length calcLength = Length(100, Percent).blend(Length(100, Fixed), 0.5, ValueRangeAll);
 263     ops2.operations().append(TranslateTransformOperation::create(calcLength, Length(0, Fixed), TransformOperation::TranslateX));
 264     RefPtrWillBeRawPtr<AnimatableValueKeyframe> badKeyframe2 = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops2).get());
 265     EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe2.get()));
 266 }
 267
 268 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeEffectModelMultipleFramesOkay)
 269 {
 270     AnimatableValueKeyframeVector framesSame;
 271     framesSame.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 272     framesSame.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
 273     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesSame).get()));
 274
 275     AnimatableValueKeyframeVector framesMixed;
 276     framesMixed.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 277     framesMixed.append(createDefaultKeyframe(CSSPropertyTransform, AnimationEffect::CompositeReplace, 1.0).get());
 278     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesMixed).get()));
 279 }
 280
 281 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeEffectModel)
 282 {
 283     AnimatableValueKeyframeVector framesSame;
 284     framesSame.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 0.0).get());
 285     framesSame.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 1.0).get());
 286     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesSame).get()));
 287
 288     AnimatableValueKeyframeVector framesMixedProperties;
 289     framesMixedProperties.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 290     framesMixedProperties.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 1.0).get());
 291     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesMixedProperties).get()));
 292 }
 293
 294 TEST_F(AnimationCompositorAnimationsTest, AnimatedBoundingBox)
 295 {
 296     Vector<TransformOperations> transformVector;
 297     transformVector.append(TransformOperations());
 298     transformVector.last().operations().append(TranslateTransformOperation::create(Length(0, Fixed), Length(0, Fixed), 0.0, TransformOperation::Translate3D));
 299     transformVector.append(TransformOperations());
 300     transformVector.last().operations().append(TranslateTransformOperation::create(Length(200, Fixed), Length(200, Fixed), 0.0, TransformOperation::Translate3D));
 301     OwnPtrWillBePersistent<AnimatableValueKeyframeVector> frames = createCompositableTransformKeyframeVector(transformVector);
 302     FloatBox bounds;
 303     EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), 0, 1));
 304     EXPECT_EQ(FloatBox(0.0f, 0.f, 0.0f, 200.0f, 200.0f, 0.0f), bounds);
 305     bounds = FloatBox();
 306     EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), -1, 1));
 307     EXPECT_EQ(FloatBox(-200.0f, -200.0, 0.0, 400.0f, 400.0f, 0.0f), bounds);
 308     transformVector.append(TransformOperations());
 309     transformVector.last().operations().append(TranslateTransformOperation::create(Length(-300, Fixed), Length(-400, Fixed), 1.0f, TransformOperation::Translate3D));
 310     bounds = FloatBox();
 311     frames = createCompositableTransformKeyframeVector(transformVector);
 312     EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), 0, 1));
 313     EXPECT_EQ(FloatBox(-300.0f, -400.f, 0.0f, 500.0f, 600.0f, 1.0f), bounds);
 314     bounds = FloatBox();
 315     EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), -1, 2));
 316     EXPECT_EQ(FloatBox(-1300.0f, -1600.f, 0.0f, 1500.0f, 1800.0f, 3.0f), bounds);
 317 }
 318
 319 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorStartDelay)
 320 {
 321     m_timing.iterationDuration = 20.0;
 322
 323     m_timing.startDelay = 2.0;
 324     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 325     EXPECT_DOUBLE_EQ(-2.0, m_compositorTiming.scaledTimeOffset);
 326
 327     m_timing.startDelay = -2.0;
 328     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 329     EXPECT_DOUBLE_EQ(2.0, m_compositorTiming.scaledTimeOffset);
 330 }
 331
 332 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationStart)
 333 {
 334     m_timing.iterationStart = 2.2;
 335     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 336 }
 337
 338 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationCount)
 339 {
 340     m_timing.iterationCount = 5.0;
 341     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 342     EXPECT_EQ(5, m_compositorTiming.adjustedIterationCount);
 343
 344     m_timing.iterationCount = 5.5;
 345     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 346     EXPECT_EQ(5.5, m_compositorTiming.adjustedIterationCount);
 347
 348     // EXPECT_DEATH tests are flaky on Android.
 349 #if ENABLE(ASSERT) && !OS(ANDROID)
 350     m_timing.iterationCount = -1;
 351     EXPECT_DEATH(convertTimingForCompositor(m_timing, m_compositorTiming), "");
 352 #endif
 353
 354     m_timing.iterationCount = std::numeric_limits<double>::infinity();
 355     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 356     EXPECT_EQ(-1, m_compositorTiming.adjustedIterationCount);
 357
 358     m_timing.iterationCount = std::numeric_limits<double>::infinity();
 359     m_timing.iterationDuration = 5.0;
 360     m_timing.startDelay = -6.0;
 361     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 362     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 363     EXPECT_EQ(-1, m_compositorTiming.adjustedIterationCount);
 364 }
 365
 366 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationsAndStartDelay)
 367 {
 368     m_timing.iterationCount = 4.0;
 369     m_timing.iterationDuration = 5.0;
 370
 371     m_timing.startDelay = 6.0;
 372     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 373     EXPECT_DOUBLE_EQ(-6.0, m_compositorTiming.scaledTimeOffset);
 374     EXPECT_DOUBLE_EQ(4.0, m_compositorTiming.adjustedIterationCount);
 375
 376     m_timing.startDelay = -6.0;
 377     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 378     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 379     EXPECT_DOUBLE_EQ(4.0, m_compositorTiming.adjustedIterationCount);
 380
 381     m_timing.startDelay = 21.0;
 382     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 383 }
 384
 385 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorPlaybackRate)
 386 {
 387     m_timing.playbackRate = 1.0;
 388     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 389     EXPECT_DOUBLE_EQ(1.0, m_compositorTiming.playbackRate);
 390
 391     m_timing.playbackRate = -2.3;
 392     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 393     EXPECT_DOUBLE_EQ(-2.3, m_compositorTiming.playbackRate);
 394
 395     m_timing.playbackRate = 1.6;
 396     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 397     EXPECT_DOUBLE_EQ(1.6, m_compositorTiming.playbackRate);
 398 }
 399
 400 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirection)
 401 {
 402     m_timing.direction = Timing::PlaybackDirectionNormal;
 403     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 404     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionNormal);
 405
 406     m_timing.direction = Timing::PlaybackDirectionAlternate;
 407     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 408     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate);
 409
 410     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 411     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 412     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse);
 413
 414     m_timing.direction = Timing::PlaybackDirectionReverse;
 415     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 416     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionReverse);
 417 }
 418
 419 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIterationsAndStartDelay)
 420 {
 421     m_timing.direction = Timing::PlaybackDirectionAlternate;
 422     m_timing.iterationCount = 4.0;
 423     m_timing.iterationDuration = 5.0;
 424     m_timing.startDelay = -6.0;
 425     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 426     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 427     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 428     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate);
 429
 430     m_timing.direction = Timing::PlaybackDirectionAlternate;
 431     m_timing.iterationCount = 4.0;
 432     m_timing.iterationDuration = 5.0;
 433     m_timing.startDelay = -11.0;
 434     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 435     EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset);
 436     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 437     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate);
 438
 439     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 440     m_timing.iterationCount = 4.0;
 441     m_timing.iterationDuration = 5.0;
 442     m_timing.startDelay = -6.0;
 443     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 444     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 445     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 446     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse);
 447
 448     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 449     m_timing.iterationCount = 4.0;
 450     m_timing.iterationDuration = 5.0;
 451     m_timing.startDelay = -11.0;
 452     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 453     EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset);
 454     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 455     EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse);
 456 }
 457
 458 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingTimingFunctionPassThru)
 459 {
 460     m_timing.timingFunction = m_stepTimingFunction;
 461     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 462 }
 463
 464 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionLinear)
 465 {
 466     m_timing.timingFunction = m_linearTimingFunction;
 467     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 468     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 469 }
 470
 471 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionCubic)
 472 {
 473     m_timing.timingFunction = m_cubicEaseTimingFunction;
 474     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 475     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 476
 477     m_timing.timingFunction = m_cubicCustomTimingFunction;
 478     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 479     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 480 }
 481
 482 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionSteps)
 483 {
 484     m_timing.timingFunction = m_stepTimingFunction;
 485     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 486     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 487 }
 488
 489 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedLinear)
 490 {
 491     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 492     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 493 }
 494
 495 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorNonLinearTimingFunctionOnFirstFrame)
 496 {
 497     m_timing.timingFunction = m_cubicEaseTimingFunction;
 498
 499     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 500
 501     (*m_keyframeVector2)[0]->setEasing(m_cubicEaseTimingFunction.get());
 502     m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
 503     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 504 }
 505
 506 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedCubicMatchingOffsets)
 507 {
 508     (*m_keyframeVector2)[0]->setEasing(m_cubicEaseTimingFunction.get());
 509     m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
 510     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 511
 512     (*m_keyframeVector2)[0]->setEasing(m_cubicCustomTimingFunction.get());
 513     m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
 514     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 515
 516     (*m_keyframeVector5)[0]->setEasing(m_cubicEaseTimingFunction.get());
 517     (*m_keyframeVector5)[1]->setEasing(m_cubicCustomTimingFunction.get());
 518     (*m_keyframeVector5)[2]->setEasing(m_cubicCustomTimingFunction.get());
 519     (*m_keyframeVector5)[3]->setEasing(m_cubicCustomTimingFunction.get());
 520     m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
 521     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 522 }
 523
 524 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionMixedGood)
 525 {
 526     (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get());
 527     (*m_keyframeVector5)[1]->setEasing(m_cubicEaseTimingFunction.get());
 528     (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
 529     (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get());
 530     m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
 531     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 532 }
 533
 534 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionWithStepNotOkay)
 535 {
 536     (*m_keyframeVector2)[0]->setEasing(m_stepTimingFunction.get());
 537     m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
 538     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 539
 540     (*m_keyframeVector5)[0]->setEasing(m_stepTimingFunction.get());
 541     (*m_keyframeVector5)[1]->setEasing(m_linearTimingFunction.get());
 542     (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
 543     (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get());
 544     m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
 545     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 546
 547     (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get());
 548     (*m_keyframeVector5)[1]->setEasing(m_stepTimingFunction.get());
 549     (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
 550     (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get());
 551     m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
 552     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 553
 554     (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get());
 555     (*m_keyframeVector5)[1]->setEasing(m_cubicEaseTimingFunction.get());
 556     (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
 557     (*m_keyframeVector5)[3]->setEasing(m_stepTimingFunction.get());
 558     m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
 559     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 560 }
 561
 562 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor)
 563 {
 564     Timing linearTiming(createCompositableTiming());
 565
 566     AnimatableValueKeyframeVector basicFramesVector;
 567     basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 568     basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
 569
 570     AnimatableValueKeyframeVector nonBasicFramesVector;
 571     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 572     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.5).get());
 573     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
 574
 575     basicFramesVector[0]->setEasing(m_linearTimingFunction.get());
 576     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> basicFrames = AnimatableValueKeyframeEffectModel::create(basicFramesVector).get();
 577     EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get()));
 578
 579     basicFramesVector[0]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
 580     basicFrames = AnimatableValueKeyframeEffectModel::create(basicFramesVector).get();
 581     EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get()));
 582
 583     nonBasicFramesVector[0]->setEasing(m_linearTimingFunction.get());
 584     nonBasicFramesVector[1]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
 585     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> nonBasicFrames = AnimatableValueKeyframeEffectModel::create(nonBasicFramesVector).get();
 586     EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get(), 1));
 587 }
 588
 589 // -----------------------------------------------------------------------
 590 // -----------------------------------------------------------------------
 591
 592 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation)
 593 {
 594     // Animation to convert
 595     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
 596         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 597         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 598     // --
 599
 600     WebCompositorSupportMock mockCompositor;
 601
 602     // Curve is created
 603     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
 604     ExpectationSet usesMockCurve;
 605     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 606         .WillOnce(Return(mockCurvePtr));
 607
 608     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 609     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0)));
 610
 611     // Create animation
 612     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 613     ExpectationSet usesMockAnimation;
 614
 615     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 616         .WillOnce(Return(mockAnimationPtr));
 617
 618     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
 619     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 620     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal));
 621     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
 622
 623     EXPECT_CALL(*mockAnimationPtr, delete_())
 624         .Times(1)
 625         .After(usesMockAnimation);
 626     EXPECT_CALL(*mockCurvePtr, delete_())
 627         .Times(1)
 628         .After(usesMockCurve);
 629
 630     // Go!
 631     setCompositorForTesting(mockCompositor);
 632     Vector<OwnPtr<WebCompositorAnimation> > result;
 633     getAnimationOnCompositor(m_timing, *effect.get(), result);
 634     EXPECT_EQ(1U, result.size());
 635     result[0].clear();
 636 }
 637
 638 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration)
 639 {
 640     // Animation to convert
 641     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
 642         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 643         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 644
 645     m_timing.iterationDuration = 10.0;
 646     // --
 647
 648     WebCompositorSupportMock mockCompositor;
 649
 650     // Curve is created
 651     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
 652     ExpectationSet usesMockCurve;
 653     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 654         .WillOnce(Return(mockCurvePtr));
 655
 656     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 657     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(10.0, 5.0)));
 658
 659     // Create animation
 660     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 661     ExpectationSet usesMockAnimation;
 662
 663     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 664         .WillOnce(Return(mockAnimationPtr));
 665
 666     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
 667     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 668     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal));
 669     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
 670
 671     EXPECT_CALL(*mockAnimationPtr, delete_())
 672         .Times(1)
 673         .After(usesMockAnimation);
 674     EXPECT_CALL(*mockCurvePtr, delete_())
 675         .Times(1)
 676         .After(usesMockCurve);
 677
 678     // Go!
 679     setCompositorForTesting(mockCompositor);
 680     Vector<OwnPtr<WebCompositorAnimation> > result;
 681     getAnimationOnCompositor(m_timing, *effect.get(), result);
 682     EXPECT_EQ(1U, result.size());
 683     result[0].clear();
 684 }
 685
 686 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationLinear)
 687 {
 688     // Animation to convert
 689     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
 690         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 691         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
 692         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5),
 693         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 694
 695     m_timing.iterationCount = 5;
 696     m_timing.direction = Timing::PlaybackDirectionAlternate;
 697     m_timing.playbackRate = 2.0;
 698     // --
 699
 700     WebCompositorSupportMock mockCompositor;
 701
 702     // Curve is created
 703     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock();
 704     ExpectationSet usesMockCurve;
 705
 706     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 707         .WillOnce(Return(mockCurvePtr));
 708
 709     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 710     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.25, -1.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 711     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.5, 20.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 712     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0)));
 713
 714     // Animation is created
 715     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 716     ExpectationSet usesMockAnimation;
 717
 718     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 719         .WillOnce(Return(mockAnimationPtr));
 720
 721     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
 722     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 723     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternate));
 724     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(2.0));
 725
 726     EXPECT_CALL(*mockAnimationPtr, delete_())
 727         .Times(1)
 728         .After(usesMockAnimation);
 729     EXPECT_CALL(*mockCurvePtr, delete_())
 730         .Times(1)
 731         .After(usesMockCurve);
 732
 733     // Go!
 734     setCompositorForTesting(mockCompositor);
 735     Vector<OwnPtr<WebCompositorAnimation> > result;
 736     getAnimationOnCompositor(m_timing, *effect.get(), result);
 737     EXPECT_EQ(1U, result.size());
 738     result[0].clear();
 739 }
 740
 741 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationStartDelay)
 742 {
 743     // Animation to convert
 744     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
 745         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 746         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 747
 748     m_timing.iterationCount = 5.0;
 749     m_timing.iterationDuration = 1.75;
 750     m_timing.startDelay = 3.25;
 751     // --
 752
 753     WebCompositorSupportMock mockCompositor;
 754
 755     // Curve is created
 756     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
 757     ExpectationSet usesMockCurve;
 758     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 759         .WillOnce(Return(mockCurvePtr));
 760
 761     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 762     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.75, 5.0)));
 763
 764     // Create animation
 765     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 766     ExpectationSet usesMockAnimation;
 767
 768     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 769         .WillOnce(Return(mockAnimationPtr));
 770
 771     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
 772     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-3.25));
 773     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal));
 774     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
 775
 776     EXPECT_CALL(*mockAnimationPtr, delete_())
 777         .Times(1)
 778         .After(usesMockAnimation);
 779     EXPECT_CALL(*mockCurvePtr, delete_())
 780         .Times(1)
 781         .After(usesMockCurve);
 782
 783     // Go!
 784     setCompositorForTesting(mockCompositor);
 785     Vector<OwnPtr<WebCompositorAnimation> > result;
 786     getAnimationOnCompositor(m_timing, *effect.get(), result);
 787     EXPECT_EQ(1U, result.size());
 788     result[0].clear();
 789 }
 790
 791 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationChained)
 792 {
 793     // Animation to convert
 794     AnimatableValueKeyframeVector frames;
 795     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0));
 796     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25));
 797     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5));
 798     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 799     frames[0]->setEasing(m_cubicEaseTimingFunction.get());
 800     frames[1]->setEasing(m_linearTimingFunction.get());
 801     frames[2]->setEasing(m_cubicCustomTimingFunction.get());
 802     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = AnimatableValueKeyframeEffectModel::create(frames);
 803
 804     m_timing.timingFunction = m_linearTimingFunction.get();
 805     m_timing.iterationDuration = 2.0;
 806     m_timing.iterationCount = 10;
 807     m_timing.direction = Timing::PlaybackDirectionAlternate;
 808     // --
 809
 810     WebCompositorSupportMock mockCompositor;
 811
 812     // Curve is created
 813     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock();
 814     ExpectationSet usesMockCurve;
 815
 816     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 817         .WillOnce(Return(mockCurvePtr));
 818
 819     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeEase));
 820     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.5, -1.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 821     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 20.0), 1.0, 2.0, 3.0, 4.0));
 822     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(2.0, 5.0)));
 823
 824     // Animation is created
 825     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 826     ExpectationSet usesMockAnimation;
 827
 828     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 829         .WillOnce(Return(mockAnimationPtr));
 830
 831     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10));
 832     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 833     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternate));
 834     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
 835
 836     EXPECT_CALL(*mockAnimationPtr, delete_())
 837         .Times(1)
 838         .After(usesMockAnimation);
 839     EXPECT_CALL(*mockCurvePtr, delete_())
 840         .Times(1)
 841         .After(usesMockCurve);
 842
 843     // Go!
 844     setCompositorForTesting(mockCompositor);
 845     Vector<OwnPtr<WebCompositorAnimation> > result;
 846     getAnimationOnCompositor(m_timing, *effect.get(), result);
 847     EXPECT_EQ(1U, result.size());
 848     result[0].clear();
 849 }
 850
 851 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation)
 852 {
 853     RefPtr<TimingFunction> cubicEasyFlipTimingFunction = CubicBezierTimingFunction::create(0.0, 0.0, 0.0, 1.0);
 854
 855     // Animation to convert
 856     AnimatableValueKeyframeVector frames;
 857     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0));
 858     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25));
 859     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5));
 860     frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 861     frames[0]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
 862     frames[1]->setEasing(m_linearTimingFunction.get());
 863     frames[2]->setEasing(cubicEasyFlipTimingFunction.get());
 864     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = AnimatableValueKeyframeEffectModel::create(frames);
 865
 866     m_timing.timingFunction = m_linearTimingFunction.get();
 867     m_timing.iterationCount = 10;
 868     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 869     // --
 870
 871     WebCompositorSupportMock mockCompositor;
 872
 873     // Curve is created
 874     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock();
 875     ExpectationSet usesMockCurve;
 876
 877     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 878         .WillOnce(Return(mockCurvePtr));
 879
 880     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeEaseIn));
 881     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.25, -1.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 882     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), 0.0, 0.0, 0.0, 1.0));
 883     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 5.0)));
 884
 885     // Create the animation
 886     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 887     ExpectationSet usesMockAnimation;
 888
 889     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 890         .WillOnce(Return(mockAnimationPtr));
 891
 892     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10));
 893     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 894     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternateReverse));
 895     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
 896
 897     EXPECT_CALL(*mockAnimationPtr, delete_())
 898         .Times(1)
 899         .After(usesMockAnimation);
 900     EXPECT_CALL(*mockCurvePtr, delete_())
 901         .Times(1)
 902         .After(usesMockCurve);
 903
 904     // Go!
 905     setCompositorForTesting(mockCompositor);
 906     Vector<OwnPtr<WebCompositorAnimation> > result;
 907     getAnimationOnCompositor(m_timing, *effect.get(), result);
 908     EXPECT_EQ(1U, result.size());
 909     result[0].clear();
 910 }
 911
 912 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegativeStartDelay)
 913 {
 914     // Animation to convert
 915     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
 916         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 917         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 918
 919     m_timing.iterationCount = 5.0;
 920     m_timing.iterationDuration = 1.5;
 921     m_timing.startDelay = -3;
 922     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 923     // --
 924
 925     WebCompositorSupportMock mockCompositor;
 926
 927     // Curve is created
 928     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
 929     ExpectationSet usesMockCurve;
 930     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 931         .WillOnce(Return(mockCurvePtr));
 932
 933     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 934     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.5, 5.0)));
 935
 936     // Create animation
 937     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 938     ExpectationSet usesMockAnimation;
 939
 940     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 941         .WillOnce(Return(mockAnimationPtr));
 942
 943     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
 944     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(3.0));
 945     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternateReverse));
 946     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
 947
 948     EXPECT_CALL(*mockAnimationPtr, delete_())
 949         .Times(1)
 950         .After(usesMockAnimation);
 951     EXPECT_CALL(*mockCurvePtr, delete_())
 952         .Times(1)
 953         .After(usesMockCurve);
 954
 955     // Go!
 956     setCompositorForTesting(mockCompositor);
 957     Vector<OwnPtr<WebCompositorAnimation> > result;
 958     getAnimationOnCompositor(m_timing, *effect.get(), result);
 959     EXPECT_EQ(1U, result.size());
 960     result[0].clear();
 961 }
 962
 963 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationPlaybackRates)
 964 {
 965     // Animation to convert
 966     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
 967         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 968         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 969
 970     m_timing.playbackRate = 2;
 971     // --
 972
 973     WebCompositorSupportMock mockCompositor;
 974
 975     // Curve is created
 976     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
 977     ExpectationSet usesMockCurve;
 978     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 979         .WillOnce(Return(mockCurvePtr));
 980
 981     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
 982     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0)));
 983
 984     // Create animation
 985     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
 986     ExpectationSet usesMockAnimation;
 987
 988     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
 989         .WillOnce(Return(mockAnimationPtr));
 990
 991     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
 992     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 993     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal));
 994     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(-3));
 995
 996     EXPECT_CALL(*mockAnimationPtr, delete_())
 997         .Times(1)
 998         .After(usesMockAnimation);
 999     EXPECT_CALL(*mockCurvePtr, delete_())
1000         .Times(1)
1001         .After(usesMockCurve);
1002
1003     // Go!
1004     setCompositorForTesting(mockCompositor);
1005     Vector<OwnPtr<WebCompositorAnimation> > result;
1006     // Set player plaback rate also
1007     getAnimationOnCompositor(m_timing, *effect.get(), result, -1.5);
1008     EXPECT_EQ(1U, result.size());
1009     result[0].clear();
1010 }
1011
1012 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationFillModeNone)
1013 {
1014     // Animation to convert
1015     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
1016         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
1017         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
1018
1019     m_timing.fillMode = Timing::FillModeNone;
1020
1021     WebCompositorSupportMock mockCompositor;
1022
1023     // Curve is created
1024     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
1025     ExpectationSet usesMockCurve;
1026     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
1027         .WillOnce(Return(mockCurvePtr));
1028
1029     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
1030     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0)));
1031
1032     // Create animation
1033     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
1034     ExpectationSet usesMockAnimation;
1035
1036     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
1037         .WillOnce(Return(mockAnimationPtr));
1038
1039     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
1040     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
1041     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal));
1042     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
1043     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setFillMode(blink::WebCompositorAnimation::FillModeNone));
1044
1045     EXPECT_CALL(*mockAnimationPtr, delete_())
1046         .Times(1)
1047         .After(usesMockAnimation);
1048     EXPECT_CALL(*mockCurvePtr, delete_())
1049         .Times(1)
1050         .After(usesMockCurve);
1051
1052     // Go!
1053     setCompositorForTesting(mockCompositor);
1054     Vector<OwnPtr<WebCompositorAnimation> > result;
1055     getAnimationOnCompositor(m_timing, *effect.get(), result);
1056     EXPECT_EQ(1U, result.size());
1057     result[0].clear();
1058 }
1059
1060 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationFillModeAuto)
1061 {
1062     // Animation to convert
1063     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
1064         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
1065         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
1066
1067     m_timing.fillMode = Timing::FillModeAuto;
1068
1069     WebCompositorSupportMock mockCompositor;
1070
1071     // Curve is created
1072     WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
1073     ExpectationSet usesMockCurve;
1074     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
1075         .WillOnce(Return(mockCurvePtr));
1076
1077     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear));
1078     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0)));
1079
1080     // Create animation
1081     WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
1082     ExpectationSet usesMockAnimation;
1083
1084     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
1085         .WillOnce(Return(mockAnimationPtr));
1086
1087     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
1088     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
1089     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal));
1090     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1));
1091     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setFillMode(blink::WebCompositorAnimation::FillModeNone));
1092
1093     EXPECT_CALL(*mockAnimationPtr, delete_())
1094         .Times(1)
1095         .After(usesMockAnimation);
1096     EXPECT_CALL(*mockCurvePtr, delete_())
1097         .Times(1)
1098         .After(usesMockCurve);
1099
1100     // Go!
1101     setCompositorForTesting(mockCompositor);
1102     Vector<OwnPtr<WebCompositorAnimation> > result;
1103     getAnimationOnCompositor(m_timing, *effect.get(), result);
1104     EXPECT_EQ(1U, result.size());
1105     result[0].clear();
1106 }
1107
1108 } // namespace blink