Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

Index: third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
diff --git a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
index e629a0312679007a23d889b0ae11cc137f54c1eb..47cb1c700ea6b5174ed06d8e81166d1d89b7d48d 100644
--- a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
+++ b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
@@ -20,14 +20,13 @@
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Deque.h"
 #include "wtf/Locker.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
-
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <memory>
 #include <v8.h>
 
 namespace blink {
@@ -69,11 +68,11 @@ public:
         void initialize();
         void shutdown();
 
-        OwnPtr<WebThreadSupportingGC> m_thread;
+        std::unique_ptr<WebThreadSupportingGC> m_thread;
         const InitializationPolicy m_initializationPolicy;
-        OwnPtr<WaitableEvent> m_waitableEvent;
+        std::unique_ptr<WaitableEvent> m_waitableEvent;
         Persistent<NullExecutionContext> m_executionContext;
-        OwnPtr<gin::IsolateHolder> m_isolateHolder;
+        std::unique_ptr<gin::IsolateHolder> m_isolateHolder;
         RefPtr<ScriptState> m_scriptState;
     };
 
@@ -160,8 +159,8 @@ public:
         public:
             ThreadHolder(ThreadingTestBase* test)
                 : m_context(test->m_context)
-                , m_readingThread(adoptPtr(new Thread("reading thread")))
-                , m_updatingThread(adoptPtr(new Thread("updating thread")))
+                , m_readingThread(wrapUnique(new Thread("reading thread")))
+                , m_updatingThread(wrapUnique(new Thread("updating thread")))
             {
                 m_context->registerThreadHolder(this);
             }
@@ -175,8 +174,8 @@ public:
 
         private:
             RefPtr<Context> m_context;
-            OwnPtr<Thread> m_readingThread;
-            OwnPtr<Thread> m_updatingThread;
+            std::unique_ptr<Thread> m_readingThread;
+            std::unique_ptr<Thread> m_updatingThread;
         };
 
         class ReaderImpl final : public WebDataConsumerHandle::Reader {
@@ -200,9 +199,9 @@ public:
         class DataConsumerHandle final : public WebDataConsumerHandle {
             USING_FAST_MALLOC(DataConsumerHandle);
         public:
-            static PassOwnPtr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context)
+            static std::unique_ptr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context)
             {
-                return adoptPtr(new DataConsumerHandle(name, context));
+                return wrapUnique(new DataConsumerHandle(name, context));
             }
 
         private:
@@ -241,8 +240,8 @@ public:
             : m_context(Context::create()) { }
 
         RefPtr<Context> m_context;
-        OwnPtr<WebDataConsumerHandle::Reader> m_reader;
-        OwnPtr<WaitableEvent> m_waitableEvent;
+        std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
+        std::unique_ptr<WaitableEvent> m_waitableEvent;
         NoopClient m_client;
     };
 
@@ -251,10 +250,10 @@ public:
         using Self = ThreadingHandleNotificationTest;
         static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
-        void run(PassOwnPtr<WebDataConsumerHandle> handle)
+        void run(std::unique_ptr<WebDataConsumerHandle> handle)
         {
             ThreadHolder holder(this);
-            m_waitableEvent = adoptPtr(new WaitableEvent());
+            m_waitableEvent = wrapUnique(new WaitableEvent());
             m_handle = std::move(handle);
 
             postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, this));
@@ -272,7 +271,7 @@ public:
             postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, this));
         }
 
-        OwnPtr<WebDataConsumerHandle> m_handle;
+        std::unique_ptr<WebDataConsumerHandle> m_handle;
     };
 
     class ThreadingHandleNoNotificationTest : public ThreadingTestBase, public WebDataConsumerHandle::Client {
@@ -280,10 +279,10 @@ public:
         using Self = ThreadingHandleNoNotificationTest;
         static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
-        void run(PassOwnPtr<WebDataConsumerHandle> handle)
+        void run(std::unique_ptr<WebDataConsumerHandle> handle)
         {
             ThreadHolder holder(this);
-            m_waitableEvent = adoptPtr(new WaitableEvent());
+            m_waitableEvent = wrapUnique(new WaitableEvent());
             m_handle = std::move(handle);
 
             postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, this));
@@ -302,12 +301,12 @@ public:
             ASSERT_NOT_REACHED();
         }
 
-        OwnPtr<WebDataConsumerHandle> m_handle;
+        std::unique_ptr<WebDataConsumerHandle> m_handle;
     };
 
     class MockFetchDataConsumerHandle : public FetchDataConsumerHandle {
     public:
-        static PassOwnPtr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return adoptPtr(new ::testing::StrictMock<MockFetchDataConsumerHandle>); }
+        static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerHandle>); }
         MOCK_METHOD1(obtainReaderInternal, Reader*(Client*));
 
     private:
@@ -316,7 +315,7 @@ public:
 
     class MockFetchDataConsumerReader : public FetchDataConsumerHandle::Reader {
     public:
-        static PassOwnPtr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return adoptPtr(new ::testing::StrictMock<MockFetchDataConsumerReader>); }
+        static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerReader>); }
 
         using Result = WebDataConsumerHandle::Result;
         using Flags = WebDataConsumerHandle::Flags;
@@ -388,7 +387,7 @@ public:
     class ReplayingHandle final : public WebDataConsumerHandle {
         USING_FAST_MALLOC(ReplayingHandle);
     public:
-        static PassOwnPtr<ReplayingHandle> create() { return adoptPtr(new ReplayingHandle()); }
+        static std::unique_ptr<ReplayingHandle> create() { return wrapUnique(new ReplayingHandle()); }
         ~ReplayingHandle();
 
         // Add a command to this handle. This function must be called on the
@@ -425,7 +424,7 @@ public:
             Result m_result;
             bool m_isHandleAttached;
             Mutex m_mutex;
-            OwnPtr<WaitableEvent> m_detached;
+            std::unique_ptr<WaitableEvent> m_detached;
         };
 
         Context* getContext() { return m_context.get(); }
@@ -458,15 +457,15 @@ public:
     class HandleReader final : public WebDataConsumerHandle::Client {
         USING_FAST_MALLOC(HandleReader);
     public:
-        using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>;
+        using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
 
-        HandleReader(PassOwnPtr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
+        HandleReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
         void didGetReadable() override;
 
     private:
-        void runOnFinishedReading(PassOwnPtr<HandleReadResult>);
+        void runOnFinishedReading(std::unique_ptr<HandleReadResult>);
 
-        OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+        std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
         std::unique_ptr<OnFinishedReading> m_onFinishedReading;
         Vector<char> m_data;
     };
@@ -476,15 +475,15 @@ public:
     class HandleTwoPhaseReader final : public WebDataConsumerHandle::Client {
         USING_FAST_MALLOC(HandleTwoPhaseReader);
     public:
-        using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>;
+        using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
 
-        HandleTwoPhaseReader(PassOwnPtr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
+        HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
         void didGetReadable() override;
 
     private:
-        void runOnFinishedReading(PassOwnPtr<HandleReadResult>);
+        void runOnFinishedReading(std::unique_ptr<HandleReadResult>);
 
-        OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+        std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
         std::unique_ptr<OnFinishedReading> m_onFinishedReading;
         Vector<char> m_data;
     };
@@ -495,9 +494,9 @@ public:
     class HandleReaderRunner final {
         STACK_ALLOCATED();
     public:
-        explicit HandleReaderRunner(PassOwnPtr<WebDataConsumerHandle> handle)
-            : m_thread(adoptPtr(new Thread("reading thread")))
-            , m_event(adoptPtr(new WaitableEvent()))
+        explicit HandleReaderRunner(std::unique_ptr<WebDataConsumerHandle> handle)
+            : m_thread(wrapUnique(new Thread("reading thread")))
+            , m_event(wrapUnique(new WaitableEvent()))
             , m_isDone(false)
         {
             m_thread->thread()->postTask(BLINK_FROM_HERE, threadSafeBind(&HandleReaderRunner::start, AllowCrossThreadAccess(this), passed(std::move(handle))));
@@ -507,7 +506,7 @@ public:
             wait();
         }
 
-        PassOwnPtr<HandleReadResult> wait()
+        std::unique_ptr<HandleReadResult> wait()
         {
             if (m_isDone)
                 return nullptr;
@@ -517,24 +516,24 @@ public:
         }
 
     private:
-        void start(PassOwnPtr<WebDataConsumerHandle> handle)
+        void start(std::unique_ptr<WebDataConsumerHandle> handle)
         {
-            m_handleReader = adoptPtr(new T(std::move(handle), bind<PassOwnPtr<HandleReadResult>>(&HandleReaderRunner::onFinished, this)));
+            m_handleReader = wrapUnique(new T(std::move(handle), WTF::bind<std::unique_ptr<HandleReadResult>>(&HandleReaderRunner::onFinished, this)));
         }
 
-        void onFinished(PassOwnPtr<HandleReadResult> result)
+        void onFinished(std::unique_ptr<HandleReadResult> result)
         {
             m_handleReader = nullptr;
             m_result = std::move(result);
             m_event->signal();
         }
 
-        OwnPtr<Thread> m_thread;
-        OwnPtr<WaitableEvent> m_event;
-        OwnPtr<HandleReadResult> m_result;
+        std::unique_ptr<Thread> m_thread;
+        std::unique_ptr<WaitableEvent> m_event;
+        std::unique_ptr<HandleReadResult> m_result;
         bool m_isDone;
 
-        OwnPtr<T> m_handleReader;
+        std::unique_ptr<T> m_handleReader;
     };
 };