[ServiceWorker] Fetch event should return integrity value

content/browser/service_worker/foreign_fetch_request_handler.cc

 // Copyright 2015 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/foreign_fetch_request_handler.h"
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 58 matching lines @@
 void ForeignFetchRequestHandler::InitializeHandler(
     net::URLRequest* request,
     ServiceWorkerContextWrapper* context_wrapper,
     storage::BlobStorageContext* blob_storage_context,
     int process_id,
     int provider_id,
     ServiceWorkerMode service_worker_mode,
     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<ResourceRequestBody> body,
     bool initiated_in_secure_context) {
   if (!IsForeignFetchEnabled())
     return;
 
   if (!context_wrapper || !context_wrapper->context() ||
       provider_id == kInvalidServiceWorkerProviderId) {
@@ skipping 33 matching lines @@
   if (!context_wrapper->OriginHasForeignFetchRegistrations(
           request->url().GetOrigin())) {
     return;
   }
 
   // Any more precise checks to see if the request should be intercepted are
   // asynchronous, so just create our handler in all cases.
   std::unique_ptr<ForeignFetchRequestHandler> handler =
       base::WrapUnique(new ForeignFetchRequestHandler(
           context_wrapper, blob_storage_context->AsWeakPtr(), request_mode,
-          credentials_mode, redirect_mode, resource_type, request_context_type,
-          frame_type, body, timeout));
+          credentials_mode, redirect_mode, integrity, resource_type,
+          request_context_type, frame_type, body, timeout));
   request->SetUserData(&kUserDataKey, std::move(handler));
 }
 
 ForeignFetchRequestHandler* ForeignFetchRequestHandler::GetHandler(
     net::URLRequest* request) {
   return static_cast<ForeignFetchRequestHandler*>(
       request->GetUserData(&kUserDataKey));
 }
 
 std::unique_ptr<net::URLRequestInterceptor>
@@ skipping 31 matching lines @@
     // other foreign fetch service workers.
     return nullptr;
   }
 
   // It's for original request (A) or redirect case (B-a or B-b).
   DCHECK(!job_.get() || job_->ShouldForwardToServiceWorker());
 
   ServiceWorkerURLRequestJob* job = new ServiceWorkerURLRequestJob(
       request, network_delegate, std::string(), blob_storage_context_,
       resource_context, request_mode_, credentials_mode_, redirect_mode_,
-      resource_type_, request_context_type_, frame_type_, body_,
+      integrity_, resource_type_, request_context_type_, frame_type_, body_,
       ServiceWorkerFetchType::FOREIGN_FETCH, timeout_, this);
   job_ = job->GetWeakPtr();
   resource_context_ = resource_context;
 
   context_->FindReadyRegistrationForDocument(
       request->url(),
       base::Bind(&ForeignFetchRequestHandler::DidFindRegistration,
                  weak_factory_.GetWeakPtr(), job_));
 
   return job_.get();
 }
 
 ForeignFetchRequestHandler::ForeignFetchRequestHandler(
     ServiceWorkerContextWrapper* context,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_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<ResourceRequestBody> body,
     const base::Optional<base::TimeDelta>& timeout)
     : context_(context),
       blob_storage_context_(blob_storage_context),
       resource_type_(resource_type),
       request_mode_(request_mode),
       credentials_mode_(credentials_mode),
       redirect_mode_(redirect_mode),
+      integrity_(integrity),
       request_context_type_(request_context_type),
       frame_type_(frame_type),
       body_(body),
       timeout_(timeout),
       weak_factory_(this) {}
 
 void ForeignFetchRequestHandler::DidFindRegistration(
     const base::WeakPtr<ServiceWorkerURLRequestJob>& job,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
@@ skipping 80 matching lines @@
   // The worker entry in the database was written by old version Chrome (< M56)
   // and the main script was not loaded yet. In this case, we can't check the
   // origin trial token.
   if (!active_version->origin_trial_tokens())
     return true;
   const auto& token_map = *active_version->origin_trial_tokens();
   return base::ContainsKey(token_map, "ForeignFetch");
 }
 
 }  // namespace content