Limit timeout for foreign fetch events when triggered by another service worker.

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 "base/command_line.h"
 #include "base/macros.h"
@@ skipping 73 matching lines @@
 
   if (!context_wrapper)
     return;
 
   if (skip_service_worker == SkipServiceWorker::ALL)
     return;
 
   if (!initiated_in_secure_context)
     return;
 
-  if (ServiceWorkerUtils::IsMainResourceType(resource_type))
+  // ServiceWorkerUtils::IsMainResource doesn't consider all worker types to
+  // be main resources. This code shouldn't handle any main resource requests
+  // though, so explicitly exclude the extra worker types.
+  if (ServiceWorkerUtils::IsMainResourceType(resource_type) ||
+      resource_type == RESOURCE_TYPE_WORKER ||
+      resource_type == RESOURCE_TYPE_SERVICE_WORKER)
     return;
 
   if (request->initiator().has_value() &&
       request->initiator()->IsSameOriginWith(url::Origin(request->url()))) {
     return;
   }
 
+  ServiceWorkerProviderHost* provider_host =
+      context_wrapper->context()->GetProviderHost(process_id, provider_id);
+  if (!provider_host || !provider_host->IsContextAlive())
+    return;
+
+  base::Optional<base::TimeDelta> timeout;
+  if (provider_host->IsHostToRunningServiceWorker()) {
+    timeout = base::make_optional(
+        provider_host->running_hosted_version()->remaining_timeout());
+  }
+
   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(
       new ForeignFetchRequestHandler(
           context_wrapper, blob_storage_context->AsWeakPtr(), request_mode,
           credentials_mode, redirect_mode, resource_type, request_context_type,
-          frame_type, body));
+          frame_type, body, timeout));
   request->SetUserData(&kUserDataKey, handler.release());
 }
 
 ForeignFetchRequestHandler* ForeignFetchRequestHandler::GetHandler(
     net::URLRequest* request) {
   return static_cast<ForeignFetchRequestHandler*>(
       request->GetUserData(&kUserDataKey));
 }
 
 std::unique_ptr<net::URLRequestInterceptor>
@@ skipping 32 matching lines @@
     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_,
-      ServiceWorkerFetchType::FOREIGN_FETCH, this);
+      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,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
-    scoped_refptr<ResourceRequestBodyImpl> body)
+    scoped_refptr<ResourceRequestBodyImpl> 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),
       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) {
   if (!job || job.get() != job_.get()) {
     // No more job to handle, or job changed somehow, so just return.
     return;
   }
@@ skipping 78 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