Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/fetch/FetchManager.cpp

 // Copyright 2014 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/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
@@ skipping 20 matching lines @@
 #include "modules/fetch/ResponseInit.h"
 #include "platform/HTTPNames.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
-#include "wtf/OwnPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
+#include <memory>
 
 namespace blink {
 
 namespace {
 
 bool IsRedirectStatusCode(int statusCode)
 {
     return (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307 || statusCode == 308);
 }
 
 } // namespace
 
 class FetchManager::Loader final : public GarbageCollectedFinalized<FetchManager::Loader>, public ThreadableLoaderClient {
     USING_PRE_FINALIZER(FetchManager::Loader, dispose);
 public:
     static Loader* create(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request, bool isIsolatedWorld)
     {
         return new Loader(executionContext, fetchManager, resolver, request, isIsolatedWorld);
     }
 
     ~Loader() override;
     DECLARE_VIRTUAL_TRACE();
 
-    void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) override;
+    void didReceiveResponse(unsigned long, const ResourceResponse&, std::unique_ptr<WebDataConsumerHandle>) override;
     void didFinishLoading(unsigned long, double) override;
     void didFail(const ResourceError&) override;
     void didFailAccessControlCheck(const ResourceError&) override;
     void didFailRedirectCheck() override;
 
     void start();
     void dispose();
 
     class SRIVerifier final : public GarbageCollectedFinalized<SRIVerifier>, public WebDataConsumerHandle::Client {
     public:
         // Promptly clear m_handle and m_reader.
         EAGERLY_FINALIZE();
         // SRIVerifier takes ownership of |handle| and |response|.
         // |updater| must be garbage collected. The other arguments
         // all must have the lifetime of the give loader.
-        SRIVerifier(PassOwnPtr<WebDataConsumerHandle> handle, CompositeDataConsumerHandle::Updater* updater, Response* response, FetchManager::Loader* loader, String integrityMetadata, const KURL& url)
+        SRIVerifier(std::unique_ptr<WebDataConsumerHandle> handle, CompositeDataConsumerHandle::Updater* updater, Response* response, FetchManager::Loader* loader, String integrityMetadata, const KURL& url)
             : m_handle(std::move(handle))
             , m_updater(updater)
             , m_response(response)
             , m_loader(loader)
             , m_integrityMetadata(integrityMetadata)
             , m_url(url)
             , m_finished(false)
         {
             m_reader = m_handle->obtainReader(this);
         }
@@ skipping 40 matching lines @@
 
         bool isFinished() const { return m_finished; }
 
         DEFINE_INLINE_TRACE()
         {
             visitor->trace(m_updater);
             visitor->trace(m_response);
             visitor->trace(m_loader);
         }
     private:
-        OwnPtr<WebDataConsumerHandle> m_handle;
+        std::unique_ptr<WebDataConsumerHandle> m_handle;
         Member<CompositeDataConsumerHandle::Updater> m_updater;
         Member<Response> m_response;
         Member<FetchManager::Loader> m_loader;
         String m_integrityMetadata;
         KURL m_url;
-        OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+        std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
         Vector<char> m_buffer;
         bool m_finished;
     };
 
 private:
     Loader(ExecutionContext*, FetchManager*, ScriptPromiseResolver*, FetchRequestData*, bool isIsolatedWorld);
 
     void performBasicFetch();
     void performNetworkError(const String& message);
     void performHTTPFetch(bool corsFlag, bool corsPreflightFlag);
     void performDataFetch();
     void failed(const String& message);
     void notifyFinished();
     Document* document() const;
     void loadSucceeded();
 
     Member<FetchManager> m_fetchManager;
     Member<ScriptPromiseResolver> m_resolver;
     Member<FetchRequestData> m_request;
-    OwnPtr<ThreadableLoader> m_loader;
+    std::unique_ptr<ThreadableLoader> m_loader;
     bool m_failed;
     bool m_finished;
     int m_responseHttpStatusCode;
     Member<SRIVerifier> m_integrityVerifier;
     bool m_didFinishLoading;
     bool m_isIsolatedWorld;
     Member<ExecutionContext> m_executionContext;
 };
 
 FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request, bool isIsolatedWorld)
@@ skipping 18 matching lines @@
 
 DEFINE_TRACE(FetchManager::Loader)
 {
     visitor->trace(m_fetchManager);
     visitor->trace(m_resolver);
     visitor->trace(m_request);
     visitor->trace(m_integrityVerifier);
     visitor->trace(m_executionContext);
 }
 
-void FetchManager::Loader::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
+void FetchManager::Loader::didReceiveResponse(unsigned long, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
     ASSERT(handle);
 
     if (response.url().protocolIs("blob") && response.httpStatusCode() == 404) {
         // "If |blob| is null, return a network error."
         // https://fetch.spec.whatwg.org/#concept-basic-fetch
         performNetworkError("Blob not found.");
         return;
     }
 
@@ skipping 335 matching lines @@
 
     // "1. Let |HTTPRequest| be a copy of |request|, except that |HTTPRequest|'s
     //  body is a tee of |request|'s body."
     // We use ResourceRequest class for HTTPRequest.
     // FIXME: Support body.
     ResourceRequest request(m_request->url());
     request.setRequestContext(m_request->context());
     request.setHTTPMethod(m_request->method());
     request.setFetchRequestMode(m_request->mode());
     request.setFetchCredentialsMode(m_request->credentials());
-    const Vector<OwnPtr<FetchHeaderList::Header>>& list = m_request->headerList()->list();
+    const Vector<std::unique_ptr<FetchHeaderList::Header>>& list = m_request->headerList()->list();
     for (size_t i = 0; i < list.size(); ++i) {
         request.addHTTPHeaderField(AtomicString(list[i]->first), AtomicString(list[i]->second));
     }
 
     if (m_request->method() != HTTPNames::GET && m_request->method() != HTTPNames::HEAD) {
         if (m_request->buffer())
             request.setHTTPBody(m_request->buffer()->drainAsFormData());
         if (m_request->attachedCredential())
             request.setAttachedCredential(m_request->attachedCredential());
     }
@@ skipping 162 matching lines @@
     loader->dispose();
 }
 
 DEFINE_TRACE(FetchManager)
 {
     visitor->trace(m_loaders);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink