Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/fetch/CompositeDataConsumerHandle.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/CompositeDataConsumerHandle.h"
 
 #include "platform/ThreadSafeFunctional.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Locker.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
+#include <memory>
 
 namespace blink {
 
 using Result = WebDataConsumerHandle::Result;
 
 class CompositeDataConsumerHandle::ReaderImpl final : public WebDataConsumerHandle::Reader {
 public:
     explicit ReaderImpl(PassRefPtr<Context>);
     ~ReaderImpl() override;
     Result read(void* data, size_t /* size */, Flags, size_t* readSize) override;
     Result beginRead(const void** buffer, Flags, size_t* available) override;
     Result endRead(size_t readSize) override;
 
 private:
     RefPtr<Context> m_context;
 };
 
 class CompositeDataConsumerHandle::Context final : public ThreadSafeRefCounted<Context> {
 public:
     using Token = unsigned;
-    static PassRefPtr<Context> create(PassOwnPtr<WebDataConsumerHandle> handle) { return adoptRef(new Context(std::move(handle))); }
+    static PassRefPtr<Context> create(std::unique_ptr<WebDataConsumerHandle> handle) { return adoptRef(new Context(std::move(handle))); }
     ~Context()
     {
         ASSERT(!m_readerThread);
         ASSERT(!m_reader);
         ASSERT(!m_client);
     }
-    PassOwnPtr<ReaderImpl> obtainReader(Client* client)
+    std::unique_ptr<ReaderImpl> obtainReader(Client* client)
     {
         MutexLocker locker(m_mutex);
         ASSERT(!m_readerThread);
         ASSERT(!m_reader);
         ASSERT(!m_client);
         ++m_token;
         m_client = client;
         m_readerThread = Platform::current()->currentThread();
         m_reader = m_handle->obtainReader(m_client);
-        return adoptPtr(new ReaderImpl(this));
+        return wrapUnique(new ReaderImpl(this));
     }
     void detachReader()
     {
         MutexLocker locker(m_mutex);
         ASSERT(m_readerThread);
         ASSERT(m_readerThread->isCurrentThread());
         ASSERT(m_reader);
         ASSERT(!m_isInTwoPhaseRead);
         ASSERT(!m_isUpdateWaitingForEndRead);
         ++m_token;
         m_reader = nullptr;
         m_readerThread = nullptr;
         m_client = nullptr;
     }
-    void update(PassOwnPtr<WebDataConsumerHandle> handle)
+    void update(std::unique_ptr<WebDataConsumerHandle> handle)
     {
         MutexLocker locker(m_mutex);
         m_handle = std::move(handle);
         if (!m_readerThread) {
             // There is no reader.
             return;
         }
         ++m_token;
         updateReaderNoLock(m_token);
     }
@@ skipping 21 matching lines @@
             // We need this lock to access |m_handle|.
             MutexLocker locker(m_mutex);
             m_reader = nullptr;
             m_reader = m_handle->obtainReader(m_client);
             m_isUpdateWaitingForEndRead = false;
         }
         return r;
     }
 
 private:
-    explicit Context(PassOwnPtr<WebDataConsumerHandle> handle)
+    explicit Context(std::unique_ptr<WebDataConsumerHandle> handle)
         : m_handle(std::move(handle))
         , m_readerThread(nullptr)
         , m_client(nullptr)
         , m_token(0)
         , m_isUpdateWaitingForEndRead(false)
         , m_isInTwoPhaseRead(false)
     {
     }
     void updateReader(Token token)
     {
@@ skipping 16 matching lines @@
             }
             // Unregister the old one, then register the new one.
             m_reader = nullptr;
             m_reader = m_handle->obtainReader(m_client);
             return;
         }
         ++m_token;
         m_readerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&Context::updateReader, this, m_token));
     }
 
-    OwnPtr<Reader> m_reader;
-    OwnPtr<WebDataConsumerHandle> m_handle;
+    std::unique_ptr<Reader> m_reader;
+    std::unique_ptr<WebDataConsumerHandle> m_handle;
     // Note: Holding a WebThread raw pointer is not generally safe, but we can
     // do that in this case because:
     //  1. Destructing a ReaderImpl when the bound thread ends is a user's
     //     responsibility.
     //  2. |m_readerThread| will never be used after the associated reader is
     //     detached.
     WebThread* m_readerThread;
     Client* m_client;
     Token m_token;
     // These boolean values are bound to the reader thread.
@@ skipping 27 matching lines @@
 CompositeDataConsumerHandle::Updater::Updater(PassRefPtr<Context> context)
     : m_context(context)
 #if ENABLE(ASSERT)
     , m_thread(Platform::current()->currentThread())
 #endif
 {
 }
 
 CompositeDataConsumerHandle::Updater::~Updater() {}
 
-void CompositeDataConsumerHandle::Updater::update(PassOwnPtr<WebDataConsumerHandle> handle)
+void CompositeDataConsumerHandle::Updater::update(std::unique_ptr<WebDataConsumerHandle> handle)
 {
     ASSERT(handle);
     ASSERT(m_thread->isCurrentThread());
     m_context->update(std::move(handle));
 }
 
-CompositeDataConsumerHandle::CompositeDataConsumerHandle(PassOwnPtr<WebDataConsumerHandle> handle, Updater** updater)
+CompositeDataConsumerHandle::CompositeDataConsumerHandle(std::unique_ptr<WebDataConsumerHandle> handle, Updater** updater)
     : m_context(Context::create(std::move(handle)))
 {
     *updater = new Updater(m_context);
 }
 
 CompositeDataConsumerHandle::~CompositeDataConsumerHandle() { }
 
 WebDataConsumerHandle::Reader* CompositeDataConsumerHandle::obtainReaderInternal(Client* client)
 {
-    return m_context->obtainReader(client).leakPtr();
+    return m_context->obtainReader(client).release();
 }
 
 } // namespace blink