Remove OwnPtr from Blink.

third_party/WebKit/Source/core/paint/SVGPaintContext.cpp

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-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
@@ skipping 14 matching lines @@
 #include "core/paint/SVGPaintContext.h"
 
 #include "core/frame/FrameHost.h"
 #include "core/layout/svg/LayoutSVGResourceFilter.h"
 #include "core/layout/svg/LayoutSVGResourceMasker.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/layout/svg/SVGResources.h"
 #include "core/layout/svg/SVGResourcesCache.h"
 #include "core/paint/SVGMaskPainter.h"
 #include "platform/FloatConversion.h"
+#include "wtf/PtrUtil.h"
 
 namespace blink {
 
 SVGPaintContext::~SVGPaintContext()
 {
     if (m_filter) {
         ASSERT(SVGResourcesCache::cachedResourcesForLayoutObject(&m_object));
         ASSERT(SVGResourcesCache::cachedResourcesForLayoutObject(&m_object)->filter() == m_filter);
         ASSERT(m_filterRecordingContext);
         SVGFilterPainter(*m_filter).finishEffect(m_object, *m_filterRecordingContext);
@@ skipping 37 matching lines @@
     if (!applyClipIfNecessary(resources))
         return false;
 
     if (!applyMaskIfNecessary(resources))
         return false;
 
     if (!applyFilterIfNecessary(resources))
         return false;
 
     if (!isIsolationInstalled() && SVGLayoutSupport::isIsolationRequired(&m_object))
-        m_compositingRecorder = adoptPtr(new CompositingRecorder(paintInfo().context, m_object, SkXfermode::kSrcOver_Mode, 1));
+        m_compositingRecorder = wrapUnique(new CompositingRecorder(paintInfo().context, m_object, SkXfermode::kSrcOver_Mode, 1));
 
     return true;
 }
 
 void SVGPaintContext::applyCompositingIfNecessary()
 {
     ASSERT(!paintInfo().isRenderingClipPathAsMaskImage());
 
     // Layer takes care of root opacity and blend mode.
     if (m_object.isSVGRoot())
         return;
 
     const ComputedStyle& style = m_object.styleRef();
     float opacity = style.opacity();
     WebBlendMode blendMode = style.hasBlendMode() && m_object.isBlendingAllowed() ?
         style.blendMode() : WebBlendModeNormal;
     if (opacity < 1 || blendMode != WebBlendModeNormal) {
         const FloatRect compositingBounds = m_object.paintInvalidationRectInLocalSVGCoordinates();
-        m_compositingRecorder = adoptPtr(new CompositingRecorder(paintInfo().context, m_object,
+        m_compositingRecorder = wrapUnique(new CompositingRecorder(paintInfo().context, m_object,
             WebCoreCompositeToSkiaComposite(CompositeSourceOver, blendMode), opacity, &compositingBounds));
     }
 }
 
 bool SVGPaintContext::applyClipIfNecessary(SVGResources* resources)
 {
     // resources->clipper() corresponds to the non-prefixed 'clip-path' whereas
     // m_object.style()->clipPath() corresponds to '-webkit-clip-path'.
     // FIXME: We should unify the clip-path and -webkit-clip-path codepaths.
     if (LayoutSVGResourceClipper* clipper = resources ? resources->clipper() : nullptr) {
         if (!SVGClipPainter(*clipper).prepareEffect(m_object, m_object.objectBoundingBox(), m_object.paintInvalidationRectInLocalSVGCoordinates(), paintInfo().context, m_clipperState))
             return false;
         m_clipper = clipper;
     } else {
         ClipPathOperation* clipPathOperation = m_object.style()->clipPath();
         if (clipPathOperation && clipPathOperation->type() == ClipPathOperation::SHAPE) {
             ShapeClipPathOperation* clipPath = toShapeClipPathOperation(clipPathOperation);
             if (!clipPath->isValid())
                 return false;
-            m_clipPathRecorder = adoptPtr(new ClipPathRecorder(paintInfo().context, m_object, clipPath->path(m_object.objectBoundingBox())));
+            m_clipPathRecorder = wrapUnique(new ClipPathRecorder(paintInfo().context, m_object, clipPath->path(m_object.objectBoundingBox())));
         }
     }
     return true;
 }
 
 bool SVGPaintContext::applyMaskIfNecessary(SVGResources* resources)
 {
     if (LayoutSVGResourceMasker* masker = resources ? resources->masker() : nullptr) {
         if (!SVGMaskPainter(*masker).prepareEffect(m_object, paintInfo().context))
             return false;
         m_masker = masker;
     }
     return true;
 }
 
 bool SVGPaintContext::applyFilterIfNecessary(SVGResources* resources)
 {
     if (!resources) {
         if (m_object.style()->svgStyle().hasFilter())
             return false;
     } else if (LayoutSVGResourceFilter* filter = resources->filter()) {
-        m_filterRecordingContext = adoptPtr(new SVGFilterRecordingContext(paintInfo().context));
+        m_filterRecordingContext = wrapUnique(new SVGFilterRecordingContext(paintInfo().context));
         m_filter = filter;
         GraphicsContext* filterContext = SVGFilterPainter(*filter).prepareEffect(m_object, *m_filterRecordingContext);
         if (!filterContext)
             return false;
 
         // Because the filter needs to cache its contents we replace the context
         // during filtering with the filter's context.
-        m_filterPaintInfo = adoptPtr(new PaintInfo(*filterContext, m_paintInfo));
+        m_filterPaintInfo = wrapUnique(new PaintInfo(*filterContext, m_paintInfo));
 
         // Because we cache the filter contents and do not invalidate on paint
         // invalidation rect changes, we need to paint the entire filter region
         // so elements outside the initial paint (due to scrolling, etc) paint.
         m_filterPaintInfo->m_cullRect.m_rect = LayoutRect::infiniteIntRect();
     }
     return true;
 }
 
 bool SVGPaintContext::isIsolationInstalled() const
@@ skipping 50 matching lines @@
     // though.
     // Additionally, it's not really safe/guaranteed to be correct, as
     // something down the paint pipe may want to farther tweak the color
     // filter, which could yield incorrect results. (Consider just using
     // saveLayer() w/ this color filter explicitly instead.)
     paint.setColorFilter(sk_ref_sp(paintInfo.context.colorFilter()));
     return true;
 }
 
 } // namespace blink