| Index: Source/modules/serviceworkers/ResponseTest.cpp | 
| diff --git a/Source/modules/serviceworkers/ResponseTest.cpp b/Source/modules/serviceworkers/ResponseTest.cpp | 
| deleted file mode 100644 | 
| index 66a113659f9de8078c2e7e2a9f6eb4d0869f5f09..0000000000000000000000000000000000000000 | 
| --- a/Source/modules/serviceworkers/ResponseTest.cpp | 
| +++ /dev/null | 
| @@ -1,375 +0,0 @@ | 
| -// 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 BlobHandleCreatorClient final : public BodyStreamBuffer::BlobHandleCreatorClient { | 
| -public: | 
| -    BlobHandleCreatorClient() | 
| -    { | 
| -    } | 
| -    ~BlobHandleCreatorClient() 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; | 
| -}; | 
| - | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, FromFetchResponseData) | 
| -{ | 
| -    const KURL url(ParsedURLString, "http://www.response.com"); | 
| - | 
| -    FetchResponseData* fetchResponseData = FetchResponseData::create(); | 
| -    fetchResponseData->setURL(url); | 
| - | 
| -    Response* response = Response::create(executionContext(), fetchResponseData); | 
| -    ASSERT(response); | 
| -    EXPECT_EQ(url, response->url()); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponse) | 
| -{ | 
| -    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse(); | 
| -    Response* response = Response::create(executionContext(), *webResponse); | 
| -    ASSERT(response); | 
| -    EXPECT_EQ(webResponse->url(), response->url()); | 
| -    EXPECT_EQ(webResponse->status(), response->status()); | 
| -    EXPECT_STREQ(webResponse->statusText().utf8().c_str(), response->statusText().utf8().data()); | 
| - | 
| -    Headers* responseHeaders = response->headers(); | 
| - | 
| -    WebVector<WebString> keys = webResponse->getHeaderKeys(); | 
| -    EXPECT_EQ(keys.size(), responseHeaders->headerList()->size()); | 
| -    for (size_t i = 0, max = keys.size(); i < max; ++i) { | 
| -        WebString key = keys[i]; | 
| -        TrackExceptionState exceptionState; | 
| -        EXPECT_STREQ(webResponse->getHeader(key).utf8().c_str(), responseHeaders->get(key, exceptionState).utf8().data()); | 
| -        EXPECT_FALSE(exceptionState.hadException()); | 
| -    } | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseDefault) | 
| -{ | 
| -    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse(); | 
| -    webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); | 
| -    Response* response = Response::create(executionContext(), *webResponse); | 
| - | 
| -    Headers* responseHeaders = response->headers(); | 
| -    TrackExceptionState exceptionState; | 
| -    EXPECT_STREQ("foop", responseHeaders->get("set-cookie", exceptionState).utf8().data()); | 
| -    EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data()); | 
| -    EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionState).utf8().data()); | 
| -    EXPECT_FALSE(exceptionState.hadException()); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseBasic) | 
| -{ | 
| -    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse(); | 
| -    webResponse->setResponseType(WebServiceWorkerResponseTypeBasic); | 
| -    Response* response = Response::create(executionContext(), *webResponse); | 
| - | 
| -    Headers* responseHeaders = response->headers(); | 
| -    TrackExceptionState exceptionState; | 
| -    EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().data()); | 
| -    EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data()); | 
| -    EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionState).utf8().data()); | 
| -    EXPECT_FALSE(exceptionState.hadException()); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseCORS) | 
| -{ | 
| -    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse(); | 
| -    webResponse->setResponseType(WebServiceWorkerResponseTypeCORS); | 
| -    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("no-cache", responseHeaders->get("cache-control", exceptionState).utf8().data()); | 
| -    EXPECT_FALSE(exceptionState.hadException()); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseOpaque) | 
| -{ | 
| -    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse(); | 
| -    webResponse->setResponseType(WebServiceWorkerResponseTypeOpaque); | 
| -    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, bool checkResponseBodyStreamBuffer) | 
| -{ | 
| -    BodyStreamBuffer* buffer = response->internalBuffer(); | 
| -    EXPECT_FALSE(response->internalBlobDataHandle()); | 
| -    EXPECT_FALSE(response->blobDataHandle()); | 
| -    if (checkResponseBodyStreamBuffer) { | 
| -        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 (checkResponseBodyStreamBuffer) { | 
| -        EXPECT_EQ(response->buffer(), response->internalBuffer()); | 
| -        EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer()); | 
| -    } else { | 
| -        EXPECT_FALSE(response->buffer()); | 
| -        EXPECT_FALSE(clonedResponse->buffer()); | 
| -    } | 
| -    BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient(); | 
| -    BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient(); | 
| -    EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response->internalContentTypeForBuffer(), client1)); | 
| -    EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clonedResponse->internalContentTypeForBuffer(), client2)); | 
| -    buffer->write(DOMArrayBuffer::create("foobar", 6)); | 
| -    buffer->write(DOMArrayBuffer::create("piyo", 4)); | 
| -    EXPECT_FALSE(client1->blobHandle()); | 
| -    EXPECT_FALSE(client2->blobHandle()); | 
| -    buffer->close(); | 
| -    EXPECT_TRUE(client1->blobHandle()); | 
| -    EXPECT_TRUE(client2->blobHandle()); | 
| -    EXPECT_EQ(10u, client1->blobHandle()->size()); | 
| -    EXPECT_EQ(10u, client2->blobHandle()->size()); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) | 
| -{ | 
| -    BodyStreamBuffer* buffer = new BodyStreamBuffer(); | 
| -    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer); | 
| -    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 
| -    Response* response = Response::create(executionContext(), fetchResponseData); | 
| -    EXPECT_EQ(response->internalBuffer(), buffer); | 
| -    checkResponseStream(response, true); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) | 
| -{ | 
| -    BodyStreamBuffer* buffer = new BodyStreamBuffer(); | 
| -    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer); | 
| -    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 
| -    fetchResponseData = fetchResponseData->createBasicFilteredResponse(); | 
| -    Response* response = Response::create(executionContext(), fetchResponseData); | 
| -    EXPECT_EQ(response->internalBuffer(), buffer); | 
| -    checkResponseStream(response, true); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) | 
| -{ | 
| -    BodyStreamBuffer* buffer = new BodyStreamBuffer(); | 
| -    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer); | 
| -    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 
| -    fetchResponseData = fetchResponseData->createCORSFilteredResponse(); | 
| -    Response* response = Response::create(executionContext(), fetchResponseData); | 
| -    EXPECT_EQ(response->internalBuffer(), buffer); | 
| -    checkResponseStream(response, true); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) | 
| -{ | 
| -    BodyStreamBuffer* buffer = new BodyStreamBuffer(); | 
| -    FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer); | 
| -    fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 
| -    fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); | 
| -    Response* response = Response::create(executionContext(), fetchResponseData); | 
| -    EXPECT_EQ(response->internalBuffer(), buffer); | 
| -    checkResponseStream(response, false); | 
| -} | 
| - | 
| -TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneError) | 
| -{ | 
| -    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()); | 
| -    BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient(); | 
| -    BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient(); | 
| -    EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response->internalContentTypeForBuffer(), client1)); | 
| -    EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clonedResponse->internalContentTypeForBuffer(), client2)); | 
| -    buffer->write(DOMArrayBuffer::create("foobar", 6)); | 
| -    buffer->write(DOMArrayBuffer::create("piyo", 4)); | 
| -    EXPECT_FALSE(client1->blobHandle()); | 
| -    EXPECT_FALSE(client2->blobHandle()); | 
| -    buffer->error(DOMException::create(NetworkError, "Error Message")); | 
| -    EXPECT_EQ("NetworkError", client1->exception()->name()); | 
| -    EXPECT_EQ("Error Message", client1->exception()->message()); | 
| -    EXPECT_EQ("NetworkError", client2->exception()->name()); | 
| -    EXPECT_EQ("Error Message", client2->exception()->message()); | 
| -} | 
| - | 
| -} // namespace | 
| -} // namespace blink | 
|  |