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() {
+  SetPhase(ABORT);
+  Complete(SERVICE_WORKER_ERROR_ABORT);
+}
+
 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 208 matching lines @@
     Complete(status);
     return;
   }
   context_->storage()->UpdateToActiveState(
       registration(),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   Complete(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerRegisterJob::Complete(ServiceWorkerStatusCode status) {
-  SetPhase(COMPLETE);
+  if (phase_ != ABORT)
+    SetPhase(COMPLETE);
   if (status != SERVICE_WORKER_OK) {
     if (registration() && registration()->waiting_version()) {
       DisassociateWaitingVersionFromDocuments(
           context_, registration()->waiting_version()->version_id());
       registration()->set_waiting_version(NULL);
     }
     if (registration() && !registration()->active_version()) {
       context_->storage()->DeleteRegistration(
           registration()->id(),
           registration()->script_url().GetOrigin(),
           base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
     }
     if (!is_promise_resolved_)
       ResolvePromise(status, NULL, NULL);
   }
   DCHECK(callbacks_.empty());
   if (registration()) {
     context_->storage()->NotifyDoneInstallingRegistration(
         registration(), pending_version(), status);
   }
-  context_->job_coordinator()->FinishJob(pattern_, this);
+  // The caller of Abort() takes care of removing the jobs from the queue.
+  if (phase_ != ABORT)
+    context_->job_coordinator()->FinishJob(pattern_, this);
 }
 
 void ServiceWorkerRegisterJob::ResolvePromise(
     ServiceWorkerStatusCode status,
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version) {
   DCHECK(!is_promise_resolved_);
   is_promise_resolved_ = true;
   promise_resolved_status_ = status;
   promise_resolved_registration_ = registration;
@@ skipping 51 matching lines @@
     if (!host->IsContextAlive())
       continue;
     if (host->waiting_version() &&
         host->waiting_version()->version_id() == version_id) {
       host->SetWaitingVersion(NULL);
     }
   }
 }
 
 }  // namespace content