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

Source/modules/serviceworkers/ResponseTest.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/serviceworkers/Response.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/testing/DummyPageHolder.h"
+#include "modules/serviceworkers/BodyStreamBuffer.h"
 #include "modules/serviceworkers/FetchResponseData.h"
+#include "platform/blob/BlobData.h"
 #include "public/platform/WebServiceWorkerResponse.h"
 #include <gtest/gtest.h>
 
 namespace blink {
 namespace {
 
+const char kTestData[] = "Here is sample text for the blob.";
+
 PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse()
 {
     const KURL url(ParsedURLString, "http://www.webresponse.com/");
     const unsigned short status = 200;
     const String statusText = "the best status text";
     struct {
         const char* key;
         const char* value;
     } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, { "foo", "bar" }, { 0, 0 } };
 
     OwnPtr<WebServiceWorkerResponse> webResponse = adoptPtr(new WebServiceWorkerResponse());
     webResponse->setURL(url);
     webResponse->setStatus(status);
     webResponse->setStatusText(statusText);
     webResponse->setResponseType(WebServiceWorkerResponseTypeDefault);
     for (int i = 0; headers[i].key; ++i)
         webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::fromUTF8(headers[i].value));
     return webResponse.release();
 }
 
+class BlobHandleCallback final : public BodyStreamBuffer::BlobHandleCreatorClient {

[yhirano, 2014/12/12 12:42:33]

How about BlobHandleCreatorClient?

[horo, 2014/12/15 02:12:24]

Done.

+public:
+    BlobHandleCallback()
+    {
+    }
+    ~BlobHandleCallback() override { }
+    void trace(Visitor* visitor) override
+    {
+        visitor->trace(m_exception);
+        BodyStreamBuffer::BlobHandleCreatorClient::trace(visitor);
+    }
+    void didCreateBlobHandle(PassRefPtr<BlobDataHandle> blobHandle) override
+    {
+        m_blobHandle = blobHandle;
+    }
+    void didFail(PassRefPtrWillBeRawPtr<DOMException> exception) override
+    {
+        m_exception = exception;
+    }
+    PassRefPtr<BlobDataHandle> blobHandle()
+    {
+        return m_blobHandle;
+    }
+    PassRefPtrWillBeRawPtr<DOMException> exception()
+    {
+        return m_exception;
+    }
+
+private:
+    RefPtr<BlobDataHandle> m_blobHandle;
+    RefPtrWillBeMember<DOMException> m_exception;
+};
+
+
 class ServiceWorkerResponseTest : public ::testing::Test {
 public:
     ServiceWorkerResponseTest()
         : m_page(DummyPageHolder::create(IntSize(1, 1))) { }
 
     ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     ExecutionContext* executionContext() { return scriptState()->executionContext(); }
 
 private:
     OwnPtr<DummyPageHolder> m_page;
@@ skipping 82 matching lines @@
     Response* response = Response::create(executionContext(), *webResponse);
 
     Headers* responseHeaders = response->headers();
     TrackExceptionState exceptionState;
     EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8().data());
     EXPECT_FALSE(exceptionState.hadException());
 }
 
+void checkResponseBlobHandle(Response* response, bool hasNonInternalBlobHandle, const unsigned long long blobSize)
+{
+    EXPECT_TRUE(response->internalBlobDataHandle());
+    EXPECT_EQ(blobSize, response->internalBlobDataHandle()->size());
+    EXPECT_FALSE(response->internalBuffer());
+    if (hasNonInternalBlobHandle) {
+        EXPECT_TRUE(response->blobDataHandle());
+        EXPECT_EQ(response->blobDataHandle(), response->internalBlobDataHandle());
+        EXPECT_EQ(blobSize, response->blobDataHandle()->size());
+    } else {
+        EXPECT_FALSE(response->blobDataHandle());
+    }
+    EXPECT_FALSE(response->buffer());
+
+    TrackExceptionState exceptionState;
+    Response* clonedResponse = response->clone(exceptionState);
+    EXPECT_FALSE(exceptionState.hadException());
+
+    EXPECT_TRUE(response->internalBlobDataHandle());
+    EXPECT_EQ(blobSize, clonedResponse->internalBlobDataHandle()->size());
+    EXPECT_EQ(response->internalBlobDataHandle(), clonedResponse->internalBlobDataHandle());
+    EXPECT_FALSE(response->internalBuffer());
+    EXPECT_FALSE(clonedResponse->internalBuffer());
+    if (hasNonInternalBlobHandle) {
+        EXPECT_EQ(response->internalBlobDataHandle(), response->blobDataHandle());
+        EXPECT_EQ(clonedResponse->internalBlobDataHandle(), clonedResponse->blobDataHandle());
+    } else {
+        EXPECT_FALSE(response->blobDataHandle());
+        EXPECT_FALSE(clonedResponse->blobDataHandle());
+    }
+    EXPECT_FALSE(response->buffer());
+    EXPECT_FALSE(clonedResponse->buffer());
+}
+
+TEST_F(ServiceWorkerResponseTest, BlobHandleCloneDefault)
+{
+    FetchResponseData* fetchResponseData = FetchResponseData::create();
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    OwnPtr<BlobData> blobData(BlobData::create());
+    blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
+    const unsigned long long size = blobData->length();
+    fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release(), size));
+    checkResponseBlobHandle(Response::create(executionContext(), fetchResponseData), true, size);
+}
+
+TEST_F(ServiceWorkerResponseTest, BlobHandleCloneBasic)
+{
+    FetchResponseData* fetchResponseData = FetchResponseData::create();
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    OwnPtr<BlobData> blobData(BlobData::create());
+    blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
+    const unsigned long long size = blobData->length();
+    fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release(), size));
+    fetchResponseData = fetchResponseData->createBasicFilteredResponse();
+    checkResponseBlobHandle(Response::create(executionContext(), fetchResponseData), true, size);
+}
+
+TEST_F(ServiceWorkerResponseTest, BlobHandleCloneCORS)
+{
+    FetchResponseData* fetchResponseData = FetchResponseData::create();
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    OwnPtr<BlobData> blobData(BlobData::create());
+    blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
+    const unsigned long long size = blobData->length();
+    fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release(), size));
+    fetchResponseData = fetchResponseData->createCORSFilteredResponse();
+    checkResponseBlobHandle(Response::create(executionContext(), fetchResponseData), true, size);
+}
+
+TEST_F(ServiceWorkerResponseTest, BlobHandleCloneOpaque)
+{
+    FetchResponseData* fetchResponseData = FetchResponseData::create();
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    OwnPtr<BlobData> blobData(BlobData::create());
+    blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
+    const unsigned long long size = blobData->length();
+    fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release(), size));
+    fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
+    checkResponseBlobHandle(Response::create(executionContext(), fetchResponseData), false, size);
+}
+
+void checkResponseStream(Response* response, BodyStreamBuffer* buffer, bool hasNonInternalStream)

[yhirano, 2014/12/12 12:42:33]

Do you need to pass buffer? Isn't just using response->internalBuffer() enough?

[yhirano, 2014/12/12 12:42:33]

hasNonInternalBodyStreamBuffer

[yhirano, 2014/12/12 12:42:33]

checkResponseBodyStreamBuffer

[horo, 2014/12/15 02:12:24]

Done.

[horo, 2014/12/15 02:12:24]

We need |buffer| to write the data (l.296) on it and close it (l.300).

[yhirano, 2014/12/15 04:03:06]

Yes, we need the buffer object, but it always equals to
|response->internalBuffer()|, as expected in L265. My suggestion is to stop
passing |buffer| and to use |response->internalBuffer()| instead.

[horo, 2014/12/15 04:26:08]

I see.
Done.

+{
+    EXPECT_FALSE(response->internalBlobDataHandle());
+    EXPECT_FALSE(response->blobDataHandle());
+    EXPECT_EQ(response->internalBuffer(), buffer);
+    if (hasNonInternalStream) {
+        EXPECT_EQ(response->buffer(), buffer);
+    } else {
+        EXPECT_FALSE(response->buffer());
+    }
+
+    TrackExceptionState exceptionState;
+    Response* clonedResponse = response->clone(exceptionState);
+    EXPECT_FALSE(exceptionState.hadException());
+    EXPECT_FALSE(response->internalBlobDataHandle());
+    EXPECT_FALSE(response->blobDataHandle());
+    EXPECT_FALSE(clonedResponse->internalBlobDataHandle());
+    EXPECT_FALSE(clonedResponse->blobDataHandle());
+
+    EXPECT_TRUE(response->internalBuffer());
+    EXPECT_TRUE(clonedResponse->internalBuffer());
+    EXPECT_NE(response->internalBuffer(), buffer);
+    EXPECT_NE(clonedResponse->internalBuffer(), buffer);
+    EXPECT_NE(response->internalBuffer(), clonedResponse->internalBuffer());
+    if (hasNonInternalStream) {
+        EXPECT_EQ(response->buffer(), response->internalBuffer());
+        EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer());
+    } else {
+        EXPECT_FALSE(response->buffer());
+        EXPECT_FALSE(clonedResponse->buffer());
+    }
+    BlobHandleCallback* callback1 = new BlobHandleCallback();
+    BlobHandleCallback* callback2 = new BlobHandleCallback();
+    EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response->internalContentType(), callback1));
+    EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clonedResponse->internalContentType(), callback2));
+    buffer->write(DOMArrayBuffer::create("foobar", 6));
+    buffer->write(DOMArrayBuffer::create("piyo", 4));
+    EXPECT_FALSE(callback1->blobHandle());
+    EXPECT_FALSE(callback2->blobHandle());
+    buffer->close();
+    EXPECT_TRUE(callback1->blobHandle());
+    EXPECT_TRUE(callback2->blobHandle());
+    EXPECT_EQ(10u, callback1->blobHandle()->size());
+    EXPECT_EQ(10u, callback2->blobHandle()->size());
+}
+
+TEST_F(ServiceWorkerResponseTest, StreamCloneDefault)

[yhirano, 2014/12/12 12:42:33]

s/Stream/BodyStreamBuffer/
Same for the below tests.

[horo, 2014/12/15 02:12:24]

Done.

+{
+    BodyStreamBuffer* buffer = new BodyStreamBuffer();
+    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer);
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    checkResponseStream(Response::create(executionContext(), fetchResponseData), buffer, true);
+}
+
+TEST_F(ServiceWorkerResponseTest, StreamCloneBasic)
+{
+    BodyStreamBuffer* buffer = new BodyStreamBuffer();
+    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer);
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    fetchResponseData = fetchResponseData->createBasicFilteredResponse();
+    checkResponseStream(Response::create(executionContext(), fetchResponseData), buffer, true);
+}
+
+TEST_F(ServiceWorkerResponseTest, StreamCloneCORS)
+{
+    BodyStreamBuffer* buffer = new BodyStreamBuffer();
+    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer);
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    fetchResponseData = fetchResponseData->createCORSFilteredResponse();
+    checkResponseStream(Response::create(executionContext(), fetchResponseData), buffer, true);
+}
+
+TEST_F(ServiceWorkerResponseTest, StreamCloneOpaque)
+{
+    BodyStreamBuffer* buffer = new BodyStreamBuffer();
+    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer);
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
+    checkResponseStream(Response::create(executionContext(), fetchResponseData), buffer, false);
+}
+
+TEST_F(ServiceWorkerResponseTest, StreamCloneError)
+{
+    BodyStreamBuffer* buffer = new BodyStreamBuffer();
+    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer);
+    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+    Response* response = Response::create(executionContext(), fetchResponseData);
+    TrackExceptionState exceptionState;
+    Response* clonedResponse = response->clone(exceptionState);
+    EXPECT_FALSE(exceptionState.hadException());
+    BlobHandleCallback* callback1 = new BlobHandleCallback();
+    BlobHandleCallback* callback2 = new BlobHandleCallback();
+    EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response->internalContentType(), callback1));
+    EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clonedResponse->internalContentType(), callback2));
+    buffer->write(DOMArrayBuffer::create("foobar", 6));
+    buffer->write(DOMArrayBuffer::create("piyo", 4));
+    EXPECT_FALSE(callback1->blobHandle());
+    EXPECT_FALSE(callback2->blobHandle());
+    buffer->error(DOMException::create(NetworkError, "Error Message"));
+    EXPECT_EQ("NetworkError", callback1->exception()->name());
+    EXPECT_EQ("Error Message", callback1->exception()->message());
+    EXPECT_EQ("NetworkError", callback2->exception()->name());
+    EXPECT_EQ("Error Message", callback2->exception()->message());
+}
+
 } // namespace
 } // namespace blink