Implement headers attributes in ForeignFetchResponse

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 64 matching lines @@
       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(),
       base::UTF16ToASCII(base::StringPiece16(web_response.statusText())),
       web_response.responseType(), headers,
       base::UTF16ToASCII(base::StringPiece16(web_response.blobUUID())),
       web_response.blobSize(), web_response.streamURL(),
       blink::WebServiceWorkerResponseErrorUnknown,
       base::Time::FromInternalValue(web_response.responseTime()),
       !web_response.cacheStorageCacheName().isNull(),
-      web_response.cacheStorageCacheName().utf8());
+      web_response.cacheStorageCacheName().utf8(), cors_exposed_header_names);
 }
 
 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;
@@ skipping 541 matching lines @@
     blink::WebServiceWorkerResponse* web_response) {
   web_response->setURL(response.url);
   web_response->setStatus(response.status_code);
   web_response->setStatusText(base::ASCIIToUTF16(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());
+  std::transform(
+      response.cors_exposed_header_names.begin(),
+      response.cors_exposed_header_names.end(), headers.begin(),
+      [](const std::string& h) { return blink::WebString::fromLatin1(h); });
+  web_response->setCorsExposedHeaderNames(headers);
 
   for (const auto& i : response.headers) {
     web_response->setHeader(base::ASCIIToUTF16(i.first),
                             base::ASCIIToUTF16(i.second));
   }
 
   if (!response.blob_uuid.empty()) {
     web_response->setBlob(blink::WebString::fromUTF8(response.blob_uuid),
                           response.blob_size);
     // Let the host know that it can release its reference to the blob.
     Send(new CacheStorageHostMsg_BlobDataHandled(response.blob_uuid));
   }
 }
 
 blink::WebVector<blink::WebServiceWorkerResponse>
 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