Blink Compositor Animation: Use PassOwnPtr in CompositorFactory.

third_party/WebKit/Source/platform/graphics/CompositorFactory.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/CompositorFactory.h"
 
 #include "platform/animation/CompositorAnimation.h"
 #include "platform/animation/CompositorAnimationPlayer.h"
 #include "platform/animation/CompositorAnimationTimeline.h"
 #include "platform/animation/CompositorFilterAnimationCurve.h"
 #include "platform/animation/CompositorFloatAnimationCurve.h"
 #include "platform/animation/CompositorTransformAnimationCurve.h"
 #include "platform/animation/CompositorTransformOperations.h"
 #include "platform/graphics/CompositorFilterOperations.h"
 
 namespace blink {
 
 class CompositorFactoryImpl : public CompositorFactory {
 public:
-    CompositorFilterAnimationCurve* createFilterAnimationCurve() override
+    PassOwnPtr<CompositorFilterAnimationCurve> createFilterAnimationCurve() override
     {
-        return new CompositorFilterAnimationCurve();
+        return adoptPtr(new CompositorFilterAnimationCurve());
     }
 
-    CompositorFloatAnimationCurve* createFloatAnimationCurve() override
+    PassOwnPtr<CompositorFloatAnimationCurve> createFloatAnimationCurve() override
     {
-        return new CompositorFloatAnimationCurve();
+        return adoptPtr(new CompositorFloatAnimationCurve());
     }
 
-    CompositorScrollOffsetAnimationCurve* createScrollOffsetAnimationCurve(
+    PassOwnPtr<CompositorScrollOffsetAnimationCurve> createScrollOffsetAnimationCurve(
         FloatPoint targetValue,
         CompositorAnimationCurve::TimingFunctionType timingFunctionType,
         CompositorScrollOffsetAnimationCurve::ScrollDurationBehavior durationBehavior)
     {
-        return new CompositorScrollOffsetAnimationCurve(targetValue, timingFunctionType,
-            durationBehavior);
+        return adoptPtr(new CompositorScrollOffsetAnimationCurve(targetValue, timingFunctionType,
+            durationBehavior));
     }
 
-    CompositorTransformAnimationCurve* createTransformAnimationCurve() override
+    PassOwnPtr<CompositorTransformAnimationCurve> createTransformAnimationCurve() override
     {
-        return new CompositorTransformAnimationCurve();
+        return adoptPtr(new CompositorTransformAnimationCurve());
     }
 
-    CompositorTransformOperations* createTransformOperations() override
+    PassOwnPtr<CompositorTransformOperations> createTransformOperations() override
     {
-        return new CompositorTransformOperations();
+        return adoptPtr(new CompositorTransformOperations());
     }
 
-    CompositorFilterOperations* createFilterOperations() override
+    PassOwnPtr<CompositorFilterOperations> createFilterOperations() override
     {
-        return new CompositorFilterOperations();
+        return adoptPtr(new CompositorFilterOperations());
     }
 
-    CompositorAnimation* createAnimation(const blink::CompositorAnimationCurve& curve, blink::CompositorAnimation::TargetProperty target, int groupId, int animationId) override
+    PassOwnPtr<CompositorAnimation> createAnimation(const blink::CompositorAnimationCurve& curve, blink::CompositorAnimation::TargetProperty target, int groupId, int animationId) override
     {
-        return new CompositorAnimation(curve, target, animationId, groupId);
+        return adoptPtr(new CompositorAnimation(curve, target, animationId, groupId));
     }
 
-    CompositorAnimationPlayer* createAnimationPlayer()
+    PassOwnPtr<CompositorAnimationPlayer> createAnimationPlayer()
     {
-        return new CompositorAnimationPlayer();
+        return adoptPtr(new CompositorAnimationPlayer());
     }
 
-    CompositorAnimationTimeline* createAnimationTimeline()
+    PassOwnPtr<CompositorAnimationTimeline> createAnimationTimeline()
     {
-        return new CompositorAnimationTimeline();
+        return adoptPtr(new CompositorAnimationTimeline());
     }
 };
 
 static CompositorFactory* s_factory = 0;
 
+CompositorFactory::~CompositorFactory() { }
+
 void CompositorFactory::initializeDefault()
 {
     delete s_factory;
     s_factory = new CompositorFactoryImpl();
 }
 
 void CompositorFactory::initializeForTesting(PassOwnPtr<CompositorFactory> factory)
 {
     delete s_factory;
     s_factory = factory.leakPtr();
 }
 
 void CompositorFactory::shutdown()
 {
     delete s_factory;
     s_factory = nullptr;
 }
 
 CompositorFactory& CompositorFactory::current()
 {
     ASSERT(s_factory);
     return *s_factory;
 }
 
+PassOwnPtr<CompositorFilterAnimationCurve> CompositorFactory::createFilterAnimationCurve() { return nullptr; }
+
+PassOwnPtr<CompositorFloatAnimationCurve> CompositorFactory::createFloatAnimationCurve() { return nullptr; }
+
+PassOwnPtr<CompositorScrollOffsetAnimationCurve> CompositorFactory::createScrollOffsetAnimationCurve(
+    FloatPoint targetValue,
+    CompositorAnimationCurve::TimingFunctionType,
+    CompositorScrollOffsetAnimationCurve::ScrollDurationBehavior) { return nullptr; }
+
+PassOwnPtr<CompositorTransformAnimationCurve> CompositorFactory::createTransformAnimationCurve() { return nullptr; }
+
+PassOwnPtr<CompositorTransformOperations> CompositorFactory::createTransformOperations() { return nullptr; }
+
+PassOwnPtr<CompositorFilterOperations> CompositorFactory::createFilterOperations() { return nullptr; }
+
+PassOwnPtr<CompositorAnimation> CompositorFactory::createAnimation(const CompositorAnimationCurve&, CompositorAnimation::TargetProperty, int groupId, int animationId) { return nullptr; }
+
+PassOwnPtr<CompositorAnimationPlayer> CompositorFactory::createAnimationPlayer() { return nullptr; }
+
+PassOwnPtr<CompositorAnimationTimeline> CompositorFactory::createAnimationTimeline() { return nullptr; }
+
 } // namespace blink