Introduce url_list to the Response scheme of CacheStorage.

content/browser/cache_storage/cache_storage_cache_unittest.cc

 // 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 "content/browser/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 186 matching lines @@
 }
 
 bool ResponseMetadataEqual(const ServiceWorkerResponse& expected,
                            const ServiceWorkerResponse& actual) {
   EXPECT_EQ(expected.status_code, actual.status_code);
   if (expected.status_code != actual.status_code)
     return false;
   EXPECT_EQ(expected.status_text, actual.status_text);
   if (expected.status_text != actual.status_text)
     return false;
-  EXPECT_EQ(expected.url, actual.url);
-  if (expected.url != actual.url)
+  EXPECT_EQ(expected.url_list.size(), actual.url_list.size());
+  if (expected.url_list.size() != actual.url_list.size())
     return false;
+  for (size_t i = 0; i < expected.url_list.size(); ++i) {
+    EXPECT_EQ(expected.url_list[i], actual.url_list[i]);
+    if (expected.url_list[i] != actual.url_list[i])
+      return false;
+  }
   EXPECT_EQ(expected.blob_size, actual.blob_size);
   if (expected.blob_size != actual.blob_size)
     return false;
 
   if (expected.blob_size == 0) {
     EXPECT_STREQ("", actual.blob_uuid.c_str());
     if (!actual.blob_uuid.empty())
       return false;
   } else {
     EXPECT_STRNE("", actual.blob_uuid.c_str());
@@ skipping 174 matching lines @@
     std::string expected_response;
     for (int i = 0; i < 100; ++i)
       expected_blob_data_ += kTestData;
 
     std::unique_ptr<storage::BlobDataBuilder> blob_data(
         new storage::BlobDataBuilder("blob-id:myblob"));
     blob_data->AppendData(expected_blob_data_);
 
     blob_handle_ =
         blob_storage_context->context()->AddFinishedBlob(blob_data.get());
+    std::unique_ptr<std::vector<GURL>> body_response_url_list(
+        base::MakeUnique<std::vector<GURL>>());
+    body_response_url_list->push_back(GURL("http://example.com/body.html"));
 
     body_response_ = ServiceWorkerResponse(
-        GURL("http://example.com/body.html"), 200, "OK",
-        blink::WebServiceWorkerResponseTypeDefault, headers,
-        blob_handle_->uuid(), expected_blob_data_.size(), GURL(),
+        std::move(body_response_url_list), 200, "OK",
+        blink::WebServiceWorkerResponseTypeDefault,
+        base::MakeUnique<ServiceWorkerHeaderMap>(headers), blob_handle_->uuid(),
+        expected_blob_data_.size(), GURL(),
         blink::WebServiceWorkerResponseErrorUnknown, base::Time::Now(),
         false /* is_in_cache_storage */,
         std::string() /* cache_storage_cache_name */,
-        ServiceWorkerHeaderList() /* cors_exposed_header_names */);
+        base::MakeUnique<
+            ServiceWorkerHeaderList>() /* cors_exposed_header_names */);
 
+    std::unique_ptr<std::vector<GURL>> body_response_with_query_url_list(
+        base::MakeUnique<std::vector<GURL>>());
+    body_response_with_query_url_list->push_back(
+        GURL("http://example.com/body.html?query=test"));
+    std::unique_ptr<ServiceWorkerHeaderList> cors_exposed_header_names(
+        base::MakeUnique<ServiceWorkerHeaderList>());
+    cors_exposed_header_names->push_back("a");
     body_response_with_query_ = ServiceWorkerResponse(
-        GURL("http://example.com/body.html?query=test"), 200, "OK",
-        blink::WebServiceWorkerResponseTypeDefault, headers,
-        blob_handle_->uuid(), expected_blob_data_.size(), GURL(),
+        std::move(body_response_with_query_url_list), 200, "OK",
+        blink::WebServiceWorkerResponseTypeDefault,
+        base::MakeUnique<ServiceWorkerHeaderMap>(headers), blob_handle_->uuid(),
+        expected_blob_data_.size(), GURL(),
         blink::WebServiceWorkerResponseErrorUnknown, base::Time::Now(),
         false /* is_in_cache_storage */,
         std::string() /* cache_storage_cache_name */,
-        {"a"} /* cors_exposed_header_names */);
+        std::move(cors_exposed_header_names));
 
+    std::unique_ptr<std::vector<GURL>> no_body_response_url_list(
+        base::MakeUnique<std::vector<GURL>>());
+    no_body_response_url_list->push_back(
+        GURL("http://example.com/no_body.html"));
     no_body_response_ = ServiceWorkerResponse(
-        GURL("http://example.com/no_body.html"), 200, "OK",
-        blink::WebServiceWorkerResponseTypeDefault, headers, "", 0, GURL(),
+        std::move(no_body_response_url_list), 200, "OK",
+        blink::WebServiceWorkerResponseTypeDefault,
+        base::MakeUnique<ServiceWorkerHeaderMap>(headers), "", 0, GURL(),
         blink::WebServiceWorkerResponseErrorUnknown, base::Time::Now(),
         false /* is_in_cache_storage */,
         std::string() /* cache_storage_cache_name */,
-        ServiceWorkerHeaderList() /* cors_exposed_header_names */);
+        base::MakeUnique<
+            ServiceWorkerHeaderList>() /* cors_exposed_header_names */);
   }
 
   std::unique_ptr<ServiceWorkerFetchRequest> CopyFetchRequest(
       const ServiceWorkerFetchRequest& request) {
     return base::MakeUnique<ServiceWorkerFetchRequest>(
         request.url, request.method, request.headers, request.referrer,
         request.is_reload);
   }
 
   CacheStorageError BatchOperation(
@@ skipping 273 matching lines @@
 TEST_P(CacheStorageCacheTestP, PutBody) {
   EXPECT_TRUE(Put(body_request_, body_response_));
 }
 
 TEST_P(CacheStorageCacheTestP, PutBody_Multiple) {
   CacheStorageBatchOperation operation1;
   operation1.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation1.request = body_request_;
   operation1.request.url = GURL("http://example.com/1");
   operation1.response = body_response_;
-  operation1.response.url = GURL("http://example.com/1");
+  operation1.response.url_list.push_back(GURL("http://example.com/1"));
 
   CacheStorageBatchOperation operation2;
   operation2.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation2.request = body_request_;
   operation2.request.url = GURL("http://example.com/2");
   operation2.response = body_response_;
-  operation2.response.url = GURL("http://example.com/2");
+  operation2.response.url_list.push_back(GURL("http://example.com/2"));
 
   CacheStorageBatchOperation operation3;
   operation3.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation3.request = body_request_;
   operation3.request.url = GURL("http://example.com/3");
   operation3.response = body_response_;
-  operation3.response.url = GURL("http://example.com/3");
+  operation3.response.url_list.push_back(GURL("http://example.com/3"));
 
   std::vector<CacheStorageBatchOperation> operations;
   operations.push_back(operation1);
   operations.push_back(operation2);
   operations.push_back(operation3);
 
   EXPECT_EQ(CACHE_STORAGE_OK, BatchOperation(operations));
   EXPECT_TRUE(Match(operation1.request));
   EXPECT_TRUE(Match(operation2.request));
   EXPECT_TRUE(Match(operation3.request));
@@ skipping 61 matching lines @@
   EXPECT_FALSE(Keys());
   EXPECT_EQ(CACHE_STORAGE_ERROR_QUERY_TOO_LARGE, callback_error_);
 }
 
 // TODO(nhiroki): Add a test for the case where one of PUT operations fails.
 // Currently there is no handy way to fail only one operation in a batch.
 // This could be easily achieved after adding some security checks in the
 // browser side (http://crbug.com/425505).
 
 TEST_P(CacheStorageCacheTestP, ResponseURLDiffersFromRequestURL) {
-  no_body_response_.url = GURL("http://example.com/foobar");
+  no_body_response_.url_list.clear();
+  no_body_response_.url_list.push_back(GURL("http://example.com/foobar"));
   EXPECT_STRNE("http://example.com/foobar",
                no_body_request_.url.spec().c_str());
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
+  ASSERT_EQ(1u, callback_response_->url_list.size());
   EXPECT_STREQ("http://example.com/foobar",
-               callback_response_->url.spec().c_str());
+               callback_response_->url_list[0].spec().c_str());
 }
 
 TEST_P(CacheStorageCacheTestP, ResponseURLEmpty) {
-  no_body_response_.url = GURL();
+  no_body_response_.url_list.clear();
   EXPECT_STRNE("", no_body_request_.url.spec().c_str());
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
-  EXPECT_STREQ("", callback_response_->url.spec().c_str());
+  EXPECT_EQ(0u, callback_response_->url_list.size());
 }
 
 TEST_F(CacheStorageCacheTest, PutBodyDropBlobRef) {
   CacheStorageBatchOperation operation;
   operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation.request = body_request_;
   operation.response = body_response_;
 
   std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
   cache_->BatchOperation(
@@ skipping 289 matching lines @@
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = true;
   EXPECT_TRUE(MatchAll(body_request_, match_params, &responses, &body_handles));
 
   ASSERT_EQ(2u, responses->size());
   ASSERT_EQ(2u, body_handles->size());
 
   // Order of returned responses is not guaranteed.
   std::set<std::string> matched_set;
   for (const ServiceWorkerResponse& response : *responses) {
-    if (response.url.spec() == "http://example.com/body.html?query=test") {
+    ASSERT_EQ(1u, response.url_list.size());
+    if (response.url_list[0].spec() ==
+        "http://example.com/body.html?query=test") {
       EXPECT_TRUE(ResponseMetadataEqual(SetCacheName(body_response_with_query_),
                                         response));
-      matched_set.insert(response.url.spec());
-    } else if (response.url.spec() == "http://example.com/body.html") {
+      matched_set.insert(response.url_list[0].spec());
+    } else if (response.url_list[0].spec() == "http://example.com/body.html") {
       EXPECT_TRUE(
           ResponseMetadataEqual(SetCacheName(body_response_), response));
-      matched_set.insert(response.url.spec());
+      matched_set.insert(response.url_list[0].spec());
     }
   }
   EXPECT_EQ(2u, matched_set.size());
 }
 
 TEST_P(CacheStorageCacheTestP, MatchAll_Head) {
   EXPECT_TRUE(Put(body_request_, body_response_));
 
   std::unique_ptr<CacheStorageCache::Responses> responses;
   std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
@@ skipping 323 matching lines @@
   memset(buffer->data(), 0, kSize);
   EXPECT_FALSE(WriteSideData(GURL("http://www.example.com/not_exist"),
                              base::Time::Now(), buffer, kSize));
   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 }
 
 TEST_F(CacheStorageCacheTest, CaselessServiceWorkerResponseHeaders) {
   // CacheStorageCache depends on ServiceWorkerResponse having caseless
   // headers so that it can quickly lookup vary headers.
   ServiceWorkerResponse response(
-      GURL("http://www.example.com"), 200, "OK",
-      blink::WebServiceWorkerResponseTypeDefault, ServiceWorkerHeaderMap(), "",
-      0, GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+      base::MakeUnique<std::vector<GURL>>(), 200, "OK",
+      blink::WebServiceWorkerResponseTypeDefault,
+      base::MakeUnique<ServiceWorkerHeaderMap>(), "", 0, GURL(),
+      blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
       false /* is_in_cache_storage */,
       std::string() /* cache_storage_cache_name */,
-      ServiceWorkerHeaderList() /* cors_exposed_header_names */);
+      base::MakeUnique<
+          ServiceWorkerHeaderList>() /* cors_exposed_header_names */);
   response.headers["content-type"] = "foo";
   response.headers["Content-Type"] = "bar";
   EXPECT_EQ("bar", response.headers["content-type"]);
 }
 
 TEST_F(CacheStorageCacheTest, CaselessServiceWorkerFetchRequestHeaders) {
   // CacheStorageCache depends on ServiceWorkerFetchRequest having caseless
   // headers so that it can quickly lookup vary headers.
   ServiceWorkerFetchRequest request(GURL("http://www.example.com"), "GET",
                                     ServiceWorkerHeaderMap(), Referrer(),
@@ skipping 114 matching lines @@
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content