Introduce url_list to the Response scheme of CacheStorage.

media/blink/multibuffer_data_source_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 752 matching lines @@
   // server. So an error should occur.
   ExecuteMixedResponseFailureTest(response1, response2);
 }
 
 TEST_F(MultibufferDataSourceTest,
        Http_MixedResponse_ServiceWorkerProxiedAndSameURLResponse) {
   Initialize(kHttpUrl, true);
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.setWasFetchedViaServiceWorker(true);
-  response1.setOriginalURLViaServiceWorker(GURL(kHttpUrl));
+  std::vector<blink::WebURL> urlList;

[falken, 2016/12/05 01:22:33]

url_list (throughout this file)

Optional suggestion, could this just be:
std::vector<blink::WebURL> url_list = {GURL(kHttpUrl)};

throughout this patch? It's fairly common:
$ git gs "std::vector.* = {.*};"

[horo, 2016/12/05 03:39:49]

Done.

+  urlList.push_back(GURL(kHttpUrl));
+  response1.setURLListViaServiceWorker(urlList);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
   // The origin URL of response1 and response2 are same. So no error should
   // occur.
   ExecuteMixedResponseSuccessTest(response1, response2);
 }
 
 TEST_F(MultibufferDataSourceTest,
        Http_MixedResponse_ServiceWorkerProxiedAndDifferentPathResponse) {
   Initialize(kHttpUrl, true);
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.setWasFetchedViaServiceWorker(true);
-  response1.setOriginalURLViaServiceWorker(GURL(kHttpDifferentPathUrl));
+  std::vector<blink::WebURL> urlList;
+  urlList.push_back(GURL(kHttpDifferentPathUrl));
+  response1.setURLListViaServiceWorker(urlList);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
   // The origin URL of response1 and response2 are same. So no error should
   // occur.
   ExecuteMixedResponseSuccessTest(response1, response2);
 }
 
 TEST_F(MultibufferDataSourceTest,
        Http_MixedResponse_ServiceWorkerProxiedAndDifferentOriginResponse) {
   Initialize(kHttpUrl, true);
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.setWasFetchedViaServiceWorker(true);
-  response1.setOriginalURLViaServiceWorker(GURL(kHttpDifferentOriginUrl));
+  std::vector<blink::WebURL> urlList;
+  urlList.push_back(GURL(kHttpDifferentOriginUrl));
+  response1.setURLListViaServiceWorker(urlList);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
   // The origin URL of response1 and response2 are different. So an error should
   // occur.
   ExecuteMixedResponseFailureTest(response1, response2);
 }
 
 TEST_F(MultibufferDataSourceTest,
        Http_MixedResponse_ServiceWorkerProxiedAndDifferentOriginResponseCORS) {
   InitializeWithCORS(kHttpUrl, true, UrlData::CORS_ANONYMOUS);
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.setWasFetchedViaServiceWorker(true);
-  response1.setOriginalURLViaServiceWorker(GURL(kHttpDifferentOriginUrl));
+  std::vector<blink::WebURL> urlList;
+  urlList.push_back(GURL(kHttpDifferentOriginUrl));
+  response1.setURLListViaServiceWorker(urlList);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
   // The origin URL of response1 and response2 are different, but a CORS check
   // has been passed for each request, so expect success.
   ExecuteMixedResponseSuccessTest(response1, response2);
 }
 
 TEST_F(MultibufferDataSourceTest, File_Retry) {
   InitializeWithFileResponse();
 
@@ skipping 672 matching lines @@
   EXPECT_EQ(kDataSize / 2, len);
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, DidPassCORSAccessTest) {
   InitializeWithCORS(kHttpUrl, true, UrlData::CORS_ANONYMOUS);
   set_preload(MultibufferDataSource::NONE);
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.setWasFetchedViaServiceWorker(true);
-  response1.setOriginalURLViaServiceWorker(GURL(kHttpDifferentOriginUrl));
+  std::vector<blink::WebURL> urlList;
+  urlList.push_back(GURL(kHttpDifferentOriginUrl));
+  response1.setURLListViaServiceWorker(urlList);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
 
   EXPECT_CALL(host_, SetTotalBytes(kFileSize));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
   EXPECT_CALL(*this, ReadCallback(kDataSize));
 
   EXPECT_FALSE(data_source_->DidPassCORSAccessCheck());
   Respond(response1);
   ReceiveData(kDataSize);
@@ skipping 108 matching lines @@
                      base::Bind(&MultibufferDataSourceTest::ReadCallback,
                                 base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   // Make sure we're not downloading anymore.
   EXPECT_EQ(data_source_->downloading(), false);
   Stop();
 }
 
 }  // namespace media