Transfer serviceworker state during cross site navigations too.

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"
 #include "content/browser/service_worker/service_worker_controllee_request_handler.h"
 #include "content/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/browser/service_worker/service_worker_handle.h"
 #include "content/browser/service_worker/service_worker_registration_handle.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/public/common/child_process_host.h"
 
 namespace content {
 
 static const int kDocumentMainThreadId = 0;
 
 ServiceWorkerProviderHost::ServiceWorkerProviderHost(
     int process_id, int provider_id,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host)
     : process_id_(process_id),
       provider_id_(provider_id),
       context_(context),
       dispatcher_host_(dispatcher_host),
       allow_association_(true) {
+  DCHECK_NE(ChildProcessHost::kInvalidUniqueID, process_id_);
 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   // Clear docurl so the deferred activation of a waiting worker
   // won't associate the new version with a provider being destroyed.
   document_url_ = GURL();
   if (controlling_version_.get())
     controlling_version_->RemoveControllee(this);
   if (associated_registration_.get()) {
     DecreaseProcessReference(associated_registration_->pattern());
@@ skipping 163 matching lines @@
           sent_message_port_ids,
           new_routing_ids));
 }
 
 void ServiceWorkerProviderHost::AddScopedProcessReferenceToPattern(
     const GURL& pattern) {
   associated_patterns_.push_back(pattern);
   IncreaseProcessReference(pattern);
 }
 
+void ServiceWorkerProviderHost::PrepareForCrossSiteTransfer() {
+  DCHECK_NE(ChildProcessHost::kInvalidUniqueID, process_id_);
+
+  for (std::vector<GURL>::iterator it = associated_patterns_.begin();
+        it != associated_patterns_.end(); ++it) {
+    DecreaseProcessReference(*it);
+  }
+
+  if (associated_registration_.get()) {
+    scoped_refptr<ServiceWorkerRegistration> registration =
+        associated_registration_;
+    DisassociateRegistration();
+    associated_registration_ = registration;
+  }
+
+  process_id_ = ChildProcessHost::kInvalidUniqueID;
+  provider_id_ = kInvalidServiceWorkerProviderId;
+  dispatcher_host_ = nullptr;
+}
+
+void ServiceWorkerProviderHost::CompleteCrossSiteTransfer(
+    int new_process_id,
+    int new_provider_id,
+    ServiceWorkerDispatcherHost* new_dispatcher_host) {
+  DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, process_id_);
+  DCHECK_NE(ChildProcessHost::kInvalidUniqueID, new_process_id);
+
+  process_id_ = new_process_id;
+  provider_id_ = new_provider_id;
+  dispatcher_host_ = new_dispatcher_host;
+
+  for (std::vector<GURL>::iterator it = associated_patterns_.begin();
+        it != associated_patterns_.end(); ++it) {
+    IncreaseProcessReference(*it);
+  }
+
+  if (associated_registration_.get()) {
+    scoped_refptr<ServiceWorkerRegistration> registration;
+    registration.swap(associated_registration_);
+    AssociateRegistration(registration);
+  }
+}
+
 ServiceWorkerObjectInfo ServiceWorkerProviderHost::CreateHandleAndPass(
     ServiceWorkerVersion* version) {
   ServiceWorkerObjectInfo info;
   if (context_ && version) {
     scoped_ptr<ServiceWorkerHandle> handle =
         ServiceWorkerHandle::Create(context_,
                                     dispatcher_host_,
                                     kDocumentMainThreadId,
                                     provider_id_,
                                     version);
@@ skipping 17 matching lines @@
     context_->process_manager()->RemoveProcessReferenceFromPattern(
         pattern, process_id_);
   }
 }
 
 bool ServiceWorkerProviderHost::IsContextAlive() {
   return context_ != NULL;
 }
 
 }  // namespace content