Keep alive ServiceWorkers when devtools is attached

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 "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/message_port_message_filter.h"
@@ skipping 95 matching lines @@
     const GURL& script_url,
     int64 version_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : version_id_(version_id),
       registration_id_(kInvalidServiceWorkerVersionId),
       script_url_(script_url),
       status_(NEW),
       context_(context),
       script_cache_map_(this, context),
       is_doomed_(false),
+      keep_alive_mode_(context->keep_alive_mode()),
       weak_factory_(this) {
   DCHECK(context_);
   DCHECK(registration);
   if (registration) {
     registration_id_ = registration->id();
     scope_ = registration->pattern();
   }
   context_->AddLiveVersion(this);
   embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
   embedded_worker_->AddListener(this);
 }
 
 ServiceWorkerVersion::~ServiceWorkerVersion() {
   embedded_worker_->RemoveListener(this);
   if (context_)
     context_->RemoveLiveVersion(version_id_);
   // EmbeddedWorker's dtor sends StopWorker if it's still running.
 }
 
 void ServiceWorkerVersion::SetStatus(Status status) {
   if (status_ == status)
     return;
 
-  // Schedule to stop worker after registration successfully completed.
-  if (status_ == ACTIVATING && status == ACTIVATED && !HasControllee())
-    ScheduleStopWorker();
-
   status_ = status;
 
   std::vector<base::Closure> callbacks;
   callbacks.swap(status_change_callbacks_);
   for (const auto& callback : callbacks)
     callback.Run();
 
   FOR_EACH_OBSERVER(Listener, listeners_, OnVersionStateChanged(this));
 }
 
@@ skipping 372 matching lines @@
 }
 
 void ServiceWorkerVersion::Doom() {
   if (is_doomed_)
     return;
   is_doomed_ = true;
   if (!HasControllee())
     DoomInternal();
 }
 
+void ServiceWorkerVersion::SetKeepAliveMode(bool keep_alive) {
+  keep_alive_mode_ = keep_alive;
+
+  if (keep_alive_mode_)
+    CancelStopWorker();
+  else
+    ScheduleStopWorker();
+}
+
 void ServiceWorkerVersion::OnStarted() {
   DCHECK_EQ(RUNNING, running_status());
   DCHECK(cache_listener_.get());
-  if (status() == ACTIVATED && !HasControllee())
-    ScheduleStopWorker();
+  ScheduleStopWorker();
   // Fire all start callbacks.
   RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK);
   FOR_EACH_OBSERVER(Listener, listeners_, OnWorkerStarted(this));
 }
 
 void ServiceWorkerVersion::OnStopped(
     EmbeddedWorkerInstance::Status old_status) {
   DCHECK_EQ(STOPPED, running_status());
   scoped_refptr<ServiceWorkerVersion> protect(this);
 
@@ skipping 289 matching lines @@
   ServiceWorkerProviderHost* provider_host =
       controllee_by_id_.Lookup(client_id);
   if (!provider_host) {
     // The client may already have been closed, just ignore.
     return;
   }
   provider_host->PostMessage(message, sent_message_port_ids);
 }
 
 void ServiceWorkerVersion::ScheduleStopWorker() {
-  if (running_status() != RUNNING)
+  if (running_status() != RUNNING ||
+      HasControllee() ||

[falken, 2014/12/08 02:30:16]

My first reaction was we should still stop the worker even if there's a
controllee, but code inspection shows we currently try to not do that. That's
surprising because empirically a SW seems to get killed every 30 seconds even
with an controllee. So I'm not sure what the current behavior is now...

+      keep_alive_mode_) {
     return;
+  }
   if (stop_worker_timer_.IsRunning()) {
     stop_worker_timer_.Reset();
     return;
   }
   stop_worker_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kStopWorkerDelay),
-      base::Bind(&ServiceWorkerVersion::StopWorker,
-                 weak_factory_.GetWeakPtr(),
-                 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)));
+      base::Bind(&ServiceWorkerVersion::MaybeStopWorker,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void ServiceWorkerVersion::CancelStopWorker() {
+  if (stop_worker_timer_.IsRunning())
+    stop_worker_timer_.Stop();
+}
+
+void ServiceWorkerVersion::MaybeStopWorker() {
+  // Reschedule the stop the worker while there're inflight requests.
+  // (Note: we'll probably need to revisit this so that we can kill 'bad' SW.
+  // See https://github.com/slightlyoff/ServiceWorker/issues/527)
+  if (HasInflightRequests()) {
+    ScheduleStopWorker();
+    return;
+  }
+  StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+}
+
+bool ServiceWorkerVersion::HasInflightRequests() const {
+  return
+    !activate_callbacks_.IsEmpty() ||
+    !install_callbacks_.IsEmpty() ||
+    !fetch_callbacks_.IsEmpty() ||
+    !sync_callbacks_.IsEmpty() ||
+    !notification_click_callbacks_.IsEmpty() ||
+    !push_callbacks_.IsEmpty() ||
+    !geofencing_callbacks_.IsEmpty();
 }
 
 void ServiceWorkerVersion::DoomInternal() {
   DCHECK(!HasControllee());
   SetStatus(REDUNDANT);
   StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
 }  // namespace content