ServiceWorker: some more groundwork in support of the update process

content/browser/service_worker/service_worker_provider_host.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_provider_host.h"
 
 #include "base/stl_util.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_request_handler.h"
@@ skipping 15 matching lines @@
     : process_id_(process_id),
       provider_id_(provider_id),
       context_(context),
       dispatcher_host_(dispatcher_host) {
 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   if (active_version_)
     active_version_->RemoveControllee(this);
   if (waiting_version_)
-    waiting_version_->RemoveWaitingControllee(this);
+    waiting_version_->RemovePotentialControllee(this);
+  if (installing_version_)
+    installing_version_->RemovePotentialControllee(this);
 }
 
 void ServiceWorkerProviderHost::SetDocumentUrl(const GURL& url) {
   DCHECK(!url.has_ref());
   document_url_ = url;
 }
 
 void ServiceWorkerProviderHost::SetActiveVersion(
     ServiceWorkerVersion* version) {
+  DCHECK(CanAssociateVersion(version));
   if (version == active_version_)
     return;
   scoped_refptr<ServiceWorkerVersion> previous_version = active_version_;
   active_version_ = version;
   if (version)
     version->AddControllee(this);
   if (previous_version)
     previous_version->RemoveControllee(this);
 
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   dispatcher_host_->Send(new ServiceWorkerMsg_SetCurrentServiceWorker(
       kDocumentMainThreadId, provider_id(), CreateHandleAndPass(version)));
 }
 
 void ServiceWorkerProviderHost::SetWaitingVersion(
     ServiceWorkerVersion* version) {
-  DCHECK(ValidateVersionForAssociation(version));
+  DCHECK(CanAssociateVersion(version));
   if (version == waiting_version_)
     return;
   scoped_refptr<ServiceWorkerVersion> previous_version = waiting_version_;
   waiting_version_ = version;
   if (version)
-    version->AddWaitingControllee(this);
+    version->AddPotentialControllee(this);
   if (previous_version)
-    previous_version->RemoveWaitingControllee(this);
+    previous_version->RemovePotentialControllee(this);
 
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   dispatcher_host_->Send(new ServiceWorkerMsg_SetWaitingServiceWorker(
       kDocumentMainThreadId, provider_id(), CreateHandleAndPass(version)));
 }
 
+void ServiceWorkerProviderHost::SetInstallingVersion(
+    ServiceWorkerVersion* version) {
+  DCHECK(CanAssociateVersion(version));
+  if (version == installing_version_)
+    return;
+  scoped_refptr<ServiceWorkerVersion> previous_version = installing_version_;
+  installing_version_ = version;
+  if (version)
+    version->AddPotentialControllee(this);
+  if (previous_version)
+    previous_version->RemovePotentialControllee(this);
+
+  if (!dispatcher_host_)
+    return;  // Could be NULL in some tests.
+
+  // TODO(michaeln): Update once the renderer side understands the .installing
+  // attribute value.
+  dispatcher_host_->Send(new ServiceWorkerMsg_SetWaitingServiceWorker(
+      kDocumentMainThreadId, provider_id(), CreateHandleAndPass(version)));
+}
+
+void ServiceWorkerProviderHost::UnsetVersion(ServiceWorkerVersion* version) {
+  if (!version)
+    return;
+  if (installing_version_ == version)
+    SetInstallingVersion(NULL);
+  else if (waiting_version_  == version)
+    SetWaitingVersion(NULL);
+  else if (active_version_ == version)
+    SetActiveVersion(NULL);
+}
+
 bool ServiceWorkerProviderHost::SetHostedVersionId(int64 version_id) {
   if (!context_)
     return true;  // System is shutting down.
   if (active_version_)
     return false;  // Unexpected bad message.
 
   ServiceWorkerVersion* live_version = context_->GetLiveVersion(version_id);
   if (!live_version)
     return true;  // Was deleted before it got started.
 
@@ skipping 20 matching lines @@
   }
   if (ServiceWorkerUtils::IsMainResourceType(resource_type) ||
       active_version()) {
     return scoped_ptr<ServiceWorkerRequestHandler>(
         new ServiceWorkerControlleeRequestHandler(
             context_, AsWeakPtr(), blob_storage_context, resource_type));
   }
   return scoped_ptr<ServiceWorkerRequestHandler>();
 }
 
-bool ServiceWorkerProviderHost::ValidateVersionForAssociation(
+bool ServiceWorkerProviderHost::CanAssociateVersion(
     ServiceWorkerVersion* version) {
+  if (!context_)
+    return false;
   if (running_hosted_version_)
     return false;
   if (!version)
     return true;
 
-  // A version to be associated with this provider should have the same
-  // registration (scope) as current active/waiting versions.
-  if (active_version_) {
-    if (active_version_->registration_id() != version->registration_id())
-      return false;
-    DCHECK_EQ(active_version_->scope(), version->scope());
-  }
-  if (waiting_version_) {
-    if (waiting_version_->registration_id() != version->registration_id())
-      return false;
-    DCHECK_EQ(waiting_version_->scope(), version->scope());
-  }
-  return true;
+  ServiceWorkerVersion* already_associated_version = NULL;
+  if (active_version_)
+    already_associated_version = active_version_;
+  else if (waiting_version_)
+    already_associated_version = waiting_version_;
+  else if (installing_version_)
+    already_associated_version = installing_version_;
+
+  return !already_associated_version ||
+         already_associated_version->registration_id() ==
+              version->registration_id();
 }
 
 void ServiceWorkerProviderHost::PostMessage(
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids) {
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   std::vector<int> new_routing_ids;
   dispatcher_host_->message_port_message_filter()->
       UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
                                       &new_routing_ids);
 
   dispatcher_host_->Send(
       new ServiceWorkerMsg_MessageToDocument(
           kDocumentMainThreadId, provider_id(),
           message,
           sent_message_port_ids,
           new_routing_ids));
 }
 
 ServiceWorkerObjectInfo ServiceWorkerProviderHost::CreateHandleAndPass(
     ServiceWorkerVersion* version) {
-  DCHECK(ValidateVersionForAssociation(version));
   ServiceWorkerObjectInfo info;
   if (context_ && version) {
     scoped_ptr<ServiceWorkerHandle> handle =
         ServiceWorkerHandle::Create(context_, dispatcher_host_,
                                     kDocumentMainThreadId, version);
     info = handle->GetObjectInfo();
     dispatcher_host_->RegisterServiceWorkerHandle(handle.Pass());
   }
   return info;
 }
 
 bool ServiceWorkerProviderHost::IsContextAlive() {
   return context_ != NULL;
 }
 
 }  // namespace content