Evict Service Worker when reading it from disk cache fails.

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 "content/browser/service_worker/service_worker_context_core.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"
@@ skipping 284 matching lines @@
   // "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..."
   activating_version->DispatchActivateEvent(
       base::Bind(&ServiceWorkerRegistration::OnActivateEventFinished,
                  this, activating_version));
 }
 
+void ServiceWorkerRegistration::DeleteVersion(
+    const scoped_refptr<ServiceWorkerVersion>& version) {

[nhiroki, 2015/04/27 04:24:25]

ServiceWorkerRegisterJob::CompleteInternal seems to have a similar logic. Are we
able to replace it with this function and make UnsetVersion() private?

[falken, 2015/04/27 04:58:16]

Yes good point, these are pretty similar. I'll see about refactoring when I
simplify DeleteVersion(), it's following some steps from the old spec that can
be removed.

+  DCHECK_EQ(id(), version->registration_id());
+
+  // "Set registration's active worker to null." (The spec's step order may
+  // differ. It's OK because the other steps queue a task.)
+  UnsetVersion(version.get());
+
+  // "Run the Update State algorithm passing registration's active worker and
+  // 'redundant' as the arguments."
+  version->SetStatus(ServiceWorkerVersion::REDUNDANT);
+
+  // "For each service worker client client whose active worker is
+  // registration's active worker..." set the active worker to null.
+  for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
+           context_->GetProviderHostIterator();
+       !it->IsAtEnd(); it->Advance()) {
+    ServiceWorkerProviderHost* host = it->GetProviderHost();
+    if (host->controlling_version() == version)
+      host->NotifyControllerActivationFailed();
+  }
+
+  version->Doom();
+
+  if (!active_version() && !waiting_version()) {
+    // Delete the records from the db.
+    context_->storage()->DeleteRegistration(
+        id(), pattern().GetOrigin(),
+        base::Bind(&ServiceWorkerRegistration::OnDeleteFinished, this));
+    // But not from memory if there is a version in the pipeline.
+    if (installing_version()) {
+      is_deleted_ = false;
+    } else {
+      is_uninstalled_ = true;
+      FOR_EACH_OBSERVER(Listener, listeners_, OnRegistrationFailed(this));
+    }
+  }
+}
+
 void ServiceWorkerRegistration::OnActivateEventFinished(
     ServiceWorkerVersion* activating_version,
     ServiceWorkerStatusCode status) {
   if (!context_ || activating_version != active_version())
     return;
   ServiceWorkerMetrics::RecordActivateEventStatus(status);
 
   // "If activateFailed is true, then:..."
   if (status != SERVICE_WORKER_OK) {
-    // "Set registration's active worker to null." (The spec's step order may
-    // differ. It's OK because the other steps queue a task.)
-    UnsetVersion(activating_version);
-
-    // "Run the Update State algorithm passing registration's active worker and
-    // 'redundant' as the arguments."
-    activating_version->SetStatus(ServiceWorkerVersion::REDUNDANT);
-
-    // "For each service worker client client whose active worker is
-    // registration's active worker..." set the active worker to null.
-    for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
-             context_->GetProviderHostIterator();
-         !it->IsAtEnd(); it->Advance()) {
-      ServiceWorkerProviderHost* host = it->GetProviderHost();
-      if (host->controlling_version() == activating_version)
-        host->NotifyControllerActivationFailed();
-    }
-
-    activating_version->Doom();
-    if (!waiting_version()) {
-      // Delete the records from the db.
-      context_->storage()->DeleteRegistration(
-          id(), pattern().GetOrigin(),
-          base::Bind(&ServiceWorkerRegistration::OnDeleteFinished, this));
-      // But not from memory if there is a version in the pipeline.
-      if (installing_version()) {
-        is_deleted_ = false;
-      } else {
-        is_uninstalled_ = true;
-        FOR_EACH_OBSERVER(Listener, listeners_, OnRegistrationFailed(this));
-      }
-    }
+    DeleteVersion(make_scoped_refptr(activating_version));
     return;
   }
 
   // "Run the Update State algorithm passing registration's active worker and
   // 'activated' as the arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATED);
   if (context_) {
     context_->storage()->UpdateToActiveState(
         this,
         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
@@ skipping 46 matching lines @@
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
   callback.Run(status);
 }
 
 }  // namespace content