Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/modules/fetch/FetchDataLoader.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 "modules/fetch/FetchDataLoader.h"
 
 #include "core/html/parser/TextResourceDecoder.h"
-#include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferBuilder.h"
-#include <memory>
 
 namespace blink {
 
 namespace {
 
 class FetchDataLoaderAsBlobHandle
     : public FetchDataLoader
     , public WebDataConsumerHandle::Client {
 public:
     explicit FetchDataLoaderAsBlobHandle(const String& mimeType)
@@ skipping 73 matching lines @@
         }
     }
 
     void cancel() override
     {
         m_reader.reset();
         m_blobData.reset();
         m_client.clear();
     }
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> m_reader;
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
     Member<FetchDataLoader::Client> m_client;
 
     String m_mimeType;
-    std::unique_ptr<BlobData> m_blobData;
+    OwnPtr<BlobData> m_blobData;
 };
 
 class FetchDataLoaderAsArrayBuffer
     : public FetchDataLoader
     , public WebDataConsumerHandle::Client {
 public:
     FetchDataLoaderAsArrayBuffer()
         : m_client(nullptr) { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 protected:
     void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
     {
         ASSERT(!m_client);
         ASSERT(!m_rawData);
         ASSERT(!m_reader);
         m_client = client;
-        m_rawData = wrapUnique(new ArrayBufferBuilder());
+        m_rawData = adoptPtr(new ArrayBufferBuilder());
         m_reader = handle->obtainReader(this);
     }
 
     void didGetReadable() override
     {
         ASSERT(m_client);
         ASSERT(m_rawData);
         ASSERT(m_reader);
 
         while (true) {
@@ skipping 42 matching lines @@
         m_client.clear();
     }
 
     void cancel() override
     {
         m_reader.reset();
         m_rawData.reset();
         m_client.clear();
     }
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> m_reader;
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
     Member<FetchDataLoader::Client> m_client;
 
-    std::unique_ptr<ArrayBufferBuilder> m_rawData;
+    OwnPtr<ArrayBufferBuilder> m_rawData;
 };
 
 class FetchDataLoaderAsString
     : public FetchDataLoader
     , public WebDataConsumerHandle::Client {
 public:
     FetchDataLoaderAsString()
         : m_client(nullptr) { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
@@ skipping 62 matching lines @@
     }
 
     void cancel() override
     {
         m_reader.reset();
         m_builder.clear();
         m_decoder.reset();
         m_client.clear();
     }
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> m_reader;
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
     Member<FetchDataLoader::Client> m_client;
 
-    std::unique_ptr<TextResourceDecoder> m_decoder;
+    OwnPtr<TextResourceDecoder> m_decoder;
     StringBuilder m_builder;
 };
 
 class FetchDataLoaderAsStream
     : public FetchDataLoader
     , public WebDataConsumerHandle::Client {
 public:
     explicit FetchDataLoaderAsStream(Stream* outStream)
         : m_client(nullptr)
         , m_outStream(outStream) { }
@@ skipping 68 matching lines @@
         cleanup();
     }
 
     void cleanup()
     {
         m_reader.reset();
         m_client.clear();
         m_outStream.clear();
     }
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> m_reader;
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
     Member<FetchDataLoader::Client> m_client;
 
     Member<Stream> m_outStream;
 };
 
 
 } // namespace
 
 FetchDataLoader* FetchDataLoader::createLoaderAsBlobHandle(const String& mimeType)
 {
     return new FetchDataLoaderAsBlobHandle(mimeType);
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsArrayBuffer()
 {
     return new FetchDataLoaderAsArrayBuffer();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsString()
 {
     return new FetchDataLoaderAsString();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsStream(Stream* outStream)
 {
     return new FetchDataLoaderAsStream(outStream);
 }
 
 } // namespace blink