ServiceWorker: Add a function to abort all pending jobs in SWJobCoordinator

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 "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 20 matching lines @@
     const GURL& script_url)
     : context_(context),
       pattern_(pattern),
       script_url_(script_url),
       phase_(INITIAL),
       is_promise_resolved_(false),
       promise_resolved_status_(SERVICE_WORKER_OK),
       weak_factory_(this) {}
 
 ServiceWorkerRegisterJob::~ServiceWorkerRegisterJob() {
-  DCHECK(!context_ || phase_ == INITIAL || phase_ == COMPLETE)
+  DCHECK(!context_ ||
+         phase_ == INITIAL || phase_ == COMPLETE || phase_ == ABORT)
       << "Jobs should only be interrupted during shutdown.";
 }
 
 void ServiceWorkerRegisterJob::AddCallback(const RegistrationCallback& callback,
                                            int process_id) {
   if (!is_promise_resolved_) {
     callbacks_.push_back(callback);
     if (process_id != -1 && (phase_ < UPDATE || !pending_version()))
       pending_process_ids_.push_back(process_id);
     return;
   }
   RunSoon(base::Bind(
       callback, promise_resolved_status_,
       promise_resolved_registration_, promise_resolved_version_));
 }
 
 void ServiceWorkerRegisterJob::Start() {
   SetPhase(START);
   context_->storage()->FindRegistrationForPattern(
       pattern_,
       base::Bind(
           &ServiceWorkerRegisterJob::HandleExistingRegistrationAndContinue,
           weak_factory_.GetWeakPtr()));
 }
 
+void ServiceWorkerRegisterJob::Abort() {

[michaeln, 2014/06/19 01:12:32]

The Complete() method does cleanup related to not leaving other objects in odd
states (resolving the promise is one of those cleanups). It might make sense to
always go thru the Complete() method to perform that cleanup.

[falken, 2014/06/19 03:45:56]

Yes, looks reasonable to go through Complete with SERVICE_WORKER_ERROR_ABORT
status.

[nhiroki, 2014/06/19 05:05:55]

Hmmm... I noticed this might cause a messy thing... Complete() calls
Coordinator::FinishJob() that deletes elements in JobQueue and JobQueue itself,
that is, JobQueue::AbortAll() indirectly delete itself. Generally speaking,
self-destruction makes difficult to maintain resource lifetime. I'll think about
a better way to share cleanup code and to manage object lifetime simpler.

[nhiroki, 2014/06/19 05:53:09]

Updated. In the latest patchset, Abort() calls only CompleteInternal() and
JobQueue deletes queued jobs on behalf of Coordinator::FinishJob().

+  SetPhase(ABORT);
+  if (!is_promise_resolved_)
+    ResolvePromise(SERVICE_WORKER_ERROR_ABORT, NULL, NULL);
+}
+
 bool ServiceWorkerRegisterJob::Equals(ServiceWorkerRegisterJobBase* job) {
   if (job->GetType() != GetType())
     return false;
   ServiceWorkerRegisterJob* register_job =
       static_cast<ServiceWorkerRegisterJob*>(job);
   return register_job->pattern_ == pattern_ &&
          register_job->script_url_ == script_url_;
 }
 
 RegistrationJobType ServiceWorkerRegisterJob::GetType() {
@@ skipping 47 matching lines @@
       break;
     case STORE:
       DCHECK(phase_ == INSTALL) << phase_;
       break;
     case ACTIVATE:
       DCHECK(phase_ == STORE) << phase_;
       break;
     case COMPLETE:
       DCHECK(phase_ != INITIAL && phase_ != COMPLETE) << phase_;
       break;
+    case ABORT:
+      break;
   }
   phase_ = phase;
 }
 
 // This function corresponds to the steps in Register following
 // "Let serviceWorkerRegistration be _GetRegistration(scope)"
 // |existing_registration| corresponds to serviceWorkerRegistration.
 // Throughout this file, comments in quotes are excerpts from the spec.
 void ServiceWorkerRegisterJob::HandleExistingRegistrationAndContinue(
     ServiceWorkerStatusCode status,
@@ skipping 301 matching lines @@
     if (!host->IsContextAlive())
       continue;
     if (host->waiting_version() &&
         host->waiting_version()->version_id() == version_id) {
       host->SetWaitingVersion(NULL);
     }
   }
 }
 
 }  // namespace content