Service Worker: Remove legacy code for resolving register() to a version

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 51 matching lines @@
 void ServiceWorkerRegisterJob::AddCallback(
     const RegistrationCallback& callback,
     ServiceWorkerProviderHost* provider_host) {
   if (!is_promise_resolved_) {
     callbacks_.push_back(callback);
     if (provider_host)
       provider_host->AddScopedProcessReferenceToPattern(pattern_);
     return;
   }
   RunSoon(base::Bind(
-      callback, promise_resolved_status_,
-      promise_resolved_registration_, promise_resolved_version_));
+      callback, promise_resolved_status_, promise_resolved_registration_));
 }
 
 void ServiceWorkerRegisterJob::Start() {
   SetPhase(START);
   ServiceWorkerStorage::FindRegistrationCallback next_step;
   if (job_type_ == REGISTRATION_JOB) {
     next_step = base::Bind(
         &ServiceWorkerRegisterJob::ContinueWithRegistration,
         weak_factory_.GetWeakPtr());
   } else {
@@ skipping 201 matching lines @@
 
 void ServiceWorkerRegisterJob::ContinueWithRegistrationForSameScriptUrl(
     const scoped_refptr<ServiceWorkerRegistration>& existing_registration,
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
   set_registration(existing_registration);
 
-  // TODO(falken): Follow the spec: resolve the promise
-  // with the newest version.
-
-  if (!existing_registration->active_version()) {
-    UpdateAndContinue();
+  // "If newestWorker is not null, and scriptURL is equal to
+  // newestWorker.scriptURL, then:
+  // Return a promise resolved with registration."
+  // We resolve only if there's an active version. If there's not,
+  // then there is either no version or only a waiting version from
+  // the last browser session; it makes sense to proceed with registration in
+  // either case.
+  DCHECK(!existing_registration->installing_version());
+  if (existing_registration->active_version()) {
+    ResolvePromise(status, existing_registration.get());
+    Complete(SERVICE_WORKER_OK);
     return;
   }
 
-  ResolvePromise(status,
-                 existing_registration.get(),
-                 existing_registration->active_version());
-  Complete(SERVICE_WORKER_OK);
+  // "Return the result of running the [[Update]] algorithm, or its equivalent,
+  // passing registration as the argument."
+  UpdateAndContinue();
 }
 
 // This function corresponds to the spec's [[Update]] algorithm.
 void ServiceWorkerRegisterJob::UpdateAndContinue() {
   SetPhase(UPDATE);
   context_->storage()->NotifyInstallingRegistration(registration());
 
-  // TODO(falken): "If serviceWorkerRegistration.installingWorker is not null.."
-  // then terminate the installing worker. It doesn't make sense to implement
-  // yet since we always activate the worker if install completed, so there can
-  // be no installing worker at this point.
-
-  // "Let serviceWorker be a newly-created ServiceWorker object..." and start
+  // "Let worker be a new ServiceWorker object..." and start
   // the worker.
   set_new_version(new ServiceWorkerVersion(registration(),
                                            script_url_,
                                            context_->storage()->NewVersionId(),
                                            context_));
 
   bool pause_after_download = job_type_ == UPDATE_JOB;
   if (pause_after_download)
     new_version()->embedded_worker()->AddListener(this);
   new_version()->StartWorker(
@@ skipping 31 matching lines @@
     }
   }
   Complete(status);
 }
 
 // This function corresponds to the spec's [[Install]] algorithm.
 void ServiceWorkerRegisterJob::InstallAndContinue() {
   SetPhase(INSTALL);
 
   // "2. Set registration.installingWorker to worker."
+  DCHECK(!registration()->installing_version());
   registration()->SetInstallingVersion(new_version());
 
   // "3. Resolve promise with registration."
-  ResolvePromise(SERVICE_WORKER_OK, registration(), new_version());
+  ResolvePromise(SERVICE_WORKER_OK, registration());
 
   // "4. Run the [[UpdateState]] algorithm passing registration.installingWorker
   // and "installing" as the arguments."
   new_version()->SetStatus(ServiceWorkerVersion::INSTALLING);
 
   // "5. Fire a simple event named updatefound..."
   registration()->NotifyUpdateFound();
 
   // "6. Fire an event named install..."
   new_version()->DispatchInstallEvent(
@@ skipping 70 matching lines @@
       if (!registration()->waiting_version() &&
           !registration()->active_version()) {
         registration()->NotifyRegistrationFailed();
         context_->storage()->DeleteRegistration(
             registration()->id(),
             registration()->pattern().GetOrigin(),
             base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
       }
     }
     if (!is_promise_resolved_)
-      ResolvePromise(status, NULL, NULL);
+      ResolvePromise(status, NULL);
   }
   DCHECK(callbacks_.empty());
   if (registration()) {
     context_->storage()->NotifyDoneInstallingRegistration(
         registration(), new_version(), status);
   }
   if (new_version())
     new_version()->embedded_worker()->RemoveListener(this);
 }
 
 void ServiceWorkerRegisterJob::ResolvePromise(
     ServiceWorkerStatusCode status,
-    ServiceWorkerRegistration* registration,
-    ServiceWorkerVersion* version) {
+    ServiceWorkerRegistration* registration) {
   DCHECK(!is_promise_resolved_);
   is_promise_resolved_ = true;
   promise_resolved_status_ = status;
   promise_resolved_registration_ = registration;
-  promise_resolved_version_ = version;
   for (std::vector<RegistrationCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end();
        ++it) {
-    it->Run(status, registration, version);
+    it->Run(status, registration);
   }
   callbacks_.clear();
 }
 
 void ServiceWorkerRegisterJob::OnPausedAfterDownload() {
   // This happens prior to OnStartWorkerFinished time.
   scoped_refptr<ServiceWorkerVersion> most_recent_version =
       registration()->waiting_version() ?
           registration()->waiting_version() :
           registration()->active_version();
   DCHECK(most_recent_version.get());
   int64 most_recent_script_id =
       most_recent_version->script_cache_map()->Lookup(script_url_);
   int64 new_script_id =
       new_version()->script_cache_map()->Lookup(script_url_);
 
   // TODO(michaeln): It would be better to compare as the new resource
   // is being downloaded and to avoid writing it to disk until we know
   // its needed.
   context_->storage()->CompareScriptResources(
-      most_recent_script_id, new_script_id,
+      most_recent_script_id,
+      new_script_id,
       base::Bind(&ServiceWorkerRegisterJob::OnCompareScriptResourcesComplete,
-                 weak_factory_.GetWeakPtr(),
-                 most_recent_version));
+                 weak_factory_.GetWeakPtr()));
 }
 
 bool ServiceWorkerRegisterJob::OnMessageReceived(const IPC::Message& message) {
   return false;
 }
 
 void ServiceWorkerRegisterJob::OnRegistrationFinishedUninstalling(
     ServiceWorkerRegistration* existing_registration) {
   DCHECK_EQ(phase_, WAIT_FOR_UNINSTALL);
   DCHECK_EQ(existing_registration, uninstalling_registration());
   existing_registration->RemoveListener(this);
   set_uninstalling_registration(NULL);
   RegisterAndContinue(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerRegisterJob::OnCompareScriptResourcesComplete(
-    ServiceWorkerVersion* most_recent_version,
     ServiceWorkerStatusCode status,
     bool are_equal) {
   if (are_equal) {
     // Only bump the last check time when we've bypassed the browser cache.
     base::TimeDelta time_since_last_check =
         base::Time::Now() - registration()->last_update_check();
     if (time_since_last_check > base::TimeDelta::FromHours(24)) {
       registration()->set_last_update_check(base::Time::Now());
       context_->storage()->UpdateLastUpdateCheckTime(registration());
     }
 
-    ResolvePromise(SERVICE_WORKER_OK, registration(), most_recent_version);
+    ResolvePromise(SERVICE_WORKER_OK, registration());
     Complete(SERVICE_WORKER_ERROR_EXISTS);
     return;
   }
 
   // Proceed with really starting the worker.
   new_version()->embedded_worker()->ResumeAfterDownload();
   new_version()->embedded_worker()->RemoveListener(this);
 }
 
 void ServiceWorkerRegisterJob::AssociateProviderHostsToRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(registration);
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context_->GetProviderHostIterator();
        !it->IsAtEnd(); it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
     if (ServiceWorkerUtils::ScopeMatches(registration->pattern(),
                                          host->document_url())) {
       if (host->CanAssociateRegistration(registration))
         host->AssociateRegistration(registration);
     }
   }
 }
 
 }  // namespace content