Introduce url_list to the Response scheme of CacheStorage.

third_party/WebKit/Source/modules/fetch/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 "modules/fetch/Response.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/BytesConsumer.h"
 #include "modules/fetch/BytesConsumerTestUtil.h"
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "modules/fetch/FetchResponseData.h"
 #include "platform/blob/BlobData.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
+#include "wtf/Vector.h"
 #include <memory>
 
 namespace blink {
 namespace {
 
 std::unique_ptr<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}};
-
+  std::vector<WebURL> urlList;

[nhiroki, 2016/12/07 02:05:57]

WTF::Vector

[horo, 2016/12/07 03:37:48]

Done.

+  urlList.push_back(url);
   std::unique_ptr<WebServiceWorkerResponse> webResponse =
       makeUnique<WebServiceWorkerResponse>();
-  webResponse->setURL(url);
+  webResponse->setURLList(urlList);
   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;
 }
 
 TEST(ServiceWorkerResponseTest, FromFetchResponseData) {
   std::unique_ptr<DummyPageHolder> page =
       DummyPageHolder::create(IntSize(1, 1));
   const KURL url(ParsedURLString, "http://www.response.com");
 
   FetchResponseData* fetchResponseData = FetchResponseData::create();
-  fetchResponseData->setURL(url);
-
+  Vector<KURL> urlList;

[nhiroki, 2016/12/07 02:05:57]

Can you add WTF:: prefix here and elsewhere?

Context:
https://groups.google.com/a/chromium.org/forum/#!topic/platform-architecture-...

[horo, 2016/12/07 03:37:48]

I think the discussion is not settled yet?

[nhiroki, 2016/12/07 04:16:07]

IMO, at least new code should have the prefix because it doesn't pollute
git-blame and it can automatically be replaced with the new prefix "wtf::" by
scripts. Anyway, the discussion is not settled yet and I'll leave it up to you.

+  urlList.append(url);
+  fetchResponseData->setURLList(urlList);
   Response* response = Response::create(&page->document(), fetchResponseData);
   ASSERT(response);
   EXPECT_EQ(url, response->url());
 }
 
 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponse) {
   V8TestingScope scope;
   std::unique_ptr<WebServiceWorkerResponse> webResponse =
       createTestWebServiceWorkerResponse();
   Response* response = Response::create(scope.getScriptState(), *webResponse);
   ASSERT(response);
-  EXPECT_EQ(webResponse->url(), response->url());
+  ASSERT_EQ(1u, webResponse->urlList().size());
+  EXPECT_EQ(webResponse->urlList()[0], 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];
@@ skipping 134 matching lines @@
   src->add(Command(Command::Data, "world"));
   src->add(Command(Command::Done));
   return new BodyStreamBuffer(scriptState, src);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
-  fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+  Vector<KURL> urlList;
+  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  fetchResponseData->setURLList(urlList);
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, true);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
-  fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+  Vector<KURL> urlList;
+  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  fetchResponseData->setURLList(urlList);
   fetchResponseData = fetchResponseData->createBasicFilteredResponse();
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, true);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
-  fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+  Vector<KURL> urlList;
+  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  fetchResponseData->setURLList(urlList);
   fetchResponseData = fetchResponseData->createCORSFilteredResponse();
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, true);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState());
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
-  fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+  Vector<KURL> urlList;
+  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  fetchResponseData->setURLList(urlList);
   fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   EXPECT_EQ(response->internalBodyBuffer(), buffer);
   checkResponseStream(scope.getScriptState(), response, false);
 }
 
 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneError) {
   V8TestingScope scope;
   BodyStreamBuffer* buffer = new BodyStreamBuffer(
       scope.getScriptState(),
       BytesConsumer::createErrored(BytesConsumer::Error()));
   FetchResponseData* fetchResponseData =
       FetchResponseData::createWithBuffer(buffer);
-  fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
+  Vector<KURL> urlList;
+  urlList.append(KURL(ParsedURLString, "http://www.response.com"));
+  fetchResponseData->setURLList(urlList);
   Response* response =
       Response::create(scope.getExecutionContext(), fetchResponseData);
   DummyExceptionStateForTesting exceptionState;
   Response* clonedResponse =
       response->clone(scope.getScriptState(), exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
 
   BytesConsumerTestUtil::MockFetchDataLoaderClient* client1 =
       new BytesConsumerTestUtil::MockFetchDataLoaderClient();
   BytesConsumerTestUtil::MockFetchDataLoaderClient* client2 =
       new BytesConsumerTestUtil::MockFetchDataLoaderClient();
   EXPECT_CALL(*client1, didFetchDataLoadFailed());
   EXPECT_CALL(*client2, didFetchDataLoadFailed());
 
   response->internalBodyBuffer()->startLoading(
       FetchDataLoader::createLoaderAsString(), client1);
   clonedResponse->internalBodyBuffer()->startLoading(
       FetchDataLoader::createLoaderAsString(), client2);
   blink::testing::runPendingTasks();
 }
 
 }  // namespace
 }  // namespace blink