Oilpan: fix webkit unit tests after r189319 (df44f48).

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 238 matching lines @@
     void simulateFrame(double time)
     {
         m_document->animationClock().updateTime(time);
         m_document->compositorPendingAnimations().update(false);
         m_timeline->serviceAnimations(TimingUpdateForAnimationFrame);
     }
 };
 
 class RenderObjectProxy : public RenderObject {
 public:
+    static PassOwnPtrWillBeRawPtr<RenderObjectProxy> create(Node* node)
+    {
+        return adoptPtrWillBeNoop(new RenderObjectProxy(node));
+    }
+
+    static void dispose(PassOwnPtrWillBeRawPtr<RenderObjectProxy> object)
+    {
+        object.leakPtr()->destroy();
+    }
+
+    const char* renderName() const override { return nullptr; }
+    void layout() override { }
+private:
     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 907 matching lines @@
     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);
+    RefPtrWillBePersistent<Element> element = m_document->createElement("shared", ASSERT_NO_EXCEPTION);
 
-    RenderObjectProxy* renderer = new RenderObjectProxy(element.get());
-    element->setRenderer(renderer);
+    OwnPtrWillBePersistent<RenderObjectProxy> renderer = RenderObjectProxy::create(element.get());
+    element->setRenderer(renderer.get());
 
     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());
+    RefPtrWillBePersistent<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());
+    RefPtrWillBePersistent<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;
+    RenderObjectProxy::dispose(renderer.release());
 
     player1.release();
     player2.release();
     Heap::collectAllGarbage();
     EXPECT_TRUE(element->activeAnimations()->players().isEmpty());
 }
 
 } // namespace blink