Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/modules/fetch/BodyStreamBuffer.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/BodyStreamBuffer.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/streams/ReadableStreamController.h"
 #include "core/streams/ReadableStreamOperations.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "modules/fetch/Body.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/DataConsumerTee.h"
 #include "modules/fetch/ReadableStreamDataConsumerHandle.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/EncodedFormData.h"
-#include <memory>
 
 namespace blink {
 
 namespace {
 
 bool isTerminating(ScriptState* scriptState)
 {
     ExecutionContext* executionContext = scriptState->getExecutionContext();
     if (!executionContext)
         return true;
@@ skipping 57 matching lines @@
 private:
     void stop() override
     {
         m_buffer->stopLoading();
     }
 
     Member<BodyStreamBuffer> m_buffer;
     Member<FetchDataLoader::Client> m_client;
 };
 
-BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, std::unique_ptr<FetchDataConsumerHandle> handle)
+BodyStreamBuffer::BodyStreamBuffer(ScriptState* scriptState, PassOwnPtr<FetchDataConsumerHandle> handle)
     : UnderlyingSourceBase(scriptState)
     , m_scriptState(scriptState)
     , m_handle(std::move(handle))
     , m_reader(m_handle->obtainReader(this))
     , m_madeFromReadableStream(false)
 {
     if (RuntimeEnabledFeatures::responseBodyWithV8ExtraStreamEnabled()) {
         ScriptState::Scope scope(scriptState);
         if (isTerminating(scriptState)) {
             m_reader = nullptr;
@@ skipping 96 matching lines @@
         closeAndLockAndDisturb();
         return formData.release();
     }
     return nullptr;
 }
 
 void BodyStreamBuffer::startLoading(FetchDataLoader* loader, FetchDataLoader::Client* client)
 {
     ASSERT(!m_loader);
     ASSERT(m_scriptState->contextIsValid());
-    std::unique_ptr<FetchDataConsumerHandle> handle = releaseHandle();
+    OwnPtr<FetchDataConsumerHandle> handle = releaseHandle();
     m_loader = loader;
     loader->start(handle.get(), new LoaderClient(m_scriptState->getExecutionContext(), this, client));
 }
 
 void BodyStreamBuffer::tee(BodyStreamBuffer** branch1, BodyStreamBuffer** branch2)
 {
     DCHECK(!isStreamLocked());
     DCHECK(!isStreamDisturbed());
     *branch1 = nullptr;
     *branch2 = nullptr;
 
     if (m_madeFromReadableStream) {
         ScriptState::Scope scope(m_scriptState.get());
         ScriptValue stream1, stream2;
         ReadableStreamOperations::tee(m_scriptState.get(), stream(), &stream1, &stream2);
         *branch1 = new BodyStreamBuffer(m_scriptState.get(), stream1);
         *branch2 = new BodyStreamBuffer(m_scriptState.get(), stream2);
         return;
     }
-    std::unique_ptr<FetchDataConsumerHandle> handle = releaseHandle();
-    std::unique_ptr<FetchDataConsumerHandle> handle1, handle2;
+    OwnPtr<FetchDataConsumerHandle> handle = releaseHandle();
+    OwnPtr<FetchDataConsumerHandle> handle1, handle2;
     DataConsumerTee::create(m_scriptState->getExecutionContext(), std::move(handle), &handle1, &handle2);
     *branch1 = new BodyStreamBuffer(m_scriptState.get(), std::move(handle1));
     *branch2 = new BodyStreamBuffer(m_scriptState.get(), std::move(handle2));
 }
 
 void BodyStreamBuffer::pullSource()
 {
     ASSERT(!m_streamNeedsMore);
     m_streamNeedsMore = true;
     processData();
@@ skipping 193 matching lines @@
 }
 
 void BodyStreamBuffer::stopLoading()
 {
     if (!m_loader)
         return;
     m_loader->cancel();
     m_loader = nullptr;
 }
 
-std::unique_ptr<FetchDataConsumerHandle> BodyStreamBuffer::releaseHandle()
+PassOwnPtr<FetchDataConsumerHandle> BodyStreamBuffer::releaseHandle()
 {
     DCHECK(!isStreamLocked());
     DCHECK(!isStreamDisturbed());
 
     if (m_madeFromReadableStream) {
         ScriptState::Scope scope(m_scriptState.get());
         // We need to have |reader| alive by some means (as written in
         // ReadableStreamDataConsumerHandle). Based on the following facts
         //  - This function is used only from tee and startLoading.
         //  - This branch cannot be taken when called from tee.
         //  - startLoading makes hasPendingActivity return true while loading.
         // , we don't need to keep the reader explicitly.
         NonThrowableExceptionState exceptionState;
         ScriptValue reader = ReadableStreamOperations::getReader(m_scriptState.get(), stream(), exceptionState);
         return ReadableStreamDataConsumerHandle::create(m_scriptState.get(), reader);
     }
     // We need to call these before calling closeAndLockAndDisturb.
     const bool isClosed = isStreamClosed();
     const bool isErrored = isStreamErrored();
-    std::unique_ptr<FetchDataConsumerHandle> handle = std::move(m_handle);
+    OwnPtr<FetchDataConsumerHandle> handle = std::move(m_handle);
 
     closeAndLockAndDisturb();
 
     if (isClosed) {
         // Note that the stream cannot be "draining", because it doesn't have
         // the internal buffer.
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
     }
     if (isErrored)
         return createFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle());
 
     DCHECK(handle);
     return handle;
 }
 
 } // namespace blink