service worker: Avoid starting up for activation during shutdown

content/browser/service_worker/service_worker_registration.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_registration.h"
 
 #include <vector>
 
 #include "content/browser/service_worker/service_worker_context_core.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
@@ skipping 10 matching lines @@
     const GURL& pattern,
     int64_t registration_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : pattern_(pattern),
       registration_id_(registration_id),
       is_deleted_(false),
       is_uninstalling_(false),
       is_uninstalled_(false),
       should_activate_when_ready_(false),
       resources_total_size_bytes_(0),
-      context_(context) {
+      context_(context),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
   DCHECK(context_);
   context_->AddLiveRegistration(this);
 }
 
 ServiceWorkerRegistration::~ServiceWorkerRegistration() {
+  // Can be false during shutdown, in which case the DCHECK_CURRENTLY_ON below
+  // would cry.
+  if (!BrowserThread::IsThreadInitialized(BrowserThread::IO))
+    return;
+
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!listeners_.might_have_observers());
   if (context_)
     context_->RemoveLiveRegistration(registration_id_);
   if (active_version())
     active_version()->RemoveListener(this);
 }
 
 ServiceWorkerVersion* ServiceWorkerRegistration::GetNewestVersion() const {
   if (installing_version())
@@ skipping 111 matching lines @@
     active_version_ = NULL;
     mask->add(ChangedVersionAttributesMask::ACTIVE_VERSION);
   }
 }
 
 void ServiceWorkerRegistration::ActivateWaitingVersionWhenReady() {
   DCHECK(waiting_version());
   should_activate_when_ready_ = true;
 
   if (!active_version() || !active_version()->HasControllee() ||
-      waiting_version()->skip_waiting())
-    ActivateWaitingVersion();
+      waiting_version()->skip_waiting()) {
+    ActivateWaitingVersion(false);
+  }
 }
 
 void ServiceWorkerRegistration::ClaimClients() {
   DCHECK(context_);
   DCHECK(active_version());
 
   for (std::unique_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context_->GetProviderHostIterator();
        !it->IsAtEnd(); it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
@@ skipping 45 matching lines @@
                  most_recent_version));
 }
 
 void ServiceWorkerRegistration::OnNoControllees(ServiceWorkerVersion* version) {
   if (!context_)
     return;
   DCHECK_EQ(active_version(), version);
   if (is_uninstalling_)
     Clear();
   else if (should_activate_when_ready_)
-    ActivateWaitingVersion();
+    ActivateWaitingVersion(true);
   is_uninstalling_ = false;
   should_activate_when_ready_ = false;
 }
 
-void ServiceWorkerRegistration::ActivateWaitingVersion() {
+void ServiceWorkerRegistration::ActivateWaitingVersion(bool delay) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(context_);
   DCHECK(waiting_version());
   DCHECK(should_activate_when_ready_);
   should_activate_when_ready_ = false;
   scoped_refptr<ServiceWorkerVersion> activating_version = waiting_version();
   scoped_refptr<ServiceWorkerVersion> exiting_version = active_version();
 
   if (activating_version->is_redundant())
     return;  // Activation is no longer relevant.
 
@@ skipping 14 matching lines @@
   SetActiveVersion(activating_version);
 
   // "8. Run the [[UpdateState]] algorithm passing registration.activeWorker and
   // "activating" as arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATING);
   // "9. Fire a simple event named controllerchange..."
   if (activating_version->skip_waiting())
     FOR_EACH_OBSERVER(Listener, listeners_, OnSkippedWaiting(this));
 
   // "10. Queue a task to fire an event named activate..."
+  // The browser could be shutting down. To avoid spurious start worker
+  // failures, wait a bit before continuing.
+  if (delay) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&ServiceWorkerRegistration::ContinueActivation,
+                              this, activating_version),
+        base::TimeDelta::FromSeconds(1));
+  } else {
+    ContinueActivation(std::move(activating_version));
+  }
+}
+
+void ServiceWorkerRegistration::ContinueActivation(
+    scoped_refptr<ServiceWorkerVersion> activating_version) {
+  if (!context_)
+    return;
+  if (active_version() != activating_version.get())
+    return;
+  DCHECK_EQ(ServiceWorkerVersion::ACTIVATING, activating_version->status());
   activating_version->RunAfterStartWorker(
       ServiceWorkerMetrics::EventType::ACTIVATE,
       base::Bind(&ServiceWorkerRegistration::DispatchActivateEvent, this,
                  activating_version),
       base::Bind(&ServiceWorkerRegistration::OnActivateEventFinished, this,
                  activating_version));
 }
 
 void ServiceWorkerRegistration::DeleteVersion(
     const scoped_refptr<ServiceWorkerVersion>& version) {
@@ skipping 28 matching lines @@
   }
 }
 
 void ServiceWorkerRegistration::NotifyRegistrationFinished() {
   std::vector<base::Closure> callbacks;
   callbacks.swap(registration_finished_callbacks_);
   for (const auto& callback : callbacks)
     callback.Run();
 }
 
+void ServiceWorkerRegistration::SetTaskRunnerForTest(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  task_runner_ = task_runner;
+}
+
 void ServiceWorkerRegistration::RegisterRegistrationFinishedCallback(
     const base::Closure& callback) {
   // This should only be called if the registration is in progress.
   DCHECK(!active_version() && !waiting_version() && !is_uninstalled() &&
          !is_uninstalling());
   registration_finished_callbacks_.push_back(callback);
 }
 
 void ServiceWorkerRegistration::DispatchActivateEvent(
-    const scoped_refptr<ServiceWorkerVersion>& activating_version) {
+    scoped_refptr<ServiceWorkerVersion> activating_version) {
   if (activating_version != active_version()) {
     OnActivateEventFinished(activating_version, SERVICE_WORKER_ERROR_FAILED);
     return;
   }
 
   DCHECK_EQ(ServiceWorkerVersion::ACTIVATING, activating_version->status());
   DCHECK_EQ(ServiceWorkerVersion::RUNNING, activating_version->running_status())
       << "Worker stopped too soon after it was started.";
   int request_id = activating_version->StartRequest(
       ServiceWorkerMetrics::EventType::ACTIVATE,
       base::Bind(&ServiceWorkerRegistration::OnActivateEventFinished, this,
                  activating_version));
   activating_version
       ->DispatchSimpleEvent<ServiceWorkerHostMsg_ActivateEventFinished>(
           request_id, ServiceWorkerMsg_ActivateEvent(request_id));
 }
 
 void ServiceWorkerRegistration::OnActivateEventFinished(
-    const scoped_refptr<ServiceWorkerVersion>& activating_version,
+    scoped_refptr<ServiceWorkerVersion> activating_version,
     ServiceWorkerStatusCode status) {
+  // Activate is prone to failing due to shutdown, because it's triggered when
+  // tabs close.
+  bool is_shutdown =
+      !context_ || context_->wrapper()->process_manager()->IsShutdown();
+  ServiceWorkerMetrics::RecordActivateEventStatus(status, is_shutdown);
+
   if (!context_ || activating_version != active_version() ||
-      activating_version->status() != ServiceWorkerVersion::ACTIVATING)
+      activating_version->status() != ServiceWorkerVersion::ACTIVATING) {
     return;
+  }
 
-  // |status| is just for UMA. Once we've attempted to dispatch the activate
-  // event to an installed worker, it's committed to becoming active.
-  ServiceWorkerMetrics::RecordActivateEventStatus(status);
+  // Normally, the worker is committed to become activated once we get here, per
+  // spec. E.g., if the script rejected waitUntil or had an unhandled exception,
+  // it should still be activated. However, if the failure occurred during
+  // shutdown, ignore it to give the worker another chance the next time the
+  // browser starts up.
+  if (is_shutdown && status != SERVICE_WORKER_OK)
+    return;
 
   // "Run the Update State algorithm passing registration's active worker and
   // 'activated' as the arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATED);
   context_->storage()->UpdateToActiveState(
       this, base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 void ServiceWorkerRegistration::OnDeleteFinished(
     ServiceWorkerStatusCode status) {
@@ skipping 47 matching lines @@
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
   callback.Run(status);
 }
 
 }  // namespace content