Blink CompositorAnimations: Add more tests for integration with CC.

third_party/WebKit/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 24 matching lines @@
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorAnimationsImpl.h"
 #include "core/animation/CompositorAnimationsTestHelper.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/KeyframeEffect.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/layout/LayoutBox.h"
 #include "core/layout/LayoutObject.h"
+#include "core/loader/EmptyClients.h"
+#include "core/paint/PaintLayer.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/geometry/FloatBox.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/filters/FilterOperations.h"
+#include "platform/graphics/paint/PaintArtifact.h"
+#include "platform/graphics/test/FakeGraphicsLayerFactory.h"
 #include "platform/transforms/TransformOperations.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 #include "public/platform/WebCompositorAnimation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 using ::testing::ExpectationSet;
 using ::testing::Ref;
 using ::testing::Return;
 using ::testing::_;
 
+class MockChromeClient : public EmptyChromeClient {
+public:
+    MockChromeClient() {}
+    GraphicsLayerFactory* graphicsLayerFactory() const override
+    {
+        return FakeGraphicsLayerFactory::instance();
+    }
+};
+
 class AnimationCompositorAnimationsTest : public AnimationCompositorAnimationsTestBase {
 protected:
     RefPtr<TimingFunction> m_linearTimingFunction;
     RefPtr<TimingFunction> m_cubicEaseTimingFunction;
     RefPtr<TimingFunction> m_cubicCustomTimingFunction;
     RefPtr<TimingFunction> m_stepTimingFunction;
 
     Timing m_timing;
     CompositorAnimationsImpl::CompositorTiming m_compositorTiming;
     OwnPtr<AnimatableValueKeyframeVector> m_keyframeVector2;
     Persistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect2;
     OwnPtr<AnimatableValueKeyframeVector> m_keyframeVector5;
     Persistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect5;
 
     RefPtrWillBePersistent<Document> m_document;
     RefPtrWillBePersistent<Element> m_element;
     Persistent<AnimationTimeline> m_timeline;
+    OwnPtrWillBePersistent<MockChromeClient> m_chromeClient;
     OwnPtr<DummyPageHolder> m_pageHolder;
     WebCompositorSupportMock m_mockCompositor;
 
     virtual void SetUp()
     {
+        m_chromeClient = adoptPtrWillBeNoop(new MockChromeClient);
+
         AnimationCompositorAnimationsTestBase::SetUp();
         setCompositorForTesting(m_mockCompositor);
 
         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);
 
         if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
             EXPECT_CALL(m_mockCompositor, createAnimationTimeline())
                 .WillOnce(Return(new WebCompositorAnimationTimelineMock()));
         }
-        m_pageHolder = DummyPageHolder::create();
+
+        Page::PageClients clients;
+        fillWithEmptyClients(clients);
+        clients.chromeClient = m_chromeClient.get();
+        m_pageHolder = DummyPageHolder::create(IntSize(), &clients);
+
         m_document = &m_pageHolder->document();
         m_document->animationClock().resetTimeForTesting();
 
         if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
             EXPECT_CALL(m_mockCompositor, createAnimationTimeline())
                 .WillOnce(Return(new WebCompositorAnimationTimelineMock()));
         }
         m_timeline = AnimationTimeline::create(m_document.get());
         m_timeline->resetForTesting();
         m_element = m_document->createElement("test", ASSERT_NO_EXCEPTION);
@@ skipping 132 matching lines @@
         }
         return nullptr;
     }
 
     void simulateFrame(double time)
     {
         m_document->animationClock().updateTime(time);
         m_document->compositorPendingAnimations().update(false);
         m_timeline->serviceAnimations(TimingUpdateForAnimationFrame);
     }
+
+    void preCommit(Animation* animation)
+    {
+        WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock;
+        ExpectationSet usesMockCurve;
+        EXPECT_CALL(m_mockCompositor, createFloatAnimationCurve())
+            .WillOnce(Return(mockCurvePtr));
+
+        WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity);
+        EXPECT_CALL(m_mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _, _))
+            .WillOnce(Return(mockAnimationPtr));
+
+        if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
+            EXPECT_TRUE(m_timeline->compositorTimeline());
+            EXPECT_CALL(m_mockCompositor, createAnimationPlayer())
+                .WillOnce(Return(new WebCompositorAnimationPlayerMock()));
+        }
+
+        const int compositorGroup = 1;
+        DisableCompositingQueryAsserts disabler;
+        EXPECT_TRUE(animation->preCommit(compositorGroup, true));
+
+        if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled())
+            EXPECT_TRUE(animation->compositorPlayer());
+
+        EXPECT_TRUE(animation->hasActiveAnimationsOnCompositor());
+    }
 };
 
-class LayoutObjectProxy : public LayoutObject {
+class LayoutObjectProxy : public LayoutBox {
 public:
-    static LayoutObjectProxy* create(Node* node)
+    static LayoutObjectProxy* create(ContainerNode* node)
     {
         return new LayoutObjectProxy(node);
     }
 
     static void dispose(LayoutObjectProxy* proxy)
     {
         proxy->destroy();
     }
 
     const char* name() const override { return nullptr; }
-    void layout() override { }
+
+    void createCompositedLayer()
+    {
+        RefPtr<ComputedStyle> computedStyle = ComputedStyle::create();
+        styleWillChange(StyleDifference(), *computedStyle.get());
+        setStyle(computedStyle);
+        styleDidChange(StyleDifference(), nullptr);
+
+        DisableCompositingQueryAsserts disabler;
+        layer()->ensureCompositedLayerMapping();
+    }
 
 private:
-    explicit LayoutObjectProxy(Node* node)
-        : LayoutObject(node)
+    explicit LayoutObjectProxy(ContainerNode* node)
+        : LayoutBox(node)
     {
     }
+
+    PaintLayerType layerTypeRequired() const override
+    {
+        return NormalPaintLayer;
+    }
 };
 
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeMultipleCSSProperties)
 {
     RefPtr<AnimatableValueKeyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace);
     keyframeGoodMultiple->setPropertyValue(CSSPropertyTransform, AnimatableTransform::create(TransformOperations(), 1).get());
     EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(keyframeGoodMultiple.get()));
@@ skipping 869 matching lines @@
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     Vector<OwnPtr<WebCompositorAnimation>> result;
     getAnimationOnCompositor(m_timing, *effect, result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
+TEST_F(AnimationCompositorAnimationsTest, CancelCompositorAnimationIfAnimationDisposed)
+{
+    RefPtrWillBePersistent<Element> element = m_document->createElement("shared", ASSERT_NO_EXCEPTION);
+
+    LayoutObjectProxy* layoutObject = LayoutObjectProxy::create(element.get());
+    element->setLayoutObject(layoutObject);
+    layoutObject->createCompositedLayer();
+
+    AnimatableValueKeyframeVector keyFrames;
+    keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace, 0.0).get());
+    keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace, 1.0).get());
+    EffectModel* animationEffect = AnimatableValueKeyframeEffectModel::create(keyFrames);
+
+    Timing timing;
+    timing.iterationDuration = 1.f;
+
+    KeyframeEffect* keyframeEffect = KeyframeEffect::create(element.get(), animationEffect, timing);
+    Animation* animation = m_timeline->play(keyframeEffect);
+    EXPECT_TRUE(animation->isCandidateForAnimationOnCompositor());
+
+    preCommit(animation);
+
+    animation->dispose();
+    animation->cancelAnimationOnCompositor();

[Ian Vollick, 2015/12/29 20:32:24]

I may be misreading the purpose of this test -- it sounded like you were
checking that if we disposed the animation, then we'd got canceled
automatically? If that's the case, should we be canceling explicitly?

[loyso (OOO), 2015/12/29 23:54:25]

That was just my assumption about the crash (ideas from Doug needed).
Yes, we can call cancelAnimationOnCompositor in dispose. But we still call
cancelAnimationOnCompositor from many other different places.
So, I made it idempotent (see landed 'depend-on' patch set). And this is the
test.

+
+    EXPECT_FALSE(animation->hasActiveAnimationsOnCompositor());
+
+    simulateFrame(0);
+    EXPECT_EQ(1U, element->elementAnimations()->animations().size());
+    simulateFrame(1.);
+
+    element->setLayoutObject(nullptr);
+    LayoutObjectProxy::dispose(layoutObject);
+
+    Heap::collectAllGarbage();
+    EXPECT_TRUE(element->elementAnimations()->animations().isEmpty());
+}
+
 TEST_F(AnimationCompositorAnimationsTest, CancelIncompatibleCompositorAnimations)
 {
     RefPtrWillBePersistent<Element> element = m_document->createElement("shared", ASSERT_NO_EXCEPTION);
 
     LayoutObjectProxy* layoutObject = LayoutObjectProxy::create(element.get());
     element->setLayoutObject(layoutObject);
+    layoutObject->createCompositedLayer();
 
     AnimatableValueKeyframeVector keyFrames;
     keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace, 0.0).get());
     keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace, 1.0).get());
     EffectModel* animationEffect1 = AnimatableValueKeyframeEffectModel::create(keyFrames);
     EffectModel* animationEffect2 = AnimatableValueKeyframeEffectModel::create(keyFrames);
 
     Timing timing;
     timing.iterationDuration = 1.f;
 
     // The first animation for opacity is ok to run on compositor.
     KeyframeEffect* keyframeEffect1 = KeyframeEffect::create(element.get(), animationEffect1, timing);
     Animation* animation1 = m_timeline->play(keyframeEffect1);
-    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, *element.get(), animation1, *animationEffect1, 1));
+    EXPECT_TRUE(animation1->isCandidateForAnimationOnCompositor());
 
-    // simulate KeyframeEffect::maybeStartAnimationOnCompositor
-    Vector<int> compositorAnimationIds;
-    compositorAnimationIds.append(1);
-    keyframeEffect1->setCompositorAnimationIdsForTesting(compositorAnimationIds);
-    EXPECT_TRUE(animation1->hasActiveAnimationsOnCompositor());
+    preCommit(animation1);
 
     // The second animation for opacity is not ok to run on compositor.
     KeyframeEffect* keyframeEffect2 = KeyframeEffect::create(element.get(), animationEffect2, timing);
     Animation* animation2 = m_timeline->play(keyframeEffect2);
     EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, *element.get(), animation2, *animationEffect2, 1));
+    EXPECT_FALSE(animation2->isCandidateForAnimationOnCompositor());
     EXPECT_FALSE(animation2->hasActiveAnimationsOnCompositor());
 
     // A fallback to blink implementation needed, so cancel all compositor-side opacity animations for this element.
     animation2->cancelIncompatibleAnimationsOnCompositor();
 
     EXPECT_FALSE(animation1->hasActiveAnimationsOnCompositor());
     EXPECT_FALSE(animation2->hasActiveAnimationsOnCompositor());
 
     simulateFrame(0);
     EXPECT_EQ(2U, element->elementAnimations()->animations().size());
     simulateFrame(1.);
 
     element->setLayoutObject(nullptr);
     LayoutObjectProxy::dispose(layoutObject);
 
     Heap::collectAllGarbage();
     EXPECT_TRUE(element->elementAnimations()->animations().isEmpty());
 }
 
 } // namespace blink