[Fetch] Response.clone should tee the body stream.

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();
 
-    setBodyUsed();
+    lockBody(PassBody);
     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));
@@ skipping 79 matching lines @@
 {
     UseCounter::count(executionContext(), UseCounter::FetchBodyStream);
     return m_stream;
 }
 
 bool Body::bodyUsed() const
 {
     return m_bodyUsed || m_stream->isLocked();
 }
 
-void Body::setBodyUsed()
+void Body::lockBody(LockBodyOption option)
 {
-    ASSERT(!m_bodyUsed);
+    ASSERT(!bodyUsed());
+    if (option == PassBody)
+        m_bodyUsed = true;
     ASSERT(!m_stream->isLocked());
     TrackExceptionState exceptionState;
-    m_streamReader = m_stream->getBytesReader(executionContext(), exceptionState);
+    m_stream->getBytesReader(executionContext(), exceptionState);
     ASSERT(!exceptionState.hadException());
-    m_bodyUsed = true;
 }
 
 bool Body::streamAccessed() const
 {
     return m_streamSource->state() != m_streamSource->Initial;
 }
 
+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()
 {
     return m_streamSource->createDrainingStream();
 }
 
 void Body::stop()
 {
     // Canceling the load will call didFail which will remove the resolver.
     if (m_loader)
         m_loader->cancel();
 }
 
 bool Body::hasPendingActivity() const
 {
     if (executionContext()->activeDOMObjectsAreStopped())
         return false;
     if (m_resolver)
         return true;
     if (m_stream->isLocked())
         return true;
     return false;
 }
 
 DEFINE_TRACE(Body)
 {
     visitor->trace(m_resolver);
     visitor->trace(m_stream);
     visitor->trace(m_streamSource);
-    visitor->trace(m_streamReader);
     ActiveDOMObject::trace(visitor);
 }
 
 Body::Body(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_bodyUsed(false)
     , m_responseType(ResponseType::ResponseUnknown)
     , m_streamSource(new ReadableStreamSource(this))
     , m_stream(new ReadableByteStream(m_streamSource, new ReadableByteStream::StrictStrategy))
 {
@@ skipping 68 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