Introduce url_list to the Response scheme of CacheStorage.

content/renderer/cache_storage/cache_storage_dispatcher.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/renderer/cache_storage/cache_storage_dispatcher.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <string>
@@ skipping 60 matching lines @@
 
 blink::WebVector<blink::WebServiceWorkerRequest> WebRequestsFromRequests(
     const std::vector<ServiceWorkerFetchRequest>& requests) {
   blink::WebVector<blink::WebServiceWorkerRequest> web_requests(
       requests.size());
   for (size_t i = 0; i < requests.size(); ++i)
     PopulateWebRequestFromFetchRequest(requests[i], &(web_requests[i]));
   return web_requests;
 }
 
-ServiceWorkerResponse ResponseFromWebResponse(
-    const blink::WebServiceWorkerResponse& web_response) {
-  ServiceWorkerHeaderMap headers;
-  GetServiceWorkerHeaderMapFromWebResponse(web_response, &headers);
-  ServiceWorkerHeaderList cors_exposed_header_names;
-  GetCorsExposedHeaderNamesFromWebResponse(web_response,
-                                           &cors_exposed_header_names);
-  // We don't support streaming for cache.
-  DCHECK(web_response.streamURL().isEmpty());
-  return ServiceWorkerResponse(
-      web_response.url(), web_response.status(),
-      web_response.statusText().ascii(), web_response.responseType(), headers,
-      web_response.blobUUID().ascii(), web_response.blobSize(),
-      web_response.streamURL(), blink::WebServiceWorkerResponseErrorUnknown,
-      base::Time::FromInternalValue(web_response.responseTime()),
-      !web_response.cacheStorageCacheName().isNull(),
-      web_response.cacheStorageCacheName().utf8(), cors_exposed_header_names);
-}

[falken, 2016/11/30 14:57:37]

nice cleanup

-
 CacheStorageCacheQueryParams QueryParamsFromWebQueryParams(
     const blink::WebServiceWorkerCache::QueryParams& web_query_params) {
   CacheStorageCacheQueryParams query_params;
   query_params.ignore_search = web_query_params.ignoreSearch;
   query_params.ignore_method = web_query_params.ignoreMethod;
   query_params.ignore_vary = web_query_params.ignoreVary;
   query_params.cache_name = web_query_params.cacheName;
   return query_params;
 }
 
 CacheStorageCacheOperationType CacheOperationTypeFromWebCacheOperationType(
     blink::WebServiceWorkerCache::OperationType operation_type) {
   switch (operation_type) {
     case blink::WebServiceWorkerCache::OperationTypePut:
       return CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     case blink::WebServiceWorkerCache::OperationTypeDelete:
       return CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE;
     default:
       return CACHE_STORAGE_CACHE_OPERATION_TYPE_UNDEFINED;
   }
 }
 
 CacheStorageBatchOperation BatchOperationFromWebBatchOperation(
     const blink::WebServiceWorkerCache::BatchOperation& web_operation) {
+  // We don't support streaming for cache.
+  DCHECK(web_operation.response.streamURL().isEmpty());
+
   CacheStorageBatchOperation operation;
   operation.operation_type =
       CacheOperationTypeFromWebCacheOperationType(web_operation.operationType);
   operation.request = FetchRequestFromWebRequest(web_operation.request);
-  operation.response = ResponseFromWebResponse(web_operation.response);
+  operation.response =
+      GetServiceWorkerResponseFromWebResponse(web_operation.response);
   operation.match_params =
       QueryParamsFromWebQueryParams(web_operation.matchParams);
   return operation;
 }
 
 template <typename T>
 void ClearCallbacksMapWithErrors(T* callbacks_map) {
   typename T::iterator iter(callbacks_map);
   while (!iter.IsAtEnd()) {
     iter.GetCurrentValue()->onError(blink::WebServiceWorkerCacheErrorNotFound);
@@ skipping 486 matching lines @@
 }
 
 void CacheStorageDispatcher::OnWebCacheDestruction(int cache_id) {
   web_caches_.Remove(cache_id);
   Send(new CacheStorageHostMsg_CacheClosed(cache_id));
 }
 
 void CacheStorageDispatcher::PopulateWebResponseFromResponse(
     const ServiceWorkerResponse& response,
     blink::WebServiceWorkerResponse* web_response) {
-  web_response->setURL(response.url);
+  blink::WebVector<blink::WebURL> url_list(response.url_list.size());
+  std::transform(response.url_list.begin(), response.url_list.end(),
+                 url_list.begin(), [](const GURL& url) { return url; });
+  web_response->setURLList(url_list);
+
   web_response->setStatus(response.status_code);
   web_response->setStatusText(WebString::fromASCII(response.status_text));
   web_response->setResponseType(response.response_type);
   web_response->setResponseTime(response.response_time.ToInternalValue());
   web_response->setCacheStorageCacheName(
       response.is_in_cache_storage
           ? blink::WebString::fromUTF8(response.cache_storage_cache_name)
           : blink::WebString());
   blink::WebVector<blink::WebString> headers(
       response.cors_exposed_header_names.size());
@@ skipping 20 matching lines @@
 CacheStorageDispatcher::WebResponsesFromResponses(
     const std::vector<ServiceWorkerResponse>& responses) {
   blink::WebVector<blink::WebServiceWorkerResponse> web_responses(
       responses.size());
   for (size_t i = 0; i < responses.size(); ++i)
     PopulateWebResponseFromResponse(responses[i], &(web_responses[i]));
   return web_responses;
 }
 
 }  // namespace content