Remove OwnPtr from Blink.

third_party/WebKit/Source/core/layout/svg/SVGResources.h

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef SVGResources_h
 #define SVGResources_h
 
 #include "wtf/Allocator.h"
 #include "wtf/HashSet.h"
 #include "wtf/Noncopyable.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 
 class LayoutObject;
 class LayoutSVGResourceClipper;
 class LayoutSVGResourceContainer;
 class LayoutSVGResourceFilter;
 class LayoutSVGResourceMarker;
 class LayoutSVGResourceMasker;
 class LayoutSVGResourcePaintServer;
 class SVGElement;
 class SVGComputedStyle;
 
 // Holds a set of resources associated with a LayoutObject
 class SVGResources {
     WTF_MAKE_NONCOPYABLE(SVGResources); USING_FAST_MALLOC(SVGResources);
 public:
     SVGResources();
 
-    static PassOwnPtr<SVGResources> buildResources(const LayoutObject*, const SVGComputedStyle&);
+    static std::unique_ptr<SVGResources> buildResources(const LayoutObject*, const SVGComputedStyle&);
     void layoutIfNeeded();
 
     static bool supportsMarkers(const SVGElement&);
 
     // Ordinary resources
     LayoutSVGResourceClipper* clipper() const { return m_clipperFilterMaskerData ? m_clipperFilterMaskerData->clipper : 0; }
     LayoutSVGResourceMarker* markerStart() const { return m_markerData ? m_markerData->markerStart : 0; }
     LayoutSVGResourceMarker* markerMid() const { return m_markerData ? m_markerData->markerMid : 0; }
     LayoutSVGResourceMarker* markerEnd() const { return m_markerData ? m_markerData->markerEnd : 0; }
     LayoutSVGResourceMasker* masker() const { return m_clipperFilterMaskerData ? m_clipperFilterMaskerData->masker : 0; }
@@ skipping 56 matching lines @@
     struct ClipperFilterMaskerData {
         USING_FAST_MALLOC(ClipperFilterMaskerData);
     public:
         ClipperFilterMaskerData()
             : clipper(nullptr)
             , filter(nullptr)
             , masker(nullptr)
         {
         }
 
-        static PassOwnPtr<ClipperFilterMaskerData> create()
+        static std::unique_ptr<ClipperFilterMaskerData> create()
         {
-            return adoptPtr(new ClipperFilterMaskerData);
+            return wrapUnique(new ClipperFilterMaskerData);
         }
 
         LayoutSVGResourceClipper* clipper;
         LayoutSVGResourceFilter* filter;
         LayoutSVGResourceMasker* masker;
     };
 
     // From SVG 1.1 2nd Edition
     // marker: line, path, polygon, polyline
     struct MarkerData {
         USING_FAST_MALLOC(MarkerData);
     public:
         MarkerData()
             : markerStart(nullptr)
             , markerMid(nullptr)
             , markerEnd(nullptr)
         {
         }
 
-        static PassOwnPtr<MarkerData> create()
+        static std::unique_ptr<MarkerData> create()
         {
-            return adoptPtr(new MarkerData);
+            return wrapUnique(new MarkerData);
         }
 
         LayoutSVGResourceMarker* markerStart;
         LayoutSVGResourceMarker* markerMid;
         LayoutSVGResourceMarker* markerEnd;
     };
 
     // From SVG 1.1 2nd Edition
     // fill:       'shapes' and 'text content elements'
     // stroke:     'shapes' and 'text content elements'
     // -> circle, ellipse, line, path, polygon, polyline, rect, text, textPath, tspan
     struct FillStrokeData {
         USING_FAST_MALLOC(FillStrokeData);
     public:
         FillStrokeData()
             : fill(nullptr)
             , stroke(nullptr)
         {
         }
 
-        static PassOwnPtr<FillStrokeData> create()
+        static std::unique_ptr<FillStrokeData> create()
         {
-            return adoptPtr(new FillStrokeData);
+            return wrapUnique(new FillStrokeData);
         }
 
         LayoutSVGResourcePaintServer* fill;
         LayoutSVGResourcePaintServer* stroke;
     };
 
-    OwnPtr<ClipperFilterMaskerData> m_clipperFilterMaskerData;
-    OwnPtr<MarkerData> m_markerData;
-    OwnPtr<FillStrokeData> m_fillStrokeData;
+    std::unique_ptr<ClipperFilterMaskerData> m_clipperFilterMaskerData;
+    std::unique_ptr<MarkerData> m_markerData;
+    std::unique_ptr<FillStrokeData> m_fillStrokeData;
     LayoutSVGResourceContainer* m_linkedResource;
 };
 
 } // namespace blink
 
 #endif