Animation: Cancel same-property animations on compositor

Source/core/animation/CompositorAnimationsTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/animation/CompositorAnimations.h"
 
+#include "core/animation/ActiveAnimations.h"
+#include "core/animation/Animation.h"
+#include "core/animation/AnimationPlayer.h"
+#include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorAnimationsImpl.h"
 #include "core/animation/CompositorAnimationsTestHelper.h"
 #include "core/animation/animatable/AnimatableDouble.h"
 #include "core/animation/animatable/AnimatableFilterOperations.h"
 #include "core/animation/animatable/AnimatableTransform.h"
 #include "core/animation/animatable/AnimatableValueTestHelper.h"
+#include "core/dom/Document.h"
+#include "core/rendering/RenderObject.h"
 #include "platform/geometry/FloatBox.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/filters/FilterOperations.h"
 #include "platform/transforms/TransformOperations.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 #include "public/platform/WebCompositorAnimation.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
@@ skipping 17 matching lines @@
     RefPtr<TimingFunction> m_cubicCustomTimingFunction;
     RefPtr<TimingFunction> m_stepTimingFunction;
 
     Timing m_timing;
     CompositorAnimationsImpl::CompositorTiming m_compositorTiming;
     OwnPtrWillBePersistent<AnimatableValueKeyframeVector> m_keyframeVector2;
     RefPtrWillBePersistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect2;
     OwnPtrWillBePersistent<AnimatableValueKeyframeVector> m_keyframeVector5;
     RefPtrWillBePersistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect5;
 
+    RefPtrWillBePersistent<Document> m_document;
+    RefPtrWillBePersistent<Element> m_element;
+    RefPtrWillBePersistent<AnimationTimeline> m_timeline;
+
     virtual void SetUp()
     {
         AnimationCompositorAnimationsTestBase::SetUp();
 
         m_linearTimingFunction = LinearTimingFunction::shared();
         m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
         m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3, 4);
         m_stepTimingFunction = StepsTimingFunction::create(1, StepsTimingFunction::End);
 
         m_timing = createCompositableTiming();
         m_compositorTiming = CompositorAnimationsImpl::CompositorTiming();
         // Make sure the CompositableTiming is really compositable, otherwise
         // most other tests will fail.
         ASSERT(convertTimingForCompositor(m_timing, m_compositorTiming));
 
         m_keyframeVector2 = createCompositableFloatKeyframeVector(2);
         m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2);
 
         m_keyframeVector5 = createCompositableFloatKeyframeVector(5);
         m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
+
+        m_document = Document::create();
+        m_document->animationClock().resetTimeForTesting();
+        m_timeline = AnimationTimeline::create(m_document.get());
+        m_element = m_document->createElement("test", ASSERT_NO_EXCEPTION);
     }
 
 public:
 
     bool convertTimingForCompositor(const Timing& t, CompositorAnimationsImpl::CompositorTiming& out)
     {
         return CompositorAnimationsImpl::convertTimingForCompositor(t, 0, out, 1);
     }
     bool isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect)
     {
-        return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, effect, 1);
+        return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, *m_element.get(), nullptr, effect, 1);
     }
     void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations)
     {
         return getAnimationOnCompositor(timing, effect, animations, 1);
     }
     void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations, double playerPlaybackRate)
     {
         return CompositorAnimationsImpl::getAnimationOnCompositor(timing, 0, std::numeric_limits<double>::quiet_NaN(), 0, effect, animations, playerPlaybackRate);
     }
     bool getAnimationBounds(FloatBox& boundingBox, const AnimationEffect& effect, double minValue, double maxValue)
@@ skipping 105 matching lines @@
             EXPECT_EQ(d->offset(), 1.0);
         } else {
             EXPECT_EQ(to->offset(), 1.0);
         }
         if (!HasFatalFailure()) {
             return AnimatableValueKeyframeEffectModel::create(frames);
         }
         return nullptr;
     }
 
+    void simulateFrame(double time)
+    {
+        m_document->animationClock().updateTime(time);
+        m_document->compositorPendingAnimations().update(false);
+        m_timeline->serviceAnimations(TimingUpdateForAnimationFrame);
+    }
+};
+
+class RenderObjectProxy : public RenderObject {
+public:
+    explicit RenderObjectProxy(Node* node)
+        : RenderObject(node)
+    {
+    }
+
+    const char* renderName() const override { return nullptr; }
+    void layout() override { }
 };
 
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeMultipleCSSProperties)
 {
     RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace);
     keyframeGoodMultiple->setPropertyValue(CSSPropertyTransform, AnimatableTransform::create(TransformOperations()).get());
     EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(keyframeGoodMultiple.get()));
@@ skipping 332 matching lines @@
     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> basicFrames = AnimatableValueKeyframeEffectModel::create(basicFramesVector).get();
     EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get()));
 
     basicFramesVector[0]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
     basicFrames = AnimatableValueKeyframeEffectModel::create(basicFramesVector).get();
     EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get()));
 
     nonBasicFramesVector[0]->setEasing(m_linearTimingFunction.get());
     nonBasicFramesVector[1]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> nonBasicFrames = AnimatableValueKeyframeEffectModel::create(nonBasicFramesVector).get();
-    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get(), 1));
+    EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get()));
 }
 
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 
 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation)
 {
     // Animation to convert
     RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
@@ skipping 549 matching lines @@
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<WebCompositorAnimation> > result;
     getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
+TEST_F(AnimationCompositorAnimationsTest, CancelIncompatibleCompositorAnimations)
+{
+    WebCompositorSupportMock mockCompositor;
+    setCompositorForTesting(mockCompositor);
+
+    RefPtrWillBeRawPtr<Element> element = m_document->createElement("shared", ASSERT_NO_EXCEPTION);
+
+    RenderObjectProxy* renderer = new RenderObjectProxy(element.get());
+    element->setRenderer(renderer);
+
+    AnimatableValueKeyframeVector keyFrames;
+    keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
+    keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
+    RefPtrWillBeRawPtr<AnimationEffect> animationEffect1 = AnimatableValueKeyframeEffectModel::create(keyFrames);
+    RefPtrWillBeRawPtr<AnimationEffect> animationEffect2 = AnimatableValueKeyframeEffectModel::create(keyFrames);
+
+    Timing timing;
+    timing.iterationDuration = 1.f;
+
+    // The first player for opacity is ok to run on compositor.
+    RefPtrWillBeRawPtr<Animation> animation1 = Animation::create(element.get(), animationEffect1, timing);
+    RefPtrWillBeRawPtr<AnimationPlayer> player1 = m_timeline->play(animation1.get());
+    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, *element.get(), player1.get(), *animationEffect1.get(), 1));
+
+    // simulate Animation::maybeStartAnimationOnCompositor
+    Vector<int> compositorAnimationIds;
+    compositorAnimationIds.append(1);
+    animation1->setCompositorAnimationIdsForTesting(compositorAnimationIds);
+    EXPECT_TRUE(player1->hasActiveAnimationsOnCompositor());
+
+    // The second player for opacity is not ok to run on compositor.
+    RefPtrWillBeRawPtr<Animation> animation2 = Animation::create(element.get(), animationEffect2, timing);
+    RefPtrWillBeRawPtr<AnimationPlayer> player2 = m_timeline->play(animation2.get());
+    EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, *element.get(), player2.get(), *animationEffect2.get(), 1));
+    EXPECT_FALSE(player2->hasActiveAnimationsOnCompositor());
+
+    // A fallback to blink implementation needed, so cancel all compositor-side opacity animations for this element.
+    player2->cancelIncompatibleAnimationsOnCompositor();
+
+    EXPECT_FALSE(player1->hasActiveAnimationsOnCompositor());
+    EXPECT_FALSE(player2->hasActiveAnimationsOnCompositor());
+
+    simulateFrame(0);
+    EXPECT_EQ(2U, element->activeAnimations()->players().size());
+    simulateFrame(1.);
+
+    element->setRenderer(nullptr);
+    delete renderer;
+    renderer = nullptr;
+
+    player1.release();
+    player2.release();
+    Heap::collectAllGarbage();
+    EXPECT_TRUE(element->activeAnimations()->players().isEmpty());
+}
+
 } // namespace blink