[Fetch] Body consume function should not set bodyUsed flag.

Source/modules/fetch/Body.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 "config.h"
 #include "modules/fetch/Body.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 92 matching lines @@
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_body);
         visitor->trace(m_bodyStreamBuffer);
         visitor->trace(m_drainingStreamBuffer);
         visitor->trace(m_stream);
         BodyStreamBuffer::Observer::trace(visitor);
         UnderlyingSource::trace(visitor);
     }
 
+    void close()
+    {
+        if (m_state == Closed) {
+            // It is possible to call |close| from the source side (such
+            // as blob loading finish) and from the consumer side (such as
+            // calling |cancel|). Thus we should ignore it here.
+            return;
+        }
+        m_state = Closed;
+        if (m_drainingStreamBuffer)
+            m_drainingStreamBuffer->close();
+        m_stream->close();
+    }
+    void error()
+    {
+        m_state = Errored;
+        if (m_drainingStreamBuffer)
+            m_drainingStreamBuffer->error(exception());
+        m_stream->error(exception());
+    }
+
 private:
     class Canceller : public BodyStreamBuffer::Canceller {
     public:
         Canceller(ReadableStreamSource* source) : m_source(source) { }
         void cancel() override
         {
             m_source->cancel();
         }
 
         DEFINE_INLINE_VIRTUAL_TRACE()
@@ skipping 77 matching lines @@
 
     void write(PassRefPtr<DOMArrayBuffer> buf)
     {
         if (m_drainingStreamBuffer) {
             m_drainingStreamBuffer->write(buf);
         } else {
             auto size = buf->byteLength();
             m_stream->enqueue(DOMUint8Array::create(buf, 0, size));
         }
     }
-    void close()
-    {
-        m_state = Closed;
-        if (m_drainingStreamBuffer)
-            m_drainingStreamBuffer->close();
-        m_stream->close();
-    }
-    void error()
-    {
-        m_state = Errored;
-        if (m_drainingStreamBuffer)
-            m_drainingStreamBuffer->error(exception());
-        m_stream->error(exception());
-    }
     void cancel()
     {
         if (m_bodyStreamBuffer) {
             m_bodyStreamBuffer->cancel();
             // We should not close the stream here, because it is canceller's
             // responsibility.
         } else {
             if (m_loader)
                 m_loader->cancel();
             close();
@@ skipping 32 matching lines @@
     // When the main thread sends a V8::TerminateExecution() signal to a worker
     // thread, any V8 API on the worker thread starts returning an empty
     // handle. This can happen in Body::readAsync. To avoid the situation, we
     // first check the ExecutionContext and return immediately if it's already
     // gone (which means that the V8::TerminateExecution() signal has been sent
     // to this worker thread).
     ExecutionContext* executionContext = scriptState->executionContext();
     if (!executionContext)
         return ScriptPromise();
 
-    lockBody(PassBody);
+    lockBody();
     m_responseType = type;
 
     ASSERT(!m_resolver);
     m_resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = m_resolver->promise();
 
-    if (streamAccessed()) {
+    if (m_stream->stateInternal() == ReadableStream::Closed) {
+        // We resolve the resolver manually in order not to use member
+        // variables.
+        switch (m_responseType) {
+        case ResponseAsArrayBuffer:
+            m_resolver->resolve(DOMArrayBuffer::create(nullptr, 0));
+            break;
+        case ResponseAsBlob: {
+            OwnPtr<BlobData> blobData = BlobData::create();
+            blobData->setContentType(mimeType());
+            m_resolver->resolve(Blob::create(BlobDataHandle::create(blobData.release(), 0)));
+            break;
+        }
+        case ResponseAsText:
+            m_resolver->resolve(String());
+            break;
+        case ResponseAsFormData:
+            // TODO(yhirano): Implement this.
+            ASSERT_NOT_REACHED();
+            break;
+        case ResponseAsJSON: {
+            ScriptState::Scope scope(m_resolver->scriptState());
+            m_resolver->reject(V8ThrowException::createSyntaxError(m_resolver->scriptState()->isolate(), "Unexpected end of input"));
+            break;
+        }
+        case ResponseUnknown:
+            ASSERT_NOT_REACHED();
+            break;
+        }
+        m_resolver.clear();
+    } else if (m_stream->stateInternal() == ReadableStream::Errored) {
+        m_resolver->reject(m_stream->storedException());
+        m_resolver.clear();
+    } else if (isBodyConsumed()) {
         m_streamSource->createDrainingStream()->readAllAndCreateBlobHandle(mimeType(), new BlobHandleReceiver(this));
     } else if (buffer()) {
         buffer()->readAllAndCreateBlobHandle(mimeType(), new BlobHandleReceiver(this));
     } else {
         readAsyncFromBlob(blobDataHandle());
     }
     return promise;
 }
 
 void Body::readAsyncFromBlob(PassRefPtr<BlobDataHandle> handle)
@@ skipping 83 matching lines @@
 {
     ASSERT(!bodyUsed());
     if (option == PassBody)
         m_bodyUsed = true;
     ASSERT(!m_stream->isLocked());
     TrackExceptionState exceptionState;
     m_stream->getBytesReader(executionContext(), exceptionState);
     ASSERT(!exceptionState.hadException());
 }
 
-bool Body::streamAccessed() const
+bool Body::isBodyConsumed() const
 {
-    return m_streamSource->state() != m_streamSource->Initial;
+    if (m_streamSource->state() != m_streamSource->Initial) {
+        // Some data is pulled from the source.
+        return true;
+    }
+    if (m_stream->stateInternal() == ReadableStream::Closed) {
+        // Return true if the blob handle is originally not empty.
+        RefPtr<BlobDataHandle> handle = blobDataHandle();
+        return handle && handle->size();
+    }
+    if (m_stream->stateInternal() == ReadableStream::Errored) {
+        // The stream is errored. That means an effort to read data was made.
+        return true;
+    }
+    return false;
 }
 
 void Body::refreshBody()
 {
     m_streamSource = new ReadableStreamSource(this);
     m_stream = new ReadableByteStream(m_streamSource, new ReadableByteStream::StrictStrategy);
     m_streamSource->startStream(m_stream);
 }
 
 BodyStreamBuffer* Body::createDrainingStream()
@@ skipping 78 matching lines @@
         break;
     case ResponseAsJSON:
         resolveJSON(m_loader->stringResult());
         break;
     case ResponseAsText:
         m_resolver->resolve(m_loader->stringResult());
         break;
     default:
         ASSERT_NOT_REACHED();
     }
-    m_stream->close();
+    m_streamSource->close();
     m_resolver.clear();
 }
 
 void Body::didFail(FileError::ErrorCode code)
 {
     if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
         return;
 
-    m_stream->error(DOMException::create(NetworkError, "network error"));
+    m_streamSource->error();
     if (m_resolver) {
         // FIXME: We should reject the promise.
         m_resolver->resolve("");
         m_resolver.clear();
     }
 }
 
 void Body::didBlobHandleReceiveError(PassRefPtrWillBeRawPtr<DOMException> exception)
 {
     if (!m_resolver)
         return;
-    m_stream->error(DOMException::create(NetworkError, "network error"));
+    m_streamSource->error();
     m_resolver->reject(exception);
     m_resolver.clear();
 }
 
 } // namespace blink