Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/fetch/DataConsumerHandleUtil.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/DataConsumerHandleUtil.h"
 
 #include "platform/blob/BlobData.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Functional.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 
 using Result = WebDataConsumerHandle::Result;
 
 namespace {
 
 class WaitingHandle final : public WebDataConsumerHandle {
 private:
     class ReaderImpl final : public WebDataConsumerHandle::Reader {
@@ skipping 41 matching lines @@
 };
 
 class UnexpectedErrorHandle final : public WebDataConsumerHandle {
 private:
     Reader* obtainReaderInternal(Client* client) override { return new RepeatingReader(UnexpectedError, client); }
     const char* debugName() const override { return "UnexpectedErrorHandle"; }
 };
 
 class WebToFetchDataConsumerHandleAdapter : public FetchDataConsumerHandle {
 public:
-    WebToFetchDataConsumerHandleAdapter(PassOwnPtr<WebDataConsumerHandle> handle) : m_handle(std::move(handle)) { }
+    WebToFetchDataConsumerHandleAdapter(std::unique_ptr<WebDataConsumerHandle> handle) : m_handle(std::move(handle)) { }
 private:
     class ReaderImpl final : public FetchDataConsumerHandle::Reader {
     public:
-        ReaderImpl(PassOwnPtr<WebDataConsumerHandle::Reader> reader) : m_reader(std::move(reader)) { }
+        ReaderImpl(std::unique_ptr<WebDataConsumerHandle::Reader> reader) : m_reader(std::move(reader)) { }
         Result read(void* data, size_t size, Flags flags, size_t* readSize) override
         {
             return m_reader->read(data, size, flags, readSize);
         }
 
         Result beginRead(const void** buffer, Flags flags, size_t* available) override
         {
             return m_reader->beginRead(buffer, flags, available);
         }
         Result endRead(size_t readSize) override
         {
             return m_reader->endRead(readSize);
         }
     private:
-        OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+        std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
     };
 
     Reader* obtainReaderInternal(Client* client) override { return new ReaderImpl(m_handle->obtainReader(client)); }
 
     const char* debugName() const override { return m_handle->debugName(); }
 
-    OwnPtr<WebDataConsumerHandle> m_handle;
+    std::unique_ptr<WebDataConsumerHandle> m_handle;
 };
 
 } // namespace
 
-PassOwnPtr<WebDataConsumerHandle> createWaitingDataConsumerHandle()
+std::unique_ptr<WebDataConsumerHandle> createWaitingDataConsumerHandle()
 {
-    return adoptPtr(new WaitingHandle);
+    return wrapUnique(new WaitingHandle);
 }
 
-PassOwnPtr<WebDataConsumerHandle> createDoneDataConsumerHandle()
+std::unique_ptr<WebDataConsumerHandle> createDoneDataConsumerHandle()
 {
-    return adoptPtr(new DoneHandle);
+    return wrapUnique(new DoneHandle);
 }
 
-PassOwnPtr<WebDataConsumerHandle> createUnexpectedErrorDataConsumerHandle()
+std::unique_ptr<WebDataConsumerHandle> createUnexpectedErrorDataConsumerHandle()
 {
-    return adoptPtr(new UnexpectedErrorHandle);
+    return wrapUnique(new UnexpectedErrorHandle);
 }
 
-PassOwnPtr<FetchDataConsumerHandle> createFetchDataConsumerHandleFromWebHandle(PassOwnPtr<WebDataConsumerHandle> handle)
+std::unique_ptr<FetchDataConsumerHandle> createFetchDataConsumerHandleFromWebHandle(std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    return adoptPtr(new WebToFetchDataConsumerHandleAdapter(std::move(handle)));
+    return wrapUnique(new WebToFetchDataConsumerHandleAdapter(std::move(handle)));
 }
 
 NotifyOnReaderCreationHelper::NotifyOnReaderCreationHelper(WebDataConsumerHandle::Client* client)
     : m_factory(this)
 {
     if (!client)
         return;
     // Note we don't need thread safety here because this object is
     // bound to the current thread.
     Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, bind(&NotifyOnReaderCreationHelper::notify, m_factory.createWeakPtr(), client));
 }
 
 void NotifyOnReaderCreationHelper::notify(WebDataConsumerHandle::Client* client)
 {
     // |client| dereference is safe here because:
     // - |this| is owned by a reader,
     //   so the reader outlives |this|, and
     // - |client| is the client of the reader, so |client| outlives the reader
     //   (guaranteed by the user of the reader),
     // and therefore |client| outlives |this|.
     client->didGetReadable();
 }
 
 } // namespace blink