Prevent a service worker from keeping itself alive by self postMessage.

content/browser/service_worker/service_worker_dispatcher_host.cc

 // Copyright 2013 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_dispatcher_host.h"
 
 #include <utility>
 
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
@@ skipping 903 matching lines @@
   switch (sender_provider_host->provider_type()) {
     case SERVICE_WORKER_PROVIDER_FOR_WINDOW:
     case SERVICE_WORKER_PROVIDER_FOR_WORKER:
     case SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER:
       service_worker_client_utils::GetClient(
           sender_provider_host,
           base::Bind(&ServiceWorkerDispatcherHost::
                          DispatchExtendableMessageEventInternal<
                              ServiceWorkerClientInfo>,
                      this, worker, message, source_origin, sent_message_ports,
-                     callback));
+                     callback, base::nullopt));
       break;
-    case SERVICE_WORKER_PROVIDER_FOR_CONTROLLER:
+    case SERVICE_WORKER_PROVIDER_FOR_CONTROLLER: {

[falken, 2016/11/21 08:01:48]

nit: maybe add some comment like "Clamp timeout to the sending worker's, to
prevent postMessage from keeping workers alive forever."

[Marijn Kruisselbrink, 2016/12/01 19:54:30]

Done

+      base::TimeDelta timeout =
+          sender_provider_host->running_hosted_version()->remaining_timeout();
       RunSoon(base::Bind(
           &ServiceWorkerDispatcherHost::DispatchExtendableMessageEventInternal<
               ServiceWorkerObjectInfo>,
           this, worker, message, source_origin, sent_message_ports, callback,
+          base::make_optional(timeout),
           sender_provider_host->GetOrCreateServiceWorkerHandle(
               sender_provider_host->running_hosted_version())));
       break;
+    }
     case SERVICE_WORKER_PROVIDER_UNKNOWN:
     default:
       NOTREACHED() << sender_provider_host->provider_type();
       break;
   }
 }
 
 void ServiceWorkerDispatcherHost::OnProviderCreated(
     int provider_id,
     int route_id,
@@ skipping 134 matching lines @@
                                                   provider_id, info, attrs));
 }
 
 template <typename SourceInfo>
 void ServiceWorkerDispatcherHost::DispatchExtendableMessageEventInternal(
     scoped_refptr<ServiceWorkerVersion> worker,
     const base::string16& message,
     const url::Origin& source_origin,
     const std::vector<int>& sent_message_ports,
     const StatusCallback& callback,
+    const base::Optional<base::TimeDelta>& timeout,
     const SourceInfo& source_info) {
   if (!source_info.IsValid()) {
     DidFailToDispatchExtendableMessageEvent<SourceInfo>(
         sent_message_ports, source_info, callback, SERVICE_WORKER_ERROR_FAILED);
     return;
   }
+
+  // If not enough time is left to actually process the event don't even
+  // bother starting the worker and sending the event.
+  if (timeout && *timeout < base::TimeDelta::FromMilliseconds(100)) {
+    DidFailToDispatchExtendableMessageEvent<SourceInfo>(
+        sent_message_ports, source_info, callback, SERVICE_WORKER_ERROR_FAILED);

[falken, 2016/11/21 08:01:48]

Hm, TIMEOUT seems like a better error code here, since if we did barely have
enough time and the worker took longer than 100 ms, we'd get a TIMEOUT error.

[Marijn Kruisselbrink, 2016/12/01 19:54:29]

Good point, done.

+    return;
+  }
+
   worker->RunAfterStartWorker(
       ServiceWorkerMetrics::EventType::MESSAGE,
       base::Bind(&ServiceWorkerDispatcherHost::
                      DispatchExtendableMessageEventAfterStartWorker,
                  this, worker, message, source_origin, sent_message_ports,
-                 ExtendableMessageEventSource(source_info), callback),
+                 ExtendableMessageEventSource(source_info), timeout, callback),
       base::Bind(
           &ServiceWorkerDispatcherHost::DidFailToDispatchExtendableMessageEvent<
               SourceInfo>,
           this, sent_message_ports, source_info, callback));
 }
 
 void ServiceWorkerDispatcherHost::
     DispatchExtendableMessageEventAfterStartWorker(
         scoped_refptr<ServiceWorkerVersion> worker,
         const base::string16& message,
         const url::Origin& source_origin,
         const std::vector<int>& sent_message_ports,
         const ExtendableMessageEventSource& source,
+        const base::Optional<base::TimeDelta>& timeout,
         const StatusCallback& callback) {
-  int request_id =
-      worker->StartRequest(ServiceWorkerMetrics::EventType::MESSAGE, callback);
+  int request_id;
+  if (timeout) {
+    request_id = worker->StartRequestWithCustomTimeout(
+        ServiceWorkerMetrics::EventType::MESSAGE, callback, *timeout,
+        ServiceWorkerVersion::CONTINUE_ON_TIMEOUT);
+  } else {
+    request_id = worker->StartRequest(ServiceWorkerMetrics::EventType::MESSAGE,
+                                      callback);
+  }
 
   MessagePortMessageFilter* filter =
       worker->embedded_worker()->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
 
   ServiceWorkerMsg_ExtendableMessageEvent_Params params;
   params.message = message;
   params.source_origin = source_origin;
   params.message_ports = sent_message_ports;
@@ skipping 530 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content