Introduce url_list to the Response scheme of CacheStorage.

third_party/WebKit/Source/modules/fetch/FetchManager.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/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
@@ skipping 16 matching lines @@
 #include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
 #include "modules/fetch/FetchRequestData.h"
 #include "modules/fetch/FormDataBytesConsumer.h"
 #include "modules/fetch/Response.h"
 #include "modules/fetch/ResponseInit.h"
 #include "platform/HTTPNames.h"
 #include "platform/network/NetworkUtils.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
+#include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "platform/weborigin/Suborigin.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
@@ skipping 100 matching lines @@
                         ScriptPromiseResolver* resolver,
                         FetchRequestData* request,
                         bool isIsolatedWorld) {
     return new Loader(executionContext, fetchManager, resolver, request,
                       isIsolatedWorld);
   }
 
   ~Loader() override;
   DECLARE_VIRTUAL_TRACE();
 
+  void didReceiveRedirectTo(const KURL&) override;
   void didReceiveResponse(unsigned long,
                           const ResourceResponse&,
                           std::unique_ptr<WebDataConsumerHandle>) override;
   void didFinishLoading(unsigned long, double) override;
   void didFail(const ResourceError&) override;
   void didFailAccessControlCheck(const ResourceError&) override;
   void didFailRedirectCheck() override;
 
   void start();
   void dispose();
@@ skipping 108 matching lines @@
   Member<FetchManager> m_fetchManager;
   Member<ScriptPromiseResolver> m_resolver;
   Member<FetchRequestData> m_request;
   Member<ThreadableLoader> m_loader;
   bool m_failed;
   bool m_finished;
   int m_responseHttpStatusCode;
   Member<SRIVerifier> m_integrityVerifier;
   bool m_didFinishLoading;
   bool m_isIsolatedWorld;
+  Vector<KURL> m_urlList;
   Member<ExecutionContext> m_executionContext;
 };
 
 FetchManager::Loader::Loader(ExecutionContext* executionContext,
                              FetchManager* fetchManager,
                              ScriptPromiseResolver* resolver,
                              FetchRequestData* request,
                              bool isIsolatedWorld)
     : m_fetchManager(fetchManager),
       m_resolver(resolver),
       m_request(request),
       m_failed(false),
       m_finished(false),
       m_responseHttpStatusCode(0),
       m_integrityVerifier(nullptr),
       m_didFinishLoading(false),
       m_isIsolatedWorld(isIsolatedWorld),
       m_executionContext(executionContext) {
   ThreadState::current()->registerPreFinalizer(this);
+  m_urlList.append(request->url());
 }
 
 FetchManager::Loader::~Loader() {
   ASSERT(!m_loader);
 }
 
 DEFINE_TRACE(FetchManager::Loader) {
   visitor->trace(m_fetchManager);
   visitor->trace(m_resolver);
   visitor->trace(m_request);
   visitor->trace(m_loader);
   visitor->trace(m_integrityVerifier);
   visitor->trace(m_executionContext);
 }
 
+void FetchManager::Loader::didReceiveRedirectTo(const KURL& url) {
+  m_urlList.append(url);
+}
+
 void FetchManager::Loader::didReceiveResponse(
     unsigned long,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   ASSERT(handle);
+  // TODO(horo): This check could be false when we will use the response url
+  // in service worker responses. (crbug.com/553535)
+  DCHECK(response.url() == m_urlList.back());
   ScriptState* scriptState = m_resolver->getScriptState();
   ScriptState::Scope scope(scriptState);
 
   if (response.url().protocolIs("blob") && response.httpStatusCode() == 404) {
     // "If |blob| is null, return a network error."
     // https://fetch.spec.whatwg.org/#concept-basic-fetch
     performNetworkError("Blob not found.");
     return;
   }
 
@@ skipping 82 matching lines @@
             scriptState->getExecutionContext(), std::move(handle))));
   } else {
     sriConsumer = new SRIBytesConsumer();
     responseData = FetchResponseData::createWithBuffer(
         new BodyStreamBuffer(scriptState, sriConsumer));
   }
   responseData->setStatus(response.httpStatusCode());
   responseData->setStatusMessage(response.httpStatusText());
   for (auto& it : response.httpHeaderFields())
     responseData->headerList()->append(it.key, it.value);
-  responseData->setURL(response.url());
+  if (response.urlListViaServiceWorker().isEmpty()) {
+    // Note: |urlListViaServiceWorker| is empty, unless the response came from a
+    // service worker, in which case it will only be empty if it was created
+    // through new Response().
+    responseData->setURLList(m_urlList);
+  } else {
+    DCHECK(response.wasFetchedViaServiceWorker());
+    responseData->setURLList(response.urlListViaServiceWorker());
+  }
   responseData->setMIMEType(response.mimeType());
   responseData->setResponseTime(response.responseTime());
 
   FetchResponseData* taintedResponse = nullptr;
 
   if (NetworkUtils::isRedirectResponseCode(m_responseHttpStatusCode)) {
     Vector<String> locations;
     responseData->headerList()->getAll(HTTPNames::Location, locations);
     if (locations.size() > 1) {
       performNetworkError("Multiple Location header.");
@@ skipping 486 matching lines @@
   m_loaders.remove(loader);
   loader->dispose();
 }
 
 DEFINE_TRACE(FetchManager) {
   visitor->trace(m_loaders);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink