Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/image-decoders/ImageDecoderTestHelpers.cpp

 // Copyright 2015 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/image-decoders/ImageDecoderTestHelpers.h"
 
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/image-decoders/ImageFrame.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "wtf/OwnPtr.h"
 #include "wtf/StringHasher.h"
+#include <memory>
 
 namespace blink {
 
 PassRefPtr<SharedBuffer> readFile(const char* fileName)
 {
     String filePath = testing::blinkRootDir();
     filePath.append(fileName);
     return testing::readFromFile(filePath);
 }
 
 PassRefPtr<SharedBuffer> readFile(const char* dir, const char* fileName)
 {
     String filePath = testing::blinkRootDir();
     filePath.append("/");
     filePath.append(dir);
     filePath.append("/");
     filePath.append(fileName);
 
     return testing::readFromFile(filePath);
 }
 
 unsigned hashBitmap(const SkBitmap& bitmap)
 {
     return StringHasher::hashMemory(bitmap.getPixels(), bitmap.getSize());
 }
 
 static unsigned createDecodingBaseline(DecoderCreator createDecoder, SharedBuffer* data)
 {
-    OwnPtr<ImageDecoder> decoder = createDecoder();
+    std::unique_ptr<ImageDecoder> decoder = createDecoder();
     decoder->setData(data, true);
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     return hashBitmap(frame->bitmap());
 }
 
 void createDecodingBaseline(DecoderCreator createDecoder, SharedBuffer* data, Vector<unsigned>* baselineHashes)
 {
-    OwnPtr<ImageDecoder> decoder = createDecoder();
+    std::unique_ptr<ImageDecoder> decoder = createDecoder();
     decoder->setData(data, true);
     size_t frameCount = decoder->frameCount();
     for (size_t i = 0; i < frameCount; ++i) {
         ImageFrame* frame = decoder->frameBufferAtIndex(i);
         baselineHashes->append(hashBitmap(frame->bitmap()));
     }
 }
 
 void testByteByByteDecode(DecoderCreator createDecoder, const char* file, size_t expectedFrameCount, int expectedRepetitionCount)
 {
     RefPtr<SharedBuffer> data = readFile(file);
     ASSERT_TRUE(data.get());
     ASSERT_TRUE(data->data());
 
     Vector<unsigned> baselineHashes;
     createDecodingBaseline(createDecoder, data.get(), &baselineHashes);
 
-    OwnPtr<ImageDecoder> decoder = createDecoder();
+    std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
     size_t frameCount = 0;
     size_t framesDecoded = 0;
 
     // Pass data to decoder byte by byte.
     RefPtr<SharedBuffer> sourceData[2] = { SharedBuffer::create(), SharedBuffer::create() };
     const char* source = data->data();
 
     for (size_t length = 1; length <= data->size() && !decoder->failed(); ++length) {
         sourceData[0]->append(source, 1u);
@@ skipping 43 matching lines @@
     const unsigned hash = createDecodingBaseline(createDecoder, data.get());
 
     // In order to do any verification, this test needs to move the data owned
     // by the SharedBuffer. A way to guarantee that is to create a new one, and
     // then append a string of characters greater than kSegmentSize. This
     // results in writing the data into a segment, skipping the internal
     // contiguous buffer.
     RefPtr<SharedBuffer> segmentedData = SharedBuffer::create();
     segmentedData->append(data->data(), data->size());
 
-    OwnPtr<ImageDecoder> decoder = createDecoder();
+    std::unique_ptr<ImageDecoder> decoder = createDecoder();
     decoder->setData(segmentedData.get(), true);
 
     ASSERT_TRUE(decoder->isSizeAvailable());
 
     // This will call SharedBuffer::mergeSegmentsIntoBuffer, copying all
     // segments into the contiguous buffer. If the ImageDecoder was pointing to
     // data in a segment, its pointer would no longer be valid.
     segmentedData->data();
 
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     ASSERT_FALSE(decoder->failed());
     EXPECT_EQ(frame->getStatus(), ImageFrame::FrameComplete);
     EXPECT_EQ(hashBitmap(frame->bitmap()), hash);
 }
 
 } // namespace blink