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

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 39 matching lines @@
 #include "mojo/common/common_type_converters.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 
 namespace content {
 
 using StatusCallback = ServiceWorkerVersion::StatusCallback;
 
 namespace {
 
-// Time to wait until stopping an idle worker.
-const int kIdleWorkerTimeoutSeconds = 30;
-
 // Default delay for scheduled update.
 const int kUpdateDelaySeconds = 1;
 
 // Timeout for waiting for a response to a ping.
 const int kPingTimeoutSeconds = 30;
 
 const char kClaimClientsStateErrorMesage[] =
     "Only the active worker can claim clients.";
 
 const char kClaimClientsShutdownErrorMesage[] =
@@ skipping 106 matching lines @@
   return trace_id;
 }
 
 }  // namespace
 
 const int ServiceWorkerVersion::kTimeoutTimerDelaySeconds = 30;
 const int ServiceWorkerVersion::kStartInstalledWorkerTimeoutSeconds = 60;
 const int ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kStopWorkerTimeoutSeconds = 5;
+const int ServiceWorkerVersion::kIdleWorkerTimeoutSeconds = 30;
 
 void ServiceWorkerVersion::RestartTick(base::TimeTicks* time) const {
   *time = tick_clock_->NowTicks();
 }
 
 bool ServiceWorkerVersion::RequestExpired(
     const base::TimeTicks& expiration) const {
   if (expiration.is_null())
     return false;
   return tick_clock_->NowTicks() >= expiration;
@@ skipping 366 matching lines @@
 
   int request_id = pending_requests_.Add(base::MakeUnique<PendingRequest>(
       error_callback, base::Time::Now(), tick_clock_->NowTicks(), event_type));
   TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker", "ServiceWorkerVersion::Request",
                            pending_requests_.Lookup(request_id), "Request id",
                            request_id, "Event type",
                            ServiceWorkerMetrics::EventTypeToString(event_type));
   base::TimeTicks expiration_time = tick_clock_->NowTicks() + timeout;
   timeout_queue_.push(
       RequestInfo(request_id, event_type, expiration_time, timeout_behavior));
+  if (expiration_time > max_request_expiration_time_)
+    max_request_expiration_time_ = expiration_time;

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

It seems we never reset max to an earlier time (e.g., when this requests
finishes), so this is really an upper bound on the expiration time of all
outstanding requests. Maybe the comment suggested above should be more precise
then.

   return request_id;
 }
 
 bool ServiceWorkerVersion::StartExternalRequest(
     const std::string& request_uuid) {
   // It's possible that the renderer is lying or the version started stopping
   // right around the time of the IPC.
   if (running_status() != EmbeddedWorkerStatus::RUNNING)
     return false;
 
@@ skipping 1302 matching lines @@
 
 void ServiceWorkerVersion::CleanUpExternalRequest(
     const std::string& request_uuid,
     ServiceWorkerStatusCode status) {
   if (status == SERVICE_WORKER_OK)
     return;
   external_request_uuid_to_request_id_.erase(request_uuid);
 }
 
 }  // namespace content