Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/modules/fetch/FetchBlobDataConsumerHandle.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/FetchBlobDataConsumerHandle.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "modules/fetch/CompositeDataConsumerHandle.h"
 #include "modules/fetch/CrossThreadHolder.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "platform/blob/BlobRegistry.h"
 #include "platform/blob/BlobURL.h"
 #include "platform/network/ResourceRequest.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
+#include "wtf/OwnPtr.h"
 
 namespace blink {
 
 using Result = FetchBlobDataConsumerHandle::Result;
 
 namespace {
 
 // Object graph:
 //                                           +-------------+
 //                                           |ReaderContext|
@@ skipping 68 matching lines @@
         ASSERT(m_loader);
 
         ResourceRequest request(url);
         request.setRequestContext(WebURLRequest::RequestContextInternal);
         request.setUseStreamOnResponse(true);
         // We intentionally skip 'setExternalRequestStateFromRequestorAddressSpace', as 'data:' can never be external.
         m_loader->start(request);
     }
 
 private:
-    std::unique_ptr<ThreadableLoader> createLoader(ExecutionContext* executionContext, ThreadableLoaderClient* client) const
+    PassOwnPtr<ThreadableLoader> createLoader(ExecutionContext* executionContext, ThreadableLoaderClient* client) const
     {
         ThreadableLoaderOptions options;
         options.preflightPolicy = ConsiderPreflight;
         options.crossOriginRequestPolicy = DenyCrossOriginRequests;
         options.contentSecurityPolicyEnforcement = DoNotEnforceContentSecurityPolicy;
         options.initiator = FetchInitiatorTypeNames::internal;
 
         ResourceLoaderOptions resourceLoaderOptions;
         resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
 
         return m_loaderFactory->create(*executionContext, client, options, resourceLoaderOptions);
     }
 
     // ThreadableLoaderClient
-    void didReceiveResponse(unsigned long, const ResourceResponse&, std::unique_ptr<WebDataConsumerHandle> handle) override
+    void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle> handle) override
     {
         ASSERT(!m_receivedResponse);
         m_receivedResponse = true;
         if (!handle) {
             // Here we assume WebURLLoader must return the response body as
             // |WebDataConsumerHandle| since we call
             // request.setUseStreamOnResponse().
             m_updater->update(createUnexpectedErrorDataConsumerHandle());
             return;
         }
@@ skipping 15 matching lines @@
     void didFailRedirectCheck() override
     {
         // We don't expect redirects for Blob loading.
         ASSERT_NOT_REACHED();
     }
 
     Persistent<CompositeDataConsumerHandle::Updater> m_updater;
 
     RefPtr<BlobDataHandle> m_blobDataHandle;
     Persistent<FetchBlobDataConsumerHandle::LoaderFactory> m_loaderFactory;
-    std::unique_ptr<ThreadableLoader> m_loader;
+    OwnPtr<ThreadableLoader> m_loader;
 
     bool m_receivedResponse;
 };
 
 class DefaultLoaderFactory final : public FetchBlobDataConsumerHandle::LoaderFactory {
 public:
-    std::unique_ptr<ThreadableLoader> create(
+    PassOwnPtr<ThreadableLoader> create(
         ExecutionContext& executionContext,
         ThreadableLoaderClient* client,
         const ThreadableLoaderOptions& options,
         const ResourceLoaderOptions& resourceLoaderOptions) override
     {
         return ThreadableLoader::create(executionContext, client, options, resourceLoaderOptions);
     }
 };
 
 } // namespace
 
 // ReaderContext is referenced from FetchBlobDataConsumerHandle and
 // ReaderContext::ReaderImpl.
 // All functions/members must be called/accessed only on the reader thread,
 // except for constructor, destructor, and obtainReader().
 class FetchBlobDataConsumerHandle::ReaderContext final : public ThreadSafeRefCounted<ReaderContext> {
 public:
     class ReaderImpl : public FetchDataConsumerHandle::Reader {
     public:
-        ReaderImpl(Client* client, PassRefPtr<ReaderContext> readerContext, std::unique_ptr<WebDataConsumerHandle::Reader> reader)
+        ReaderImpl(Client* client, PassRefPtr<ReaderContext> readerContext, PassOwnPtr<WebDataConsumerHandle::Reader> reader)
             : m_readerContext(readerContext)
             , m_reader(std::move(reader))
             , m_notifier(client) { }
         ~ReaderImpl() override { }
 
         Result read(void* data, size_t size, Flags flags, size_t* readSize) override
         {
             if (m_readerContext->drained())
                 return Done;
             m_readerContext->ensureStartLoader();
@@ skipping 37 matching lines @@
             RefPtr<BlobDataHandle> handle = drainAsBlobDataHandle(AllowBlobWithInvalidSize);
             if (!handle)
                 return nullptr;
             RefPtr<EncodedFormData> formData = EncodedFormData::create();
             formData->appendBlob(handle->uuid(), handle);
             return formData.release();
         }
 
     private:
         RefPtr<ReaderContext> m_readerContext;
-        std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
+        OwnPtr<WebDataConsumerHandle::Reader> m_reader;
         NotifyOnReaderCreationHelper m_notifier;
     };
 
     ReaderContext(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle, FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
         : m_blobDataHandleForDrain(blobDataHandle)
         , m_loaderStarted(false)
         , m_drained(false)
     {
         CompositeDataConsumerHandle::Updater* updater = nullptr;
         m_handle = CompositeDataConsumerHandle::create(createWaitingDataConsumerHandle(), &updater);
-        m_loaderContextHolder = CrossThreadHolder<LoaderContext>::create(executionContext, wrapUnique(new BlobLoaderContext(updater, m_blobDataHandleForDrain, loaderFactory)));
+        m_loaderContextHolder = CrossThreadHolder<LoaderContext>::create(executionContext, adoptPtr(new BlobLoaderContext(updater, m_blobDataHandleForDrain, loaderFactory)));
     }
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> obtainReader(WebDataConsumerHandle::Client* client)
+    PassOwnPtr<FetchDataConsumerHandle::Reader> obtainReader(WebDataConsumerHandle::Client* client)
     {
-        return wrapUnique(new ReaderImpl(client, this, m_handle->obtainReader(client)));
+        return adoptPtr(new ReaderImpl(client, this, m_handle->obtainReader(client)));
     }
 
 private:
     void ensureStartLoader()
     {
         if (m_loaderStarted)
             return;
         m_loaderStarted = true;
         m_loaderContextHolder->postTask(threadSafeBind<LoaderContext*, ExecutionContext*>(&LoaderContext::start));
     }
 
     void clearBlobDataHandleForDrain()
     {
         m_blobDataHandleForDrain.clear();
     }
 
     bool drained() const { return m_drained; }
     void setDrained() { m_drained = true; }
 
-    std::unique_ptr<WebDataConsumerHandle> m_handle;
+    OwnPtr<WebDataConsumerHandle> m_handle;
     RefPtr<BlobDataHandle> m_blobDataHandleForDrain;
-    std::unique_ptr<CrossThreadHolder<LoaderContext>> m_loaderContextHolder;
+    OwnPtr<CrossThreadHolder<LoaderContext>> m_loaderContextHolder;
 
     bool m_loaderStarted;
     bool m_drained;
 };
 
 FetchBlobDataConsumerHandle::FetchBlobDataConsumerHandle(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle, LoaderFactory* loaderFactory)
     : m_readerContext(adoptRef(new ReaderContext(executionContext, blobDataHandle, loaderFactory)))
 {
 }
 
 FetchBlobDataConsumerHandle::~FetchBlobDataConsumerHandle()
 {
 }
 
-std::unique_ptr<FetchDataConsumerHandle> FetchBlobDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle, LoaderFactory* loaderFactory)
+PassOwnPtr<FetchDataConsumerHandle> FetchBlobDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle, LoaderFactory* loaderFactory)
 {
     if (!blobDataHandle)
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
 
-    return wrapUnique(new FetchBlobDataConsumerHandle(executionContext, blobDataHandle, loaderFactory));
+    return adoptPtr(new FetchBlobDataConsumerHandle(executionContext, blobDataHandle, loaderFactory));
 }
 
-std::unique_ptr<FetchDataConsumerHandle> FetchBlobDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle)
+PassOwnPtr<FetchDataConsumerHandle> FetchBlobDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobDataHandle)
 {
     if (!blobDataHandle)
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
 
-    return wrapUnique(new FetchBlobDataConsumerHandle(executionContext, blobDataHandle, new DefaultLoaderFactory));
+    return adoptPtr(new FetchBlobDataConsumerHandle(executionContext, blobDataHandle, new DefaultLoaderFactory));
 }
 
 FetchDataConsumerHandle::Reader* FetchBlobDataConsumerHandle::obtainReaderInternal(Client* client)
 {
-    return m_readerContext->obtainReader(client).release();
+    return m_readerContext->obtainReader(client).leakPtr();
 }
 
 } // namespace blink