[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 255 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()) {
-        m_streamSource->createDrainingStream()->readAllAndCreateBlobHandle(mimeType(), new BlobHandleReceiver(this));
-    } else if (buffer()) {
-        buffer()->readAllAndCreateBlobHandle(mimeType(), new BlobHandleReceiver(this));
+    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 {

[horo, 2015/04/01 12:04:54]

nit: Why don't you continue using "else if"?

[yhirano, 2015/04/01 12:11:55]

Done.

-        readAsyncFromBlob(blobDataHandle());
+        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)
 {
     FileReaderLoader::ReadType readType = FileReaderLoader::ReadAsText;
     RefPtr<BlobDataHandle> blobHandle = handle;
     if (!blobHandle)
         blobHandle = BlobDataHandle::create(BlobData::create(), 0);
@@ skipping 78 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 105 matching lines @@
 void Body::didBlobHandleReceiveError(PassRefPtrWillBeRawPtr<DOMException> exception)
 {
     if (!m_resolver)
         return;
     m_stream->error(DOMException::create(NetworkError, "network error"));
     m_resolver->reject(exception);
     m_resolver.clear();
 }
 
 } // namespace blink