[ServiceWorker] Fetch event should return integrity value

content/browser/service_worker/service_worker_url_request_job.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/browser/service_worker/service_worker_url_request_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 297 matching lines @@
 
 ServiceWorkerURLRequestJob::ServiceWorkerURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const std::string& client_id,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     const ResourceContext* resource_context,
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     FetchRedirectMode redirect_mode,
+    const std::string& integrity,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
     scoped_refptr<ResourceRequestBodyImpl> body,
     ServiceWorkerFetchType fetch_type,
     const base::Optional<base::TimeDelta>& timeout,
     Delegate* delegate)
     : net::URLRequestJob(request, network_delegate),
       delegate_(delegate),
       response_type_(NOT_DETERMINED),
       is_started_(false),
       service_worker_response_type_(
           blink::kWebServiceWorkerResponseTypeDefault),
       client_id_(client_id),
       blob_storage_context_(blob_storage_context),
       resource_context_(resource_context),
       request_mode_(request_mode),
       credentials_mode_(credentials_mode),
       redirect_mode_(redirect_mode),
+      integrity_(integrity),
       resource_type_(resource_type),
       request_context_type_(request_context_type),
       frame_type_(frame_type),
       fall_back_required_(false),
       body_(body),
       fetch_type_(fetch_type),
       timeout_(timeout),
       weak_factory_(this) {
   DCHECK(delegate_) << "ServiceWorkerURLRequestJob requires a delegate";
 }
@@ skipping 217 matching lines @@
   const net::HttpRequestHeaders& headers = request_->extra_request_headers();
   for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();) {
     if (ServiceWorkerContext::IsExcludedHeaderNameForFetchEvent(it.name()))
       continue;
     request->headers[it.name()] = it.value();
   }
   request->blob_uuid = blob_uuid;
   request->blob_size = blob_size;
   request->credentials_mode = credentials_mode_;
   request->redirect_mode = redirect_mode_;
+  request->integrity = integrity_;
   request->client_id = client_id_;
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
   if (info) {
     request->is_reload = ui::PageTransitionCoreTypeIs(
         info->GetPageTransition(), ui::PAGE_TRANSITION_RELOAD);
     request->referrer =
         Referrer(GURL(request_->referrer()), info->GetReferrerPolicy());
   } else {
     CHECK(
         request_->referrer_policy() ==
@@ skipping 408 matching lines @@
                        weak_factory_.GetWeakPtr()));
   }
   fetch_dispatcher_->Run();
 }
 
 void ServiceWorkerURLRequestJob::OnNavigationPreloadResponse() {
   nav_preload_metrics_->ReportNavigationPreloadFinished();
 }
 
 }  // namespace content