[ServiceWorker] Use BodyStreamBuffer as the body data of the Response object.

Source/modules/serviceworkers/Response.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 "Response.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 155 matching lines @@
 }
 
 Response* Response::create(ExecutionContext* context, const WebServiceWorkerResponse& webResponse)
 {
     FetchResponseData* responseData = createFetchResponseDataFromWebResponse(webResponse);
     Response* r = new Response(context, responseData);
     r->suspendIfNeeded();
     return r;
 }
 
-Response* Response::create(const Response& copyFrom)
+Response* Response::createClone(const Response& cloneFrom)
 {
-    Response* r = new Response(copyFrom);
+    Response* r = new Response(cloneFrom);
     r->suspendIfNeeded();
     return r;
 }
 
 String Response::type() const
 {
     // "The type attribute's getter must return response's type."
     switch (m_response->type()) {
     case FetchResponseData::BasicType:
         return "basic";
@@ skipping 39 matching lines @@
     // "The headers attribute's getter must return the associated Headers object."
     return m_headers;
 }
 
 Response* Response::clone(ExceptionState& exceptionState) const
 {
     if (bodyUsed()) {
         exceptionState.throwTypeError("Response body is already used");
         return nullptr;
     }
-    return Response::create(*this);
+    if (streamAccessed()) {
+        // FIXME: Support clone() of the stream accessed Response.
+        exceptionState.throwTypeError("clone() of the Response which .body is accessed is not supported.");
+        return nullptr;
+    }
+    return Response::createClone(*this);
 }
 
 void Response::populateWebServiceWorkerResponse(WebServiceWorkerResponse& response)
 {
     m_response->populateWebServiceWorkerResponse(response);
 }
 
 Response::Response(ExecutionContext* context)
     : Body(context)
     , m_response(FetchResponseData::create())
     , m_headers(Headers::create(m_response->headerList()))
 {
     m_headers->setGuard(Headers::ResponseGuard);
 }
 
-Response::Response(const Response& copy_from)
-    : Body(copy_from)
-    , m_response(copy_from.m_response)
-    , m_headers(copy_from.m_headers->createCopy())
+Response::Response(const Response& clone_from)
+    : Body(clone_from)
+    , m_response(clone_from.m_response->clone())
+    , m_headers(Headers::create(m_response->headerList()))
 {
 }
 
 Response::Response(ExecutionContext* context, FetchResponseData* response)
     : Body(context)
     , m_response(response)
     , m_headers(Headers::create(m_response->headerList()))
 {
     m_headers->setGuard(Headers::ResponseGuard);
 }
 
+bool Response::hasBody() const
+{
+    return internalBlobDataHandle() || internalBuffer();
+}
 
-PassRefPtr<BlobDataHandle> Response::blobDataHandle()
+PassRefPtr<BlobDataHandle> Response::blobDataHandle() const
 {
     return m_response->blobDataHandle();
 }
 
+BodyStreamBuffer* Response::buffer() const
+{
+    return m_response->buffer();
+}
+
+String Response::contentType() const
+{
+    return m_response->contentType();
+}
+
+PassRefPtr<BlobDataHandle> Response::internalBlobDataHandle() const
+{
+    return m_response->internalBlobDataHandle();
+}
+
+BodyStreamBuffer* Response::internalBuffer() const
+{
+    return m_response->internalBuffer();
+}
+
+String Response::internalContentType() const
+{
+    return m_response->internalContentType();
+}
+
 void Response::trace(Visitor* visitor)
 {
     Body::trace(visitor);
     visitor->trace(m_response);
     visitor->trace(m_headers);
 }
 
 } // namespace blink