ServiceWorker: add ServiceWorkerClients.claim() support (2/3).

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 39 matching lines @@
     int render_frame_id,
     int provider_id,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       render_thread_id_(kDocumentMainThreadId),
       provider_id_(provider_id),
       context_(context),
       dispatcher_host_(dispatcher_host),
-      allow_association_(true) {
+      allow_association_(true),
+      is_claiming_(false) {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   if (render_frame_id == MSG_ROUTING_NONE) {
     // Actual thread id is set when the worker context gets started.
     render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   }
 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   // Clear docurl so the deferred activation of a waiting worker
   // won't associate the new version with a provider being destroyed.
@@ skipping 46 matching lines @@
   controlling_version_ = version;
   if (version)
     version->AddControllee(this);
   if (previous_version.get())
     previous_version->RemoveControllee(this);
 
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   bool should_notify_controllerchange =
-      previous_version && version && version->skip_waiting();
+      is_claiming_ || (previous_version && version && version->skip_waiting());
 
   // SetController message should be sent only for the document context.
   DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
   Send(new ServiceWorkerMsg_SetControllerServiceWorker(
       render_thread_id_, provider_id(),
       CreateAndRegisterServiceWorkerHandle(version),
       should_notify_controllerchange));
 }
 
 bool ServiceWorkerProviderHost::SetHostedVersionId(int64 version_id) {
@@ skipping 14 matching lines @@
     return false;
   }
 
   running_hosted_version_ = live_version;
   return true;
 }
 
 void ServiceWorkerProviderHost::AssociateRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(CanAssociateRegistration(registration));
-  if (associated_registration_.get())
-    DecreaseProcessReference(associated_registration_->pattern());
   IncreaseProcessReference(registration->pattern());
-
   associated_registration_ = registration;
   associated_registration_->AddListener(this);
   SendAssociateRegistrationMessage();
   SetControllerVersionAttribute(registration->active_version());
 }
 
 void ServiceWorkerProviderHost::DisassociateRegistration() {
   queued_events_.clear();
   if (!associated_registration_.get())
     return;
@@ skipping 99 matching lines @@
   Send(new ServiceWorkerMsg_GetClientInfo(
       kDocumentMainThreadId, embedded_worker_id, request_id, provider_id()));
 }
 
 void ServiceWorkerProviderHost::AddScopedProcessReferenceToPattern(
     const GURL& pattern) {
   associated_patterns_.push_back(pattern);
   IncreaseProcessReference(pattern);
 }
 
+void ServiceWorkerProviderHost::ClaimedByRegistration(
+    ServiceWorkerRegistration* registration) {
+  DCHECK(registration->active_version());
+  is_claiming_ = true;
+  if (registration == associated_registration_) {
+    SetControllerVersionAttribute(registration->active_version());
+  } else if (allow_association_) {
+    DisassociateRegistration();
+    AssociateRegistration(registration);
+  }
+  is_claiming_ = false;
+}
+
 void ServiceWorkerProviderHost::PrepareForCrossSiteTransfer() {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(MSG_ROUTING_NONE, render_frame_id_);
   DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 
   if (associated_registration_.get()) {
     DecreaseProcessReference(associated_registration_->pattern());
@@ skipping 163 matching lines @@
   return context_ != NULL;
 }
 
 void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
   DCHECK(dispatcher_host_);
   DCHECK(IsReadyToSendMessages());
   dispatcher_host_->Send(message);
 }
 
 }  // namespace content