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/AnimatableDouble.h"
  36 #include "core/animation/AnimatableFilterOperations.h"
  37 #include "core/animation/AnimatableTransform.h"
  38 #include "core/animation/AnimatableValueTestHelper.h"
  39 #include "core/animation/CompositorAnimationsImpl.h"
  40 #include "core/animation/CompositorAnimationsTestHelper.h"
  41 #include "platform/animation/TimingFunctionTestHelper.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/WebAnimation.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 WebCore {
  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
  66 protected:
  67     RefPtr<TimingFunction> m_linearTimingFunction;
  68     RefPtr<TimingFunction> m_cubicEaseTimingFunction;
  69     RefPtr<TimingFunction> m_cubicCustomTimingFunction;
  70     RefPtr<TimingFunction> m_stepTimingFunction;
  71
  72     Timing m_timing;
  73     CompositorAnimationsImpl::CompositorTiming m_compositorTiming;
  74     KeyframeEffectModel::KeyframeVector m_keyframeVector2;
  75     RefPtr<KeyframeEffectModel> m_keyframeAnimationEffect2;
  76     KeyframeEffectModel::KeyframeVector m_keyframeVector5;
  77     RefPtr<KeyframeEffectModel> m_keyframeAnimationEffect5;
  78
  79     virtual void SetUp()
  80     {
  81         AnimationCompositorAnimationsTestBase::SetUp();
  82
  83         m_linearTimingFunction = LinearTimingFunction::create();
  84         m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
  85         m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3, 4);
  86         m_stepTimingFunction = StepsTimingFunction::create(1, false);
  87
  88         m_timing = createCompositableTiming();
  89         m_compositorTiming = CompositorAnimationsImpl::CompositorTiming();
  90         // Make sure the CompositableTiming is really compositable, otherwise
  91         // most other tests will fail.
  92         ASSERT(convertTimingForCompositor(m_timing, m_compositorTiming));
  93
  94         m_keyframeVector2 = createCompositableFloatKeyframeVector(2);
  95         m_keyframeAnimationEffect2 = KeyframeEffectModel::create(m_keyframeVector2);
  96
  97         m_keyframeVector5 = createCompositableFloatKeyframeVector(5);
  98         m_keyframeAnimationEffect5 = KeyframeEffectModel::create(m_keyframeVector5);
  99     }
 100
 101 public:
 102
 103     bool convertTimingForCompositor(const Timing& t, CompositorAnimationsImpl::CompositorTiming& out)
 104     {
 105         return CompositorAnimationsImpl::convertTimingForCompositor(t, out);
 106     }
 107     bool isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect)
 108     {
 109         return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, effect);
 110     }
 111     void getAnimationOnCompositor(Timing& timing, KeyframeEffectModel& effect, Vector<OwnPtr<blink::WebAnimation> >& animations)
 112     {
 113         return CompositorAnimationsImpl::getAnimationOnCompositor(timing, effect, animations);
 114     }
 115
 116     bool isCandidateHelperForSingleKeyframe(Keyframe* frame)
 117     {
 118         EXPECT_EQ(frame->offset(), 0);
 119         KeyframeEffectModel::KeyframeVector frames;
 120         frames.append(frame);
 121         EXPECT_EQ(m_keyframeVector2[1]->offset(), 1.0);
 122         frames.append(m_keyframeVector2[1]);
 123         return isCandidateForAnimationOnCompositor(m_timing, *KeyframeEffectModel::create(frames).get());
 124     }
 125
 126     // -------------------------------------------------------------------
 127
 128     Timing createCompositableTiming()
 129     {
 130         Timing timing;
 131         timing.startDelay = 0;
 132         timing.fillMode = Timing::FillModeNone;
 133         timing.iterationStart = 0;
 134         timing.iterationCount = 1;
 135         timing.iterationDuration = 1.0;
 136         timing.playbackRate = 1.0;
 137         timing.direction = Timing::PlaybackDirectionNormal;
 138         ASSERT(m_linearTimingFunction);
 139         timing.timingFunction = m_linearTimingFunction;
 140         return timing;
 141     }
 142
 143     PassRefPtr<Keyframe> createReplaceOpKeyframe(CSSPropertyID id, AnimatableValue* value, double offset = 0)
 144     {
 145         RefPtr<Keyframe> keyframe = Keyframe::create();
 146         keyframe->setPropertyValue(id, value);
 147         keyframe->setComposite(AnimationEffect::CompositeReplace);
 148         keyframe->setOffset(offset);
 149         return keyframe;
 150     }
 151
 152     PassRefPtr<Keyframe> createDefaultKeyframe(CSSPropertyID id, AnimationEffect::CompositeOperation op, double offset = 0)
 153     {
 154         RefPtr<AnimatableValue> value;
 155         if (id == CSSPropertyWebkitTransform)
 156             value = AnimatableTransform::create(TransformOperations());
 157         else
 158             value = AnimatableDouble::create(10.0);
 159
 160         RefPtr<Keyframe> keyframe = createReplaceOpKeyframe(id, value.get(), offset);
 161         keyframe->setComposite(op);
 162         return keyframe;
 163     }
 164
 165     KeyframeEffectModel::KeyframeVector createCompositableFloatKeyframeVector(size_t n)
 166     {
 167         Vector<double> values;
 168         for (size_t i = 0; i < n; i++) {
 169             values.append(static_cast<double>(i));
 170         }
 171         return createCompositableFloatKeyframeVector(values);
 172     }
 173
 174     KeyframeEffectModel::KeyframeVector createCompositableFloatKeyframeVector(Vector<double>& values)
 175     {
 176         KeyframeEffectModel::KeyframeVector frames;
 177         for (size_t i = 0; i < values.size(); i++) {
 178             double offset = 1.0 / (values.size() - 1) * i;
 179             RefPtr<AnimatableDouble> value = AnimatableDouble::create(values[i]);
 180             frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, value.get(), offset).get());
 181         }
 182         return frames;
 183     }
 184
 185     PassRefPtr<KeyframeEffectModel> createKeyframeEffectModel(PassRefPtr<Keyframe> prpFrom, PassRefPtr<Keyframe> prpTo, PassRefPtr<Keyframe> prpC = 0, PassRefPtr<Keyframe> prpD = 0)
 186     {
 187         RefPtr<Keyframe> from = prpFrom;
 188         RefPtr<Keyframe> to = prpTo;
 189         RefPtr<Keyframe> c = prpC;
 190         RefPtr<Keyframe> d = prpD;
 191
 192         EXPECT_EQ(from->offset(), 0);
 193         KeyframeEffectModel::KeyframeVector frames;
 194         frames.append(from);
 195         EXPECT_LE(from->offset(), to->offset());
 196         frames.append(to);
 197         if (c) {
 198             EXPECT_LE(to->offset(), c->offset());
 199             frames.append(c);
 200         }
 201         if (d) {
 202             frames.append(d);
 203             EXPECT_LE(c->offset(), d->offset());
 204             EXPECT_EQ(d->offset(), 1.0);
 205         } else {
 206             EXPECT_EQ(to->offset(), 1.0);
 207         }
 208         if (!HasFatalFailure()) {
 209             return KeyframeEffectModel::create(frames);
 210         }
 211         return PassRefPtr<KeyframeEffectModel>();
 212     }
 213
 214 };
 215
 216 // -----------------------------------------------------------------------
 217 // -----------------------------------------------------------------------
 218
 219 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeMultipleCSSProperties)
 220 {
 221     RefPtr<Keyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace);
 222     keyframeGoodMultiple->setPropertyValue(CSSPropertyWebkitTransform, AnimatableTransform::create(TransformOperations()).get());
 223     EXPECT_TRUE(isCandidateHelperForSingleKeyframe(keyframeGoodMultiple.get()));
 224
 225     RefPtr<Keyframe> keyframeBadMultipleOp = createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeAdd);
 226     keyframeBadMultipleOp->setPropertyValue(CSSPropertyWebkitTransform, AnimatableDouble::create(10.0).get());
 227     EXPECT_FALSE(isCandidateHelperForSingleKeyframe(keyframeBadMultipleOp.get()));
 228
 229     RefPtr<Keyframe> keyframeBadMultipleID = createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace);
 230     keyframeBadMultipleID->setPropertyValue(CSSPropertyOpacity, AnimatableDouble::create(10.0).get());
 231     EXPECT_FALSE(isCandidateHelperForSingleKeyframe(keyframeBadMultipleID.get()));
 232 }
 233
 234 TEST_F(AnimationCompositorAnimationsTest, isNotCandidateForCompositorAnimationTransformDependsOnBoxSize)
 235 {
 236     TransformOperations ops;
 237     ops.operations().append(TranslateTransformOperation::create(Length(2, WebCore::Fixed), Length(2, WebCore::Fixed), TransformOperation::TranslateX));
 238     RefPtr<Keyframe> goodKeyframe = createReplaceOpKeyframe(CSSPropertyWebkitTransform, AnimatableTransform::create(ops).get());
 239     EXPECT_TRUE(isCandidateHelperForSingleKeyframe(goodKeyframe.get()));
 240
 241     ops.operations().append(TranslateTransformOperation::create(Length(50, WebCore::Percent), Length(2, WebCore::Fixed), TransformOperation::TranslateX));
 242     RefPtr<Keyframe> badKeyframe = createReplaceOpKeyframe(CSSPropertyWebkitTransform, AnimatableTransform::create(ops).get());
 243     EXPECT_FALSE(isCandidateHelperForSingleKeyframe(badKeyframe.get()));
 244
 245     TransformOperations ops2;
 246     Length calcLength = Length(100, WebCore::Percent).blend(Length(100, WebCore::Fixed), 0.5, WebCore::ValueRangeAll);
 247     ops2.operations().append(TranslateTransformOperation::create(calcLength, Length(0, WebCore::Fixed), TransformOperation::TranslateX));
 248     RefPtr<Keyframe> badKeyframe2 = createReplaceOpKeyframe(CSSPropertyWebkitTransform, AnimatableTransform::create(ops2).get());
 249     EXPECT_FALSE(isCandidateHelperForSingleKeyframe(badKeyframe2.get()));
 250 }
 251
 252 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeEffectModelMultipleFramesOkay)
 253 {
 254     KeyframeEffectModel::KeyframeVector framesSame;
 255     framesSame.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 256     framesSame.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
 257     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *KeyframeEffectModel::create(framesSame).get()));
 258
 259     KeyframeEffectModel::KeyframeVector framesMixed;
 260     framesMixed.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 261     framesMixed.append(createDefaultKeyframe(CSSPropertyWebkitTransform, AnimationEffect::CompositeReplace, 1.0).get());
 262     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *KeyframeEffectModel::create(framesMixed).get()));
 263 }
 264
 265 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeEffectModel)
 266 {
 267     KeyframeEffectModel::KeyframeVector framesSame;
 268     framesSame.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 0.0).get());
 269     framesSame.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 1.0).get());
 270     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *KeyframeEffectModel::create(framesSame).get()));
 271
 272     KeyframeEffectModel::KeyframeVector framesMixedProperties;
 273     framesMixedProperties.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 274     framesMixedProperties.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 1.0).get());
 275     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *KeyframeEffectModel::create(framesMixedProperties).get()));
 276
 277     KeyframeEffectModel::KeyframeVector framesMixedOps;
 278     framesMixedOps.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 279     framesMixedOps.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeAdd, 1.0).get());
 280     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *KeyframeEffectModel::create(framesMixedOps).get()));
 281 }
 282
 283 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorStartDelay)
 284 {
 285     m_timing.iterationDuration = 20.0;
 286
 287     m_timing.startDelay = 2.0;
 288     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 289     EXPECT_DOUBLE_EQ(-2.0, m_compositorTiming.scaledTimeOffset);
 290
 291     m_timing.startDelay = -2.0;
 292     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 293     EXPECT_DOUBLE_EQ(2.0, m_compositorTiming.scaledTimeOffset);
 294 }
 295
 296 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationStart)
 297 {
 298     m_timing.iterationStart = 2.2;
 299     EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming));
 300 }
 301
 302 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationCount)
 303 {
 304     m_timing.iterationCount = 5.0;
 305     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 306     EXPECT_EQ(5, m_compositorTiming.adjustedIterationCount);
 307
 308     m_timing.iterationCount = 5.5;
 309     EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming));
 310
 311     // Asserts will only trigger on DEBUG build.
 312     // EXPECT_DEATH tests are flaky on Android.
 313 #if !defined(NDEBUG) && !OS(ANDROID)
 314     m_timing.iterationCount = -1;
 315     EXPECT_DEATH(convertTimingForCompositor(m_timing, m_compositorTiming), "");
 316 #endif
 317
 318     m_timing.iterationCount = std::numeric_limits<double>::infinity();
 319     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 320     EXPECT_EQ(-1, m_compositorTiming.adjustedIterationCount);
 321
 322     m_timing.iterationCount = std::numeric_limits<double>::infinity();
 323     m_timing.iterationDuration = 5.0;
 324     m_timing.startDelay = -6.0;
 325     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 326     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 327     EXPECT_EQ(-1, m_compositorTiming.adjustedIterationCount);
 328 }
 329
 330 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationsAndStartDelay)
 331 {
 332     m_timing.iterationCount = 4.0;
 333     m_timing.iterationDuration = 5.0;
 334
 335     m_timing.startDelay = 6.0;
 336     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 337     EXPECT_DOUBLE_EQ(-6.0, m_compositorTiming.scaledTimeOffset);
 338     EXPECT_DOUBLE_EQ(4.0, m_compositorTiming.adjustedIterationCount);
 339
 340     m_timing.startDelay = -6.0;
 341     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 342     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 343     EXPECT_DOUBLE_EQ(4.0, m_compositorTiming.adjustedIterationCount);
 344
 345     m_timing.startDelay = 21.0;
 346     EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming));
 347 }
 348
 349 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorPlaybackRate)
 350 {
 351     m_timing.playbackRate = 2.0;
 352     EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming));
 353
 354     m_timing.playbackRate = 0.0;
 355     EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming));
 356
 357     m_timing.playbackRate = -2.0;
 358     EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming));
 359 }
 360
 361 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirection)
 362 {
 363     m_timing.direction = Timing::PlaybackDirectionAlternate;
 364     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 365     EXPECT_TRUE(m_compositorTiming.alternate);
 366     EXPECT_FALSE(m_compositorTiming.reverse);
 367
 368     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 369     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 370     EXPECT_TRUE(m_compositorTiming.alternate);
 371     EXPECT_TRUE(m_compositorTiming.reverse);
 372
 373     m_timing.direction = Timing::PlaybackDirectionReverse;
 374     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 375     EXPECT_FALSE(m_compositorTiming.alternate);
 376     EXPECT_TRUE(m_compositorTiming.reverse);
 377 }
 378
 379 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIterationsAndStartDelay)
 380 {
 381     m_timing.direction = Timing::PlaybackDirectionAlternate;
 382     m_timing.iterationCount = 4.0;
 383     m_timing.iterationDuration = 5.0;
 384     m_timing.startDelay = -6.0;
 385     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 386     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 387     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 388     EXPECT_TRUE(m_compositorTiming.alternate);
 389     EXPECT_FALSE(m_compositorTiming.reverse);
 390
 391     m_timing.direction = Timing::PlaybackDirectionAlternate;
 392     m_timing.iterationCount = 4.0;
 393     m_timing.iterationDuration = 5.0;
 394     m_timing.startDelay = -11.0;
 395     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 396     EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset);
 397     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 398     EXPECT_TRUE(m_compositorTiming.alternate);
 399     EXPECT_FALSE(m_compositorTiming.reverse);
 400
 401     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 402     m_timing.iterationCount = 4.0;
 403     m_timing.iterationDuration = 5.0;
 404     m_timing.startDelay = -6.0;
 405     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 406     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
 407     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 408     EXPECT_TRUE(m_compositorTiming.alternate);
 409     EXPECT_TRUE(m_compositorTiming.reverse);
 410
 411     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 412     m_timing.iterationCount = 4.0;
 413     m_timing.iterationDuration = 5.0;
 414     m_timing.startDelay = -11.0;
 415     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
 416     EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset);
 417     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
 418     EXPECT_TRUE(m_compositorTiming.alternate);
 419     EXPECT_TRUE(m_compositorTiming.reverse);
 420 }
 421
 422 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingTimingFunctionPassThru)
 423 {
 424     m_timing.timingFunction = m_stepTimingFunction;
 425     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 426 }
 427
 428 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionLinear)
 429 {
 430     m_timing.timingFunction = m_linearTimingFunction;
 431     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 432     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 433 }
 434
 435 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionCubic)
 436 {
 437     // Cubic bezier are okay if we only have two keyframes
 438     m_timing.timingFunction = m_cubicEaseTimingFunction;
 439     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 440     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 441
 442     m_timing.timingFunction = m_cubicCustomTimingFunction;
 443     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 444     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 445 }
 446
 447 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionSteps)
 448 {
 449     m_timing.timingFunction = m_stepTimingFunction;
 450     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 451     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 452 }
 453
 454 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedEmpty)
 455 {
 456     RefPtr<ChainedTimingFunction> chainedEmpty = ChainedTimingFunction::create();
 457     m_timing.timingFunction = chainedEmpty;
 458     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 459     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 460 }
 461
 462 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedLinear)
 463 {
 464     RefPtr<ChainedTimingFunction> chainedLinearSingle = ChainedTimingFunction::create();
 465     chainedLinearSingle->appendSegment(1.0, m_linearTimingFunction.get());
 466     m_timing.timingFunction = chainedLinearSingle;
 467     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 468
 469     RefPtr<ChainedTimingFunction> chainedLinearMultiple = ChainedTimingFunction::create();
 470     chainedLinearMultiple->appendSegment(0.25, m_linearTimingFunction.get());
 471     chainedLinearMultiple->appendSegment(0.5, m_linearTimingFunction.get());
 472     chainedLinearMultiple->appendSegment(0.75, m_linearTimingFunction.get());
 473     chainedLinearMultiple->appendSegment(1.0, m_linearTimingFunction.get());
 474     m_timing.timingFunction = chainedLinearMultiple;
 475     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 476
 477     // FIXME: Technically a chained timing function of linear functions don't
 478     // have to be aligned to keyframes. We don't support that currently as
 479     // nothing generates that yet.
 480 }
 481
 482 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedCubicMatchingOffsets)
 483 {
 484     RefPtr<ChainedTimingFunction> chainedSingleAGood = ChainedTimingFunction::create();
 485     chainedSingleAGood->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 486     m_timing.timingFunction = chainedSingleAGood;
 487     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 488
 489     RefPtr<ChainedTimingFunction> chainedSingleBGood = ChainedTimingFunction::create();
 490     chainedSingleBGood->appendSegment(1.0, m_cubicCustomTimingFunction.get());
 491     m_timing.timingFunction = chainedSingleBGood;
 492     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 493
 494     RefPtr<ChainedTimingFunction> chainedMultipleGood = ChainedTimingFunction::create();
 495     chainedMultipleGood->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 496     chainedMultipleGood->appendSegment(0.5, m_cubicCustomTimingFunction.get());
 497     chainedMultipleGood->appendSegment(0.75, m_cubicCustomTimingFunction.get());
 498     chainedMultipleGood->appendSegment(1.0, m_cubicCustomTimingFunction.get());
 499     m_timing.timingFunction = chainedMultipleGood;
 500     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 501 }
 502
 503 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedCubicNonMatchingOffsets)
 504 {
 505     RefPtr<ChainedTimingFunction> chained0 = ChainedTimingFunction::create();
 506     chained0->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 507     m_timing.timingFunction = chained0;
 508     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 509
 510     RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create();
 511     chained1->appendSegment(0.24, m_cubicEaseTimingFunction.get());
 512     chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 513     chained1->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 514     chained1->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 515     m_timing.timingFunction = chained1;
 516     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 517
 518     RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create();
 519     chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 520     chained2->appendSegment(0.51, m_cubicEaseTimingFunction.get());
 521     chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 522     chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 523     m_timing.timingFunction = chained2;
 524     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 525
 526     RefPtr<ChainedTimingFunction> chained3 = ChainedTimingFunction::create();
 527     chained3->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 528     chained3->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 529     chained3->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 530     chained3->appendSegment(0.8, m_cubicEaseTimingFunction.get());
 531     m_timing.timingFunction = chained3;
 532     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 533
 534     RefPtr<ChainedTimingFunction> chained4 = ChainedTimingFunction::create();
 535     chained4->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 536     chained4->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 537     chained4->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 538     chained4->appendSegment(1.1, m_cubicEaseTimingFunction.get());
 539     m_timing.timingFunction = chained4;
 540     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 541 }
 542
 543 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionMissingFrames)
 544 {
 545     // Missing first
 546     RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create();
 547     chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 548     chained1->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 549     chained1->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 550     m_timing.timingFunction = chained1;
 551     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 552
 553     // Missing middle
 554     RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create();
 555     chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 556     chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 557     chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 558     m_timing.timingFunction = chained2;
 559     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 560
 561     // Missing last
 562     RefPtr<ChainedTimingFunction> chained3 = ChainedTimingFunction::create();
 563     chained3->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 564     chained3->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 565     chained3->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 566     m_timing.timingFunction = chained3;
 567     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 568 }
 569
 570 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionToManyFrames)
 571 {
 572     RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create();
 573     chained1->appendSegment(0.1, m_cubicEaseTimingFunction.get());
 574     chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 575     m_timing.timingFunction = chained1;
 576     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 577
 578     RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create();
 579     chained2->appendSegment(0.1, m_cubicEaseTimingFunction.get());
 580     chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 581     chained2->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 582     chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 583     chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 584     m_timing.timingFunction = chained2;
 585     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 586 }
 587
 588 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionMixedGood)
 589 {
 590     RefPtr<ChainedTimingFunction> chainedMixed = ChainedTimingFunction::create();
 591     chainedMixed->appendSegment(0.25, m_linearTimingFunction.get());
 592     chainedMixed->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 593     chainedMixed->appendSegment(0.75, m_cubicEaseTimingFunction.get());
 594     chainedMixed->appendSegment(1.0, m_linearTimingFunction.get());
 595     m_timing.timingFunction = chainedMixed;
 596     EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 597 }
 598
 599 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionWithStepNotOkay)
 600 {
 601     RefPtr<ChainedTimingFunction> chainedStepSingle = ChainedTimingFunction::create();
 602     chainedStepSingle->appendSegment(1.0, m_stepTimingFunction.get());
 603     m_timing.timingFunction = chainedStepSingle;
 604     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get()));
 605
 606     RefPtr<ChainedTimingFunction> chainedStepMixedA = ChainedTimingFunction::create();
 607     chainedStepMixedA->appendSegment(0.25, m_stepTimingFunction.get());
 608     chainedStepMixedA->appendSegment(0.5, m_linearTimingFunction.get());
 609     chainedStepMixedA->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 610     m_timing.timingFunction = chainedStepMixedA;
 611     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 612
 613     RefPtr<ChainedTimingFunction> chainedStepMixedB = ChainedTimingFunction::create();
 614     chainedStepMixedB->appendSegment(0.25, m_linearTimingFunction.get());
 615     chainedStepMixedB->appendSegment(0.5, m_stepTimingFunction.get());
 616     chainedStepMixedB->appendSegment(1.0, m_cubicEaseTimingFunction.get());
 617     m_timing.timingFunction = chainedStepMixedB;
 618     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 619
 620     RefPtr<ChainedTimingFunction> chainedStepMixedC = ChainedTimingFunction::create();
 621     chainedStepMixedC->appendSegment(0.25, m_linearTimingFunction.get());
 622     chainedStepMixedC->appendSegment(0.5, m_cubicEaseTimingFunction.get());
 623     chainedStepMixedC->appendSegment(1.0, m_stepTimingFunction.get());
 624     m_timing.timingFunction = chainedStepMixedC;
 625     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 626 }
 627
 628 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionNestedNotOkay)
 629 {
 630     RefPtr<ChainedTimingFunction> chainedChild = ChainedTimingFunction::create();
 631     chainedChild->appendSegment(1.0, m_linearTimingFunction.get());
 632
 633     RefPtr<ChainedTimingFunction> chainedParent = ChainedTimingFunction::create();
 634     chainedParent->appendSegment(0.25, m_linearTimingFunction.get());
 635     chainedParent->appendSegment(0.5, chainedChild.get());
 636     chainedParent->appendSegment(0.75, m_linearTimingFunction.get());
 637     chainedParent->appendSegment(1.0, m_linearTimingFunction.get());
 638     m_timing.timingFunction = chainedParent;
 639     EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get()));
 640 }
 641
 642 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor)
 643 {
 644     Timing linearTiming(createCompositableTiming());
 645
 646     RefPtr<TimingFunction> cubicTimingFunc = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
 647     Timing cubicTiming(createCompositableTiming());
 648     cubicTiming.timingFunction = cubicTimingFunc;
 649
 650     RefPtr<ChainedTimingFunction> chainedTimingFunc = ChainedTimingFunction::create();
 651     chainedTimingFunc->appendSegment(0.5, m_linearTimingFunction.get());
 652     chainedTimingFunc->appendSegment(1.0, cubicTimingFunc.get());
 653     Timing chainedTiming(createCompositableTiming());
 654     chainedTiming.timingFunction = chainedTimingFunc;
 655
 656     KeyframeEffectModel::KeyframeVector basicFramesVector;
 657     basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 658     basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
 659     RefPtr<KeyframeEffectModel> basicFrames = KeyframeEffectModel::create(basicFramesVector).get();
 660
 661     EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get()));
 662     EXPECT_TRUE(isCandidateForAnimationOnCompositor(cubicTiming, *basicFrames.get()));
 663     // number of timing function and keyframes don't match
 664     EXPECT_FALSE(isCandidateForAnimationOnCompositor(chainedTiming, *basicFrames.get()));
 665
 666     KeyframeEffectModel::KeyframeVector nonBasicFramesVector;
 667     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
 668     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.5).get());
 669     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
 670     RefPtr<KeyframeEffectModel> nonBasicFrames = KeyframeEffectModel::create(nonBasicFramesVector).get();
 671
 672     EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get()));
 673     EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(cubicTiming, *nonBasicFrames.get()));
 674     EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(chainedTiming, *nonBasicFrames.get()));
 675 }
 676
 677 // -----------------------------------------------------------------------
 678 // -----------------------------------------------------------------------
 679
 680 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation)
 681 {
 682     // Animation to convert
 683     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 684         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 685         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 686     // --
 687
 688     WebCompositorSupportMock mockCompositor;
 689
 690     // Curve is created
 691     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock;
 692     ExpectationSet usesMockCurve;
 693     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 694         .WillOnce(Return(mockCurvePtr));
 695
 696     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 697     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 5.0)));
 698
 699     // Create animation
 700     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
 701     ExpectationSet usesMockAnimation;
 702
 703     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
 704         .WillOnce(Return(mockAnimationPtr));
 705
 706     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
 707     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 708     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false));
 709
 710     EXPECT_CALL(*mockAnimationPtr, delete_())
 711         .Times(1)
 712         .After(usesMockAnimation);
 713     EXPECT_CALL(*mockCurvePtr, delete_())
 714         .Times(1)
 715         .After(usesMockCurve);
 716
 717     // Go!
 718     setCompositorForTesting(mockCompositor);
 719     Vector<OwnPtr<blink::WebAnimation> > result;
 720     getAnimationOnCompositor(m_timing, *effect.get(), result);
 721     EXPECT_EQ(1U, result.size());
 722     result[0].clear();
 723 }
 724
 725 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration)
 726 {
 727     // Animation to convert
 728     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 729         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 730         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 731
 732     m_timing.iterationDuration = 10.0;
 733     // --
 734
 735     WebCompositorSupportMock mockCompositor;
 736
 737     // Curve is created
 738     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock;
 739     ExpectationSet usesMockCurve;
 740     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 741         .WillOnce(Return(mockCurvePtr));
 742
 743     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 744     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(10.0, 5.0)));
 745
 746     // Create animation
 747     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
 748     ExpectationSet usesMockAnimation;
 749
 750     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
 751         .WillOnce(Return(mockAnimationPtr));
 752
 753     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
 754     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 755     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false));
 756
 757     EXPECT_CALL(*mockAnimationPtr, delete_())
 758         .Times(1)
 759         .After(usesMockAnimation);
 760     EXPECT_CALL(*mockCurvePtr, delete_())
 761         .Times(1)
 762         .After(usesMockCurve);
 763
 764     // Go!
 765     setCompositorForTesting(mockCompositor);
 766     Vector<OwnPtr<blink::WebAnimation> > result;
 767     getAnimationOnCompositor(m_timing, *effect.get(), result);
 768     EXPECT_EQ(1U, result.size());
 769     result[0].clear();
 770 }
 771
 772 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationLinear)
 773 {
 774     // Animation to convert
 775     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 776         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 777         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
 778         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5),
 779         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 780
 781     m_timing.iterationCount = 5;
 782     m_timing.direction = Timing::PlaybackDirectionAlternate;
 783     // --
 784
 785     WebCompositorSupportMock mockCompositor;
 786
 787     // Curve is created
 788     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock();
 789     ExpectationSet usesMockCurve;
 790
 791     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 792         .WillOnce(Return(mockCurvePtr));
 793
 794     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 795     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.25, -1.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 796     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 797     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 5.0)));
 798
 799     // Animation is created
 800     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
 801     ExpectationSet usesMockAnimation;
 802
 803     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
 804         .WillOnce(Return(mockAnimationPtr));
 805
 806     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
 807     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 808     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 809
 810     EXPECT_CALL(*mockAnimationPtr, delete_())
 811         .Times(1)
 812         .After(usesMockAnimation);
 813     EXPECT_CALL(*mockCurvePtr, delete_())
 814         .Times(1)
 815         .After(usesMockCurve);
 816
 817     // Go!
 818     setCompositorForTesting(mockCompositor);
 819     Vector<OwnPtr<blink::WebAnimation> > result;
 820     getAnimationOnCompositor(m_timing, *effect.get(), result);
 821     EXPECT_EQ(1U, result.size());
 822     result[0].clear();
 823 }
 824
 825 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationStartDelay)
 826 {
 827     // Animation to convert
 828     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 829         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 830         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 831
 832     m_timing.iterationCount = 5.0;
 833     m_timing.iterationDuration = 1.75;
 834     m_timing.startDelay = 3.25;
 835     // --
 836
 837     WebCompositorSupportMock mockCompositor;
 838
 839     // Curve is created
 840     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock;
 841     ExpectationSet usesMockCurve;
 842     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 843         .WillOnce(Return(mockCurvePtr));
 844
 845     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 846     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.75, 5.0)));
 847
 848     // Create animation
 849     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
 850     ExpectationSet usesMockAnimation;
 851
 852     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
 853         .WillOnce(Return(mockAnimationPtr));
 854
 855     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
 856     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-3.25));
 857     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false));
 858
 859     EXPECT_CALL(*mockAnimationPtr, delete_())
 860         .Times(1)
 861         .After(usesMockAnimation);
 862     EXPECT_CALL(*mockCurvePtr, delete_())
 863         .Times(1)
 864         .After(usesMockCurve);
 865
 866     // Go!
 867     setCompositorForTesting(mockCompositor);
 868     Vector<OwnPtr<blink::WebAnimation> > result;
 869     getAnimationOnCompositor(m_timing, *effect.get(), result);
 870     EXPECT_EQ(1U, result.size());
 871     result[0].clear();
 872 }
 873
 874 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationChained)
 875 {
 876     // Animation to convert
 877     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 878         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 879         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
 880         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5),
 881         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 882
 883     RefPtr<ChainedTimingFunction> chainedTimingFunction = ChainedTimingFunction::create();
 884     chainedTimingFunction->appendSegment(0.25, m_cubicEaseTimingFunction.get());
 885     chainedTimingFunction->appendSegment(0.5, m_linearTimingFunction.get());
 886     chainedTimingFunction->appendSegment(1.0, m_cubicCustomTimingFunction.get());
 887
 888     m_timing.timingFunction = chainedTimingFunction;
 889     m_timing.iterationDuration = 2.0;
 890     m_timing.iterationCount = 10;
 891     m_timing.direction = Timing::PlaybackDirectionAlternate;
 892     // --
 893
 894     WebCompositorSupportMock mockCompositor;
 895
 896     // Curve is created
 897     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock();
 898     ExpectationSet usesMockCurve;
 899
 900     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 901         .WillOnce(Return(mockCurvePtr));
 902
 903     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeEase));
 904     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, -1.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 905     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 20.0), 1.0, 2.0, 3.0, 4.0));
 906     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(2.0, 5.0)));
 907
 908     // Animation is created
 909     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
 910     ExpectationSet usesMockAnimation;
 911
 912     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
 913         .WillOnce(Return(mockAnimationPtr));
 914
 915     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10));
 916     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 917     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 918
 919     EXPECT_CALL(*mockAnimationPtr, delete_())
 920         .Times(1)
 921         .After(usesMockAnimation);
 922     EXPECT_CALL(*mockCurvePtr, delete_())
 923         .Times(1)
 924         .After(usesMockCurve);
 925
 926     // Go!
 927     setCompositorForTesting(mockCompositor);
 928     Vector<OwnPtr<blink::WebAnimation> > result;
 929     getAnimationOnCompositor(m_timing, *effect.get(), result);
 930     EXPECT_EQ(1U, result.size());
 931     result[0].clear();
 932 }
 933
 934 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation)
 935 {
 936     // Animation to convert
 937     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 938         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 939         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
 940         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5),
 941         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
 942
 943     RefPtr<TimingFunction> cubicEasyFlipTimingFunction = CubicBezierTimingFunction::create(0.0, 0.0, 0.0, 1.0);
 944     RefPtr<ChainedTimingFunction> chainedTimingFunction = ChainedTimingFunction::create();
 945     chainedTimingFunction->appendSegment(0.25, CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
 946     chainedTimingFunction->appendSegment(0.5, m_linearTimingFunction.get());
 947     chainedTimingFunction->appendSegment(1.0, cubicEasyFlipTimingFunction.get());
 948
 949     m_timing.timingFunction = chainedTimingFunction;
 950     m_timing.iterationCount = 10;
 951     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
 952     // --
 953
 954     WebCompositorSupportMock mockCompositor;
 955
 956     // Curve is created
 957     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock();
 958     ExpectationSet usesMockCurve;
 959
 960     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
 961         .WillOnce(Return(mockCurvePtr));
 962
 963     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 5.0), 1.0, 0.0, 1.0, 1.0));
 964     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
 965     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.75, -1.0), blink::WebAnimationCurve::TimingFunctionTypeEaseOut));
 966     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 2.0)));
 967
 968     // Create the animation
 969     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
 970     ExpectationSet usesMockAnimation;
 971
 972     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
 973         .WillOnce(Return(mockAnimationPtr));
 974
 975     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10));
 976     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
 977     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 978
 979     EXPECT_CALL(*mockAnimationPtr, delete_())
 980         .Times(1)
 981         .After(usesMockAnimation);
 982     EXPECT_CALL(*mockCurvePtr, delete_())
 983         .Times(1)
 984         .After(usesMockCurve);
 985
 986     // Go!
 987     setCompositorForTesting(mockCompositor);
 988     Vector<OwnPtr<blink::WebAnimation> > result;
 989     getAnimationOnCompositor(m_timing, *effect.get(), result);
 990     EXPECT_EQ(1U, result.size());
 991     result[0].clear();
 992 }
 993
 994 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegativeStartDelay)
 995 {
 996     // Animation to convert
 997     RefPtr<KeyframeEffectModel> effect = createKeyframeEffectModel(
 998         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
 999         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
1000
1001     m_timing.iterationCount = 5.0;
1002     m_timing.iterationDuration = 1.5;
1003     m_timing.startDelay = -3;
1004     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
1005     // --
1006
1007     WebCompositorSupportMock mockCompositor;
1008
1009     // Curve is created
1010     blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock;
1011     ExpectationSet usesMockCurve;
1012     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
1013         .WillOnce(Return(mockCurvePtr));
1014
1015     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 5.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
1016     usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.5, 2.0)));
1017
1018     // Create animation
1019     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
1020     ExpectationSet usesMockAnimation;
1021
1022     usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _))
1023         .WillOnce(Return(mockAnimationPtr));
1024
1025     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
1026     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(3.0));
1027     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
1028
1029     EXPECT_CALL(*mockAnimationPtr, delete_())
1030         .Times(1)
1031         .After(usesMockAnimation);
1032     EXPECT_CALL(*mockCurvePtr, delete_())
1033         .Times(1)
1034         .After(usesMockCurve);
1035
1036     // Go!
1037     setCompositorForTesting(mockCompositor);
1038     Vector<OwnPtr<blink::WebAnimation> > result;
1039     getAnimationOnCompositor(m_timing, *effect.get(), result);
1040     EXPECT_EQ(1U, result.size());
1041     result[0].clear();
1042 }
1043
1044
1045 } // namespace WebCore