Implement a poor man's PostAfterStartupTask() function.

content/browser/service_worker/service_worker_register_job.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_register_job.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
+#include "base/rand_util.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/public/browser/browser_main_runner.h"
 #include "net/base/net_errors.h"
 
 namespace content {
 
 namespace {
 
 void RunSoon(const base::Closure& closure) {
   base::MessageLoop::current()->PostTask(FROM_HERE, closure);
 }
 
@@ skipping 48 matching lines @@
       provider_host->AddScopedProcessReferenceToPattern(pattern_);
     return;
   }
   RunSoon(base::Bind(callback, promise_resolved_status_,
                      promise_resolved_status_message_,
                      promise_resolved_registration_));
 }
 
 void ServiceWorkerRegisterJob::Start() {
   SetPhase(START);
+
+  if (IsBrowserStartingUp()) {
+    // Delay running update jobs until after startup.
+    delayed_start_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromSeconds(base::RandInt(5, 15)),
+        base::Bind(&ServiceWorkerRegisterJob::Restart,
+                   weak_factory_.GetWeakPtr()));
+    return;
+  }
+
   ServiceWorkerStorage::FindRegistrationCallback next_step;
   if (job_type_ == REGISTRATION_JOB) {
     next_step = base::Bind(
         &ServiceWorkerRegisterJob::ContinueWithRegistration,
         weak_factory_.GetWeakPtr());
   } else {
     next_step = base::Bind(
         &ServiceWorkerRegisterJob::ContinueWithUpdate,
         weak_factory_.GetWeakPtr());
   }
@@ skipping 77 matching lines @@
     case INSTALL:
       DCHECK(phase_ == UPDATE) << phase_;
       break;
     case STORE:
       DCHECK(phase_ == INSTALL) << phase_;
       break;
     case COMPLETE:
       DCHECK(phase_ != INITIAL && phase_ != COMPLETE) << phase_;
       break;
     case ABORT:
+      delayed_start_timer_.Stop();
       break;
   }
   phase_ = phase;
 }
 
+void ServiceWorkerRegisterJob::Restart() {
+  DCHECK(phase_ == START) << phase_;

[cmumford, 2015/02/26 23:47:45]

DCHECK_EQ.

Also, couldn't you get here before START if startup was slow?

+  phase_ = INITIAL;
+  Start();
+}
+
 // This function corresponds to the steps in [[Register]] following
 // "Let registration be the result of running the [[GetRegistration]] algorithm.
 // Throughout this file, comments in quotes are excerpts from the spec.
 void ServiceWorkerRegisterJob::ContinueWithRegistration(
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& existing_registration) {
   DCHECK_EQ(REGISTRATION_JOB, job_type_);
   if (status != SERVICE_WORKER_ERROR_NOT_FOUND && status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
@@ skipping 360 matching lines @@
     ServiceWorkerProviderHost* host = it->GetProviderHost();
     if (ServiceWorkerUtils::ScopeMatches(registration->pattern(),
                                          host->document_url())) {
       if (host->CanAssociateRegistration(registration))
         host->AssociateRegistration(registration);
     }
   }
 }
 
 }  // namespace content