Introduce url_list to the Response scheme of CacheStorage.

third_party/WebKit/Source/modules/cachestorage/CacheTest.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/cachestorage/Cache.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 176 matching lines @@
         *m_expectedBatchOperations;
     EXPECT_EQ(expectedBatchOperations.size(), batchOperations.size());
     for (int i = 0, minsize = std::min(expectedBatchOperations.size(),
                                        batchOperations.size());
          i < minsize; ++i) {
       EXPECT_EQ(expectedBatchOperations[i].operationType,
                 batchOperations[i].operationType);
       const String expectedRequestUrl =
           KURL(expectedBatchOperations[i].request.url());
       EXPECT_EQ(expectedRequestUrl, KURL(batchOperations[i].request.url()));
-      const String expectedResponseUrl =
-          KURL(expectedBatchOperations[i].response.url());
-      EXPECT_EQ(expectedResponseUrl, KURL(batchOperations[i].response.url()));
+      EXPECT_EQ(expectedBatchOperations[i].response.urlList().size(),
+                batchOperations[i].response.urlList().size());
+      for (size_t j = 0;
+           j < expectedBatchOperations[i].response.urlList().size(); ++j) {
+        EXPECT_EQ(expectedBatchOperations[i].response.urlList()[j],
+                  batchOperations[i].response.urlList()[j]);
+      }
       CompareQueryParamsForTest(expectedBatchOperations[i].matchParams,
                                 batchOperations[i].matchParams);
     }
   }
 
  private:
   static void CompareQueryParamsForTest(const QueryParams& expectedQueryParams,
                                         const QueryParams& queryParams) {
     EXPECT_EQ(expectedQueryParams.ignoreSearch, queryParams.ignoreSearch);
     EXPECT_EQ(expectedQueryParams.ignoreMethod, queryParams.ignoreMethod);
@@ skipping 250 matching lines @@
   testCache->setExpectedQueryParams(&expectedQueryParams);
 
   CacheQueryOptions options;
   options.setCacheName(expectedQueryParams.cacheName);
 
   const String url = "http://batch.operations.test/";
   Request* request = newRequestFromUrl(url);
   ASSERT(request);
 
   WebServiceWorkerResponse webResponse;
-  webResponse.setURL(KURL(ParsedURLString, url));
+  std::vector<KURL> urlList;
+  urlList.push_back(KURL(ParsedURLString, url));
+  webResponse.setURLList(urlList);
   Response* response = Response::create(getScriptState(), webResponse);
 
   WebVector<WebServiceWorkerCache::BatchOperation> expectedDeleteOperations(
       size_t(1));
   {
     WebServiceWorkerCache::BatchOperation deleteOperation;
     deleteOperation.operationType = WebServiceWorkerCache::OperationTypeDelete;
     request->populateWebServiceWorkerRequest(deleteOperation.request);
     deleteOperation.matchParams = expectedQueryParams;
     expectedDeleteOperations[0] = deleteOperation;
@@ skipping 57 matching lines @@
 };
 
 TEST_F(CacheStorageTest, MatchResponseTest) {
   ScriptState::Scope scope(getScriptState());
   NonThrowableExceptionState exceptionState;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::create();
   const String requestUrl = "http://request.url/";
   const String responseUrl = "http://match.response.test/";
 
   WebServiceWorkerResponse webResponse;
-  webResponse.setURL(KURL(ParsedURLString, responseUrl));
+  std::vector<KURL> urlList;
+  urlList.push_back(KURL(ParsedURLString, responseUrl));
+  webResponse.setURLList(urlList);
   webResponse.setResponseType(WebServiceWorkerResponseTypeDefault);
 
   Cache* cache = createCache(fetcher, new MatchTestCache(webResponse));
   CacheQueryOptions options;
 
   ScriptPromise result =
       cache->match(getScriptState(), stringToRequestInfo(requestUrl), options,
                    exceptionState);
   ScriptValue scriptValue = getResolveValue(result);
   Response* response =
@@ skipping 76 matching lines @@
   NonThrowableExceptionState exceptionState;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::create();
   const String url1 = "http://first.response/";
   const String url2 = "http://second.response/";
 
   Vector<String> expectedUrls(size_t(2));
   expectedUrls[0] = url1;
   expectedUrls[1] = url2;
 
   WebVector<WebServiceWorkerResponse> webResponses(size_t(2));
-  webResponses[0].setURL(KURL(ParsedURLString, url1));
+  std::vector<KURL> urlList1;
+  urlList1.push_back(KURL(ParsedURLString, url1));
+  webResponses[0].setURLList(urlList1);
   webResponses[0].setResponseType(WebServiceWorkerResponseTypeDefault);
-  webResponses[1].setURL(KURL(ParsedURLString, url2));
+  std::vector<KURL> urlList2;
+  urlList2.push_back(KURL(ParsedURLString, url2));
+  webResponses[1].setURLList(urlList2);
   webResponses[1].setResponseType(WebServiceWorkerResponseTypeDefault);
 
   Cache* cache =
       createCache(fetcher, new MatchAllAndBatchTestCache(webResponses));
 
   CacheQueryOptions options;
   ScriptPromise result =
       cache->matchAll(getScriptState(), stringToRequestInfo("http://some.url/"),
                       options, exceptionState);
   ScriptValue scriptValue = getResolveValue(result);
@@ skipping 57 matching lines @@
 
   EXPECT_EQ(kNotImplementedString, getRejectString(addResult));
   EXPECT_EQ(1, fetcher->fetchCount());
   EXPECT_EQ("dispatchBatch",
             testCache->getAndClearLastErrorWebCacheMethodCalled());
 }
 
 }  // namespace
 
 }  // namespace blink