Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/fetch/DataConsumerTee.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/DataConsumerTee.h"
 
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchBlobDataConsumerHandle.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Deque.h"
 #include "wtf/Functional.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
+#include <memory>
 
 namespace blink {
 
 using Result = WebDataConsumerHandle::Result;
 using Flags = WebDataConsumerHandle::Flags;
 
 namespace {
 
 // This file contains the "tee" implementation. There are several classes and
 // their relationship is complicated, so let me describe here.
@@ skipping 109 matching lines @@
     };
 
     static PassRefPtr<DestinationContext> create() { return adoptRef(new DestinationContext()); }
 
     void enqueue(const char* buffer, size_t size)
     {
         bool needsNotification = false;
         {
             MutexLocker locker(m_mutex);
             needsNotification = m_queue.isEmpty();
-            OwnPtr<Vector<char>> data = adoptPtr(new Vector<char>);
+            std::unique_ptr<Vector<char>> data = wrapUnique(new Vector<char>);
             data->append(buffer, size);
             m_queue.append(std::move(data));
         }
         if (needsNotification)
             notify();
     }
 
     void setResult(Result r)
     {
         ASSERT(r != WebDataConsumerHandle::Ok);
@@ skipping 40 matching lines @@
         ASSERT(!m_client);
         m_readerThread = Platform::current()->currentThread();
         m_client = client;
     }
     void detachReader()
     {
         ASSERT(m_readerThread && m_readerThread->isCurrentThread());
         m_readerThread = nullptr;
         m_client = nullptr;
     }
-    const OwnPtr<Vector<char>>& top() const { return m_queue.first(); }
+    const std::unique_ptr<Vector<char>>& top() const { return m_queue.first(); }
     bool isEmpty() const { return m_queue.isEmpty(); }
     size_t offset() const { return m_offset; }
     void consume(size_t size)
     {
         const auto& top = m_queue.first();
         ASSERT(m_offset <= m_offset + size);
         ASSERT(m_offset + size <= top->size());
         if (top->size() <= m_offset + size) {
             m_offset = 0;
             m_queue.removeFirst();
@@ skipping 15 matching lines @@
 
     void detach()
     {
         MutexLocker locker(m_mutex);
         ASSERT(!m_client);
         ASSERT(!m_readerThread);
         m_queue.clear();
     }
 
     Result m_result;
-    Deque<OwnPtr<Vector<char>>> m_queue;
+    Deque<std::unique_ptr<Vector<char>>> m_queue;
     // 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;
     WebDataConsumerHandle::Client* m_client;
     size_t m_offset;
     bool m_isTwoPhaseReadInProgress;
@@ skipping 21 matching lines @@
     }
 
     Result beginRead(const void** buffer, Flags, size_t* available) override
     {
         MutexLocker locker(context()->mutex());
         *available = 0;
         *buffer = nullptr;
         if (context()->isEmpty())
             return context()->getResult();
 
-        const OwnPtr<Vector<char>>& chunk = context()->top();
+        const std::unique_ptr<Vector<char>>& chunk = context()->top();
         *available = chunk->size() - context()->offset();
         *buffer = chunk->data() + context()->offset();
         return WebDataConsumerHandle::Ok;
     }
 
     Result endRead(size_t readSize) override
     {
         MutexLocker locker(context()->mutex());
         if (context()->isEmpty())
             return WebDataConsumerHandle::UnexpectedError;
         context()->consume(readSize);
         return WebDataConsumerHandle::Ok;
     }
 
 private:
     DestinationContext* context() { return m_contextProxy->context(); }
 
     RefPtr<DestinationContext::Proxy> m_contextProxy;
 };
 
 class DestinationHandle final : public WebDataConsumerHandle {
 public:
-    static PassOwnPtr<WebDataConsumerHandle> create(PassRefPtr<DestinationContext::Proxy> contextProxy)
+    static std::unique_ptr<WebDataConsumerHandle> create(PassRefPtr<DestinationContext::Proxy> contextProxy)
     {
-        return adoptPtr(new DestinationHandle(contextProxy));
+        return wrapUnique(new DestinationHandle(contextProxy));
     }
 
 private:
     DestinationHandle(PassRefPtr<DestinationContext::Proxy> contextProxy) : m_contextProxy(contextProxy) { }
     DestinationReader* obtainReaderInternal(Client* client) { return new DestinationReader(m_contextProxy, client); }
     const char* debugName() const override { return "DestinationHandle"; }
 
     RefPtr<DestinationContext::Proxy> m_contextProxy;
 };
 
 // Bound to the created thread.
 class SourceContext final : public GarbageCollectedFinalized<SourceContext>, public ActiveDOMObject, public WebDataConsumerHandle::Client {
     USING_GARBAGE_COLLECTED_MIXIN(SourceContext);
 public:
     SourceContext(
         PassRefPtr<TeeRootObject> root,
-        PassOwnPtr<WebDataConsumerHandle> src,
+        std::unique_ptr<WebDataConsumerHandle> src,
         PassRefPtr<DestinationContext> dest1,
         PassRefPtr<DestinationContext> dest2,
         ExecutionContext* executionContext)
         : ActiveDOMObject(executionContext)
         , m_root(root)
         , m_reader(src->obtainReader(this))
         , m_dest1(dest1)
         , m_dest2(dest2)
     {
         suspendIfNeeded();
@@ skipping 44 matching lines @@
         m_dest1->setResult(WebDataConsumerHandle::UnexpectedError);
         m_dest2->setResult(WebDataConsumerHandle::UnexpectedError);
         m_root->stop();
         m_root = nullptr;
         m_reader = nullptr;
         m_dest1 = nullptr;
         m_dest2 = nullptr;
     }
 
     RefPtr<TeeRootObject> m_root;
-    OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+    std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
     RefPtr<DestinationContext> m_dest1;
     RefPtr<DestinationContext> m_dest2;
 };
 
 } // namespace
 
-void DataConsumerTee::create(ExecutionContext* executionContext, PassOwnPtr<WebDataConsumerHandle> src, OwnPtr<WebDataConsumerHandle>* dest1, OwnPtr<WebDataConsumerHandle>* dest2)
+void DataConsumerTee::create(ExecutionContext* executionContext, std::unique_ptr<WebDataConsumerHandle> src, std::unique_ptr<WebDataConsumerHandle>* dest1, std::unique_ptr<WebDataConsumerHandle>* dest2)
 {
     RefPtr<TeeRootObject> root = TeeRootObject::create();
     RefPtr<DestinationTracker> tracker = DestinationTracker::create(root);
     RefPtr<DestinationContext> context1 = DestinationContext::create();
     RefPtr<DestinationContext> context2 = DestinationContext::create();
 
     root->initialize(new SourceContext(root, std::move(src), context1, context2, executionContext));
 
     *dest1 = DestinationHandle::create(DestinationContext::Proxy::create(context1, tracker));
     *dest2 = DestinationHandle::create(DestinationContext::Proxy::create(context2, tracker));
 }
 
-void DataConsumerTee::create(ExecutionContext* executionContext, PassOwnPtr<FetchDataConsumerHandle> src, OwnPtr<FetchDataConsumerHandle>* dest1, OwnPtr<FetchDataConsumerHandle>* dest2)
+void DataConsumerTee::create(ExecutionContext* executionContext, std::unique_ptr<FetchDataConsumerHandle> src, std::unique_ptr<FetchDataConsumerHandle>* dest1, std::unique_ptr<FetchDataConsumerHandle>* dest2)
 {
     RefPtr<BlobDataHandle> blobDataHandle = src->obtainReader(nullptr)->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize);
     if (blobDataHandle) {
         *dest1 = FetchBlobDataConsumerHandle::create(executionContext, blobDataHandle);
         *dest2 = FetchBlobDataConsumerHandle::create(executionContext, blobDataHandle);
         return;
     }
 
-    OwnPtr<WebDataConsumerHandle> webDest1, webDest2;
-    DataConsumerTee::create(executionContext, static_cast<PassOwnPtr<WebDataConsumerHandle>>(std::move(src)), &webDest1, &webDest2);
+    std::unique_ptr<WebDataConsumerHandle> webDest1, webDest2;
+    DataConsumerTee::create(executionContext, static_cast<std::unique_ptr<WebDataConsumerHandle>>(std::move(src)), &webDest1, &webDest2);
     *dest1 = createFetchDataConsumerHandleFromWebHandle(std::move(webDest1));
     *dest2 = createFetchDataConsumerHandleFromWebHandle(std::move(webDest2));
     return;
 }
 
 } // namespace blink