Make WebServiceWorkerResponse support ResponseType

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/Response.h"
 #include "modules/serviceworkers/FetchResponseData.h"
 #include "public/platform/WebServiceWorkerResponse.h"
 #include <gtest/gtest.h>
 
 namespace blink {
 namespace {
 
+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 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)
 {
-    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[] = { {"X-Foo", "bar"}, {"X-Quux", "foop"}, {0, 0} };
-
-    WebServiceWorkerResponse webResponse;
-    webResponse.setURL(url);
-    webResponse.setStatus(status);
-    webResponse.setStatusText(statusText);
-    for (int i = 0; headers[i].key; ++i)
-        webResponse.setHeader(WebString::fromUTF8(headers[i].key), WebString::fromUTF8(headers[i].value));
-
-    Response* response = Response::create(executionContext(), webResponse);
+    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
+    Response* response = Response::create(executionContext(), *webResponse);
     ASSERT(response);
-    EXPECT_EQ(url, response->url());
-    EXPECT_EQ(status, response->status());
-    EXPECT_EQ(statusText, response->statusText());
+    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();
 
-    WTF::HashMap<String, String> headersMap;
-    for (int i = 0; headers[i].key; ++i)
-        headersMap.add(headers[i].key, headers[i].value);
-    EXPECT_EQ(headersMap.size(), responseHeaders->headerList()->size());
-    for (WTF::HashMap<String, String>::iterator iter = headersMap.begin(); iter != headersMap.end(); ++iter) {
+    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_EQ(iter->value, responseHeaders->get(iter->key, 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());
+}
+
 } // namespace
 } // namespace blink