Remove OwnPtr from Blink.

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

 /*
  * Copyright (C) 2012 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/ImageFrameGenerator.h"
 
 #include "SkData.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/ImageDecodingStore.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "third_party/skia/include/core/SkYUVSizeInfo.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 
 static bool compatibleInfo(const SkImageInfo& src, const SkImageInfo& dst)
 {
     if (src == dst)
         return true;
 
     // It is legal to write kOpaque_SkAlphaType pixels into a kPremul_SkAlphaType buffer.
     // This can happen when DeferredImageDecoder allocates an kOpaque_SkAlphaType image
@@ skipping 108 matching lines @@
     if (m_decodeFailed)
         return false;
 
     TRACE_EVENT1("blink", "ImageFrameGenerator::decodeToYUV", "frame index", static_cast<int>(index));
 
     if (!planes || !planes[0] || !planes[1] || !planes[2]
         || !rowBytes || !rowBytes[0] || !rowBytes[1] || !rowBytes[2]) {
         return false;
     }
 
-    OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
+    std::unique_ptr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
     // getYUVComponentSizes was already called and was successful, so ImageDecoder::create must succeed.
     ASSERT(decoder);
 
     decoder->setData(data, true);
 
-    OwnPtr<ImagePlanes> imagePlanes = adoptPtr(new ImagePlanes(planes, rowBytes));
+    std::unique_ptr<ImagePlanes> imagePlanes = wrapUnique(new ImagePlanes(planes, rowBytes));
     decoder->setImagePlanes(std::move(imagePlanes));
 
     ASSERT(decoder->canDecodeToYUV());
 
     if (decoder->decodeToYUV()) {
         setHasAlpha(0, false); // YUV is always opaque
         return true;
     }
 
     ASSERT(decoder->failed());
@@ skipping 14 matching lines @@
 
     SkBitmap fullSizeImage;
     bool complete = decode(data, allDataReceived, index, &decoder, &fullSizeImage, allocator);
 
     if (!decoder)
         return SkBitmap();
 
     // If we are not resuming decoding that means the decoder is freshly
     // created and we have ownership. If we are resuming decoding then
     // the decoder is owned by ImageDecodingStore.
-    OwnPtr<ImageDecoder> decoderContainer;
+    std::unique_ptr<ImageDecoder> decoderContainer;
     if (!resumeDecoding)
-        decoderContainer = adoptPtr(decoder);
+        decoderContainer = wrapUnique(decoder);
 
     if (fullSizeImage.isNull()) {
         // If decoding has failed, we can save work in the future by
         // ignoring further requests to decode the image.
         m_decodeFailed = decoder->failed();
         if (resumeDecoding)
             ImageDecodingStore::instance().unlockDecoder(this, decoder);
         return SkBitmap();
     }
 
@@ skipping 40 matching lines @@
 {
     ASSERT(m_decodeMutex.locked());
     TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     // Try to create an ImageDecoder if we are not given one.
     ASSERT(decoder);
     bool newDecoder = false;
     if (!*decoder) {
         newDecoder = true;
         if (m_imageDecoderFactory)
-            *decoder = m_imageDecoderFactory->create().leakPtr();
+            *decoder = m_imageDecoderFactory->create().release();
 
         if (!*decoder)
-            *decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied).leakPtr();
+            *decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied).release();
 
         if (!*decoder)
             return false;
     }
 
     if (!m_isMultiFrame && newDecoder && allDataReceived) {
         // If we're using an external memory allocator that means we're decoding
         // directly into the output memory and we can save one memcpy.
         ASSERT(allocator);
         (*decoder)->setMemoryAllocator(allocator);
@@ skipping 39 matching lines @@
     return true;
 }
 
 bool ImageFrameGenerator::getYUVComponentSizes(SegmentReader* data, SkYUVSizeInfo* sizeInfo)
 {
     TRACE_EVENT2("blink", "ImageFrameGenerator::getYUVComponentSizes", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     if (m_yuvDecodingFailed)
         return false;
 
-    OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
+    std::unique_ptr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
     if (!decoder)
         return false;
 
     // Setting a dummy ImagePlanes object signals to the decoder that we want to do YUV decoding.
     decoder->setData(data, true);
-    OwnPtr<ImagePlanes> dummyImagePlanes = adoptPtr(new ImagePlanes);
+    std::unique_ptr<ImagePlanes> dummyImagePlanes = wrapUnique(new ImagePlanes);
     decoder->setImagePlanes(std::move(dummyImagePlanes));
 
     return updateYUVComponentSizes(decoder.get(), sizeInfo->fSizes, sizeInfo->fWidthBytes);
 }
 
 } // namespace blink