Transfer serviceworker state during cross site navigations too.

content/browser/appcache/appcache_request_handler.cc

 // Copyright (c) 2011 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/appcache/appcache_request_handler.h"
 
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_policy.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 
 namespace content {
 
 AppCacheRequestHandler::AppCacheRequestHandler(AppCacheHost* host,
                                                ResourceType resource_type,
                                                bool should_reset_appcache)
     : host_(host),
       resource_type_(resource_type),
       should_reset_appcache_(should_reset_appcache),
       is_waiting_for_cache_selection_(false),
       found_group_id_(0),
       found_cache_id_(0),
       found_network_namespace_(false),
       cache_entry_not_found_(false),
-      maybe_load_resource_executed_(false) {
+      maybe_load_resource_executed_(false),
+      old_process_id_(0),
+      old_host_id_(kAppCacheNoHostId) {
   DCHECK(host_);
   host_->AddObserver(this);
 }
 
 AppCacheRequestHandler::~AppCacheRequestHandler() {
   if (host_) {
     storage()->CancelDelegateCallbacks(this);
     host_->RemoveObserver(this);
   }
 }
@@ skipping 139 matching lines @@
   if (job_.get() && job_->is_delivering_appcache_response()) {
     *cache_id = job_->cache_id();
     *manifest_url = job_->manifest_url();
   }
 }
 
 void AppCacheRequestHandler::PrepareForCrossSiteTransfer(int old_process_id) {
   if (!host_)
     return;
   AppCacheBackendImpl* backend = host_->service()->GetBackend(old_process_id);
+  old_process_id_ = old_process_id;
+  old_host_id_ = host_->host_id();
   host_for_cross_site_transfer_ = backend->TransferHostOut(host_->host_id());
   DCHECK_EQ(host_, host_for_cross_site_transfer_.get());
 }
 
 void AppCacheRequestHandler::CompleteCrossSiteTransfer(
     int new_process_id, int new_host_id) {
   if (!host_for_cross_site_transfer_.get())
     return;
   DCHECK_EQ(host_, host_for_cross_site_transfer_.get());
   AppCacheBackendImpl* backend = host_->service()->GetBackend(new_process_id);
   backend->TransferHostIn(new_host_id, host_for_cross_site_transfer_.Pass());
 }
 
+void AppCacheRequestHandler::MaybeCompleteCrossSiteTransferInOldProcess(
+    int old_process_id) {
+  if (!host_ || !host_for_cross_site_transfer_.get() ||
+      old_process_id != old_process_id_) {
+    return;
+  }
+  CompleteCrossSiteTransfer(old_process_id_, old_host_id_);
+}
+
 void AppCacheRequestHandler::OnDestructionImminent(AppCacheHost* host) {
   storage()->CancelDelegateCallbacks(this);
   host_ = NULL;  // no need to RemoveObserver, the host is being deleted
 
   // Since the host is being deleted, we don't have to complete any job
   // that is current running. It's destined for the bit bucket anyway.
   if (job_.get()) {
     job_->Kill();
     job_ = NULL;
   }
@@ skipping 206 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace content