Use WebURLResponse to pass the navigation preload response from SWContextClient to FetchEvent.

third_party/WebKit/Source/modules/serviceworkers/FetchEvent.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/serviceworkers/FetchEvent.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ToV8.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
 #include "modules/fetch/Request.h"
 #include "modules/fetch/Response.h"
 #include "modules/serviceworkers/ServiceWorkerError.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
+#include "public/platform/WebURLResponse.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerError.h"
-#include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 FetchEvent* FetchEvent::create(ScriptState* scriptState,
                                const AtomicString& type,
                                const FetchEventInit& initializer) {
   return new FetchEvent(scriptState, type, initializer, nullptr, nullptr,
                         false);
@@ skipping 73 matching lines @@
         scriptState, event.As<v8::Object>(),
         V8HiddenValue::requestInFetchEvent(scriptState->isolate()), request);
     // From the same reason as above, setHiddenValue can return false.
     // TODO(yhirano): Add an assertion that it returns true once the
     // graceful shutdown mechanism is introduced.
   }
 }
 
 void FetchEvent::onNavigationPreloadResponse(
     ScriptState* scriptState,
-    std::unique_ptr<WebServiceWorkerResponse> response,
+    std::unique_ptr<WebURLResponse> response,
     std::unique_ptr<WebDataConsumerHandle> dataConsumeHandle) {
   if (!scriptState->contextIsValid())
     return;
   DCHECK(m_preloadResponseProperty);
   ScriptState::Scope scope(scriptState);
   FetchResponseData* responseData = FetchResponseData::createWithBuffer(
       new BodyStreamBuffer(scriptState, new BytesConsumerForDataConsumerHandle(
                                             scriptState->getExecutionContext(),
                                             std::move(dataConsumeHandle))));
-  const WebVector<WebURL>& webURLList = response->urlList();
-  // Navigation preload doesn't support redirect.
-  DCHECK_EQ(1u, webURLList.size());
   Vector<KURL> urlList(1);
-  urlList[0] = webURLList[0];
+  urlList[0] = response->url();
   responseData->setURLList(urlList);
-  responseData->setStatus(response->status());
-  responseData->setStatusMessage(response->statusText());
-  responseData->setResponseTime(response->responseTime());
-  for (const auto& header : response->headers())
+  responseData->setStatus(response->httpStatusCode());
+  responseData->setStatusMessage(response->httpStatusText());
+  responseData->setResponseTime(response->toResourceResponse().responseTime());
+  const HTTPHeaderMap& headers(
+      response->toResourceResponse().httpHeaderFields());
+  for (const auto& header : headers) {
     responseData->headerList()->append(header.key, header.value);
+  }
   FetchResponseData* taintedResponse =
       responseData->createBasicFilteredResponse();
   m_preloadResponseProperty->resolve(
       Response::create(scriptState->getExecutionContext(), taintedResponse));
 }
 
 void FetchEvent::onNavigationPreloadError(
     ScriptState* scriptState,
     std::unique_ptr<WebServiceWorkerError> error) {
   if (!scriptState->contextIsValid())
     return;
   DCHECK(m_preloadResponseProperty);
   m_preloadResponseProperty->reject(
       ServiceWorkerError::take(nullptr, *error.get()));
 }
 
 DEFINE_TRACE(FetchEvent) {
   visitor->trace(m_observer);
   visitor->trace(m_request);
   visitor->trace(m_preloadResponseProperty);
   ExtendableEvent::trace(visitor);
 }
 
 }  // namespace blink