Implement headers attributes in ForeignFetchResponse

third_party/WebKit/Source/modules/fetch/FetchResponseData.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/fetch/FetchResponseData.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMArrayBuffer.h"
-#include "core/fetch/CrossOriginAccessControl.h"
 #include "core/fetch/FetchUtils.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchHeaderList.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 16 matching lines @@
     case FetchResponseData::OpaqueType:
         webType = WebServiceWorkerResponseTypeOpaque;
         break;
     case FetchResponseData::OpaqueRedirectType:
         webType = WebServiceWorkerResponseTypeOpaqueRedirect;
         break;
     }
     return webType;
 }
 
+WebVector<WebString> headerSetToWebVector(const HTTPHeaderSet& headers)
+{
+    // Can't just pass *headers to the WebVector constructor because HashSet
+    // iterators are not stl iterator compatible.
+    WebVector<WebString> result(static_cast<size_t>(headers.size()));
+    int idx = 0;
+    for (const auto& header : headers)
+        result[idx++] = header;
+    return result;
+}
+
 } // namespace
 
 FetchResponseData* FetchResponseData::create()
 {
     // "Unless stated otherwise, a response's url is null, status is 200, status
     // message is `OK`, header list is an empty header list, and body is null."
     return new FetchResponseData(DefaultType, 200, "OK");
 }
 
 FetchResponseData* FetchResponseData::createNetworkErrorResponse()
@@ skipping 27 matching lines @@
     }
     response->m_buffer = m_buffer;
     response->m_mimeType = m_mimeType;
     response->m_internalResponse = const_cast<FetchResponseData*>(this);
     return response;
 }
 
 FetchResponseData* FetchResponseData::createCORSFilteredResponse() const
 {
     DCHECK_EQ(m_type, DefaultType);
+    HTTPHeaderSet accessControlExposeHeaderSet;
+    String accessControlExposeHeaders;
+    if (m_headerList->get(HTTPNames::Access_Control_Expose_Headers, accessControlExposeHeaders))
+        parseAccessControlExposeHeadersAllowList(accessControlExposeHeaders, accessControlExposeHeaderSet);
+    return createCORSFilteredResponse(accessControlExposeHeaderSet);
+}
+
+FetchResponseData* FetchResponseData::createCORSFilteredResponse(const HTTPHeaderSet& exposedHeaders) const
+{
+    DCHECK_EQ(m_type, DefaultType);
     // "A CORS filtered response is a filtered response whose type is |CORS|,
     // header list excludes all headers in internal response's header list,
     // except those whose name is either one of `Cache-Control`,
     // `Content-Language`, `Content-Type`, `Expires`, `Last-Modified`, and
     // `Pragma`, and except those whose name is one of the values resulting from
     // parsing `Access-Control-Expose-Headers` in internal response's header
     // list."
     FetchResponseData* response = new FetchResponseData(CORSType, m_status, m_statusMessage);
     response->m_url = m_url;
-    HTTPHeaderSet accessControlExposeHeaderSet;
-    String accessControlExposeHeaders;
-    if (m_headerList->get("access-control-expose-headers", accessControlExposeHeaders))
-        parseAccessControlExposeHeadersAllowList(accessControlExposeHeaders, accessControlExposeHeaderSet);
     for (size_t i = 0; i < m_headerList->size(); ++i) {
         const FetchHeaderList::Header* header = m_headerList->list()[i].get();
         const String& name = header->first;
-        if (isOnAccessControlResponseHeaderWhitelist(name) || (accessControlExposeHeaderSet.contains(name) && !FetchUtils::isForbiddenResponseHeaderName(name)))
+        const bool explicitlyExposed = exposedHeaders.contains(name);
+        if (isOnAccessControlResponseHeaderWhitelist(name) || (explicitlyExposed && !FetchUtils::isForbiddenResponseHeaderName(name))) {
+            if (explicitlyExposed)
+                response->m_corsExposedHeaderNames.add(name);
             response->m_headerList->append(name, header->second);
+        }
     }
     response->m_buffer = m_buffer;
     response->m_mimeType = m_mimeType;
     response->m_internalResponse = const_cast<FetchResponseData*>(this);
     return response;
 }
 
 FetchResponseData* FetchResponseData::createOpaqueFilteredResponse() const
 {
     DCHECK_EQ(m_type, DefaultType);
@@ skipping 51 matching lines @@
         newResponse->m_terminationReason = adoptPtr(new TerminationReason);
         *newResponse->m_terminationReason = *m_terminationReason;
     }
     newResponse->m_url = m_url;
     newResponse->m_status = m_status;
     newResponse->m_statusMessage = m_statusMessage;
     newResponse->m_headerList = m_headerList->clone();
     newResponse->m_mimeType = m_mimeType;
     newResponse->m_responseTime = m_responseTime;
     newResponse->m_cacheStorageCacheName = m_cacheStorageCacheName;
+    newResponse->m_corsExposedHeaderNames = m_corsExposedHeaderNames;
 
     switch (m_type) {
     case BasicType:
     case CORSType:
         ASSERT(m_internalResponse);
         ASSERT(m_buffer == m_internalResponse->m_buffer);
         ASSERT(m_internalResponse->m_type == DefaultType);
         newResponse->m_internalResponse = m_internalResponse->clone(scriptState);
         m_buffer = m_internalResponse->m_buffer;
         newResponse->m_buffer = newResponse->m_internalResponse->m_buffer;
@@ skipping 22 matching lines @@
         break;
     }
     return newResponse;
 }
 
 void FetchResponseData::populateWebServiceWorkerResponse(WebServiceWorkerResponse& response)
 {
     if (m_internalResponse) {
         m_internalResponse->populateWebServiceWorkerResponse(response);
         response.setResponseType(fetchTypeToWebType(m_type));
+        response.setCorsExposedHeaderNames(headerSetToWebVector(m_corsExposedHeaderNames));
         return;
     }
 
     response.setURL(url());
     response.setStatus(status());
     response.setStatusText(statusMessage());
     response.setResponseType(fetchTypeToWebType(m_type));
     response.setResponseTime(responseTime());
     response.setCacheStorageCacheName(cacheStorageCacheName());
+    response.setCorsExposedHeaderNames(headerSetToWebVector(m_corsExposedHeaderNames));
     for (size_t i = 0; i < headerList()->size(); ++i) {
         const FetchHeaderList::Header* header = headerList()->list()[i].get();
         response.appendHeader(header->first, header->second);
     }
 }
 
 FetchResponseData::FetchResponseData(Type type, unsigned short status, AtomicString statusMessage)
     : m_type(type)
     , m_status(status)
     , m_statusMessage(statusMessage)
@@ skipping 15 matching lines @@
 }
 
 DEFINE_TRACE(FetchResponseData)
 {
     visitor->trace(m_headerList);
     visitor->trace(m_internalResponse);
     visitor->trace(m_buffer);
 }
 
 } // namespace blink