Prerendered tabs use the same SessionStorage namespace as the tab that triggered the prerender.

chrome/browser/prerender/prerender_manager.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 "chrome/browser/prerender/prerender_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/cancelable_request.h"
 #include "content/browser/debugger/render_view_devtools_agent_host.h"
+#include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/render_view_host_manager.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 218 matching lines @@
 }
 
 bool PrerenderManager::AddPrerenderFromLinkRelPrerender(int process_id,
                                                         int route_id,
                                                         const GURL& url,
                                                         const GURL& referrer) {
   std::pair<int, int> child_route_id_pair = std::make_pair(process_id,
                                                            route_id);
 
   return AddPrerender(ORIGIN_LINK_REL_PRERENDER, child_route_id_pair,
-                      url, referrer);
+                      url, referrer, NULL);
 }
 
-bool PrerenderManager::AddPrerenderFromOmnibox(const GURL& url) {
+bool PrerenderManager::AddPrerenderFromOmnibox(
+    const GURL& url,
+    SessionStorageNamespace* session_storage_namespace) {
+  DCHECK(session_storage_namespace);
   if (!IsOmniboxEnabled(profile_))
     return false;
 
   Origin origin = ORIGIN_MAX;
   switch (GetOmniboxHeuristicToUse()) {
     case OMNIBOX_HEURISTIC_ORIGINAL:
       origin = ORIGIN_OMNIBOX_ORIGINAL;
       break;
 
     case OMNIBOX_HEURISTIC_CONSERVATIVE:
       origin = ORIGIN_OMNIBOX_CONSERVATIVE;
       break;
 
     default:
       NOTREACHED();
       break;
   };
 
-  return AddPrerender(origin, std::make_pair(-1, -1), url, GURL());
+  return AddPrerender(origin, std::make_pair(-1, -1), url, GURL(),
+                      session_storage_namespace);
 }
 
 bool PrerenderManager::AddPrerender(
     Origin origin,
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url_arg,
-    const GURL& referrer) {
+    const GURL& referrer,
+    SessionStorageNamespace* session_storage_namespace) {
   DCHECK(CalledOnValidThread());
 
   if (origin == ORIGIN_LINK_REL_PRERENDER && IsGoogleSearchResultURL(referrer))
     origin = ORIGIN_GWS_PRERENDER;
 
   histograms_->RecordPrerender(origin, url_arg);
 
   // If the referring page is prerendering, defer the prerender.
   std::list<PrerenderContentsData>::iterator source_prerender =
       FindPrerenderContentsForChildRouteIdPair(child_route_id_pair);
@@ skipping 34 matching lines @@
   // Check if enough time has passed since the last prerender.
   if (!DoesRateLimitAllowPrerender()) {
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
     RecordFinalStatus(origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return false;
   }
 
   RenderViewHost* source_render_view_host = NULL;
-  // This test should fail only during unit tests.
   if (child_route_id_pair.first != -1) {
     source_render_view_host =
         RenderViewHost::FromID(child_route_id_pair.first,
                                child_route_id_pair.second);
     // Don't prerender page if parent RenderViewHost no longer exists, or it has
     // no view.  The latter should only happen when the RenderView has closed.
     if (!source_render_view_host || !source_render_view_host->view()) {
       RecordFinalStatus(origin, experiment,
                         FINAL_STATUS_SOURCE_RENDER_VIEW_CLOSED);
       return false;
     }
   }
 
-  PrerenderContents* prerender_contents =
-      CreatePrerenderContents(url, referrer, origin, experiment);
+  if (!session_storage_namespace && source_render_view_host) {
+    session_storage_namespace =
+        source_render_view_host->session_storage_namespace();
+  }
+
+  PrerenderContents* prerender_contents = CreatePrerenderContents(
+      url, referrer, origin, experiment);
   if (!prerender_contents || !prerender_contents->Init())
     return false;
 
   // TODO(cbentzel): Move invalid checks here instead of PrerenderContents?
   PrerenderContentsData data(prerender_contents, GetCurrentTime());
 
   prerender_list_.push_back(data);
 
   if (IsControlGroup()) {
     data.contents_->set_final_status(FINAL_STATUS_CONTROL_GROUP);
   } else {
     last_prerender_start_time_ = GetCurrentTimeTicks();
-    data.contents_->StartPrerendering(source_render_view_host);
+    data.contents_->StartPrerendering(source_render_view_host,
+                                      session_storage_namespace);
   }
   while (prerender_list_.size() > config_.max_elements) {
     data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->Destroy(FINAL_STATUS_EVICTED);
   }
   StartSchedulingPeriodicCleanups();
   return true;
 }
 
@@ skipping 130 matching lines @@
   }
 
   // If the prerendered page is in the middle of a cross-site navigation,
   // don't swap it in because there isn't a good way to merge histories.
   if (prerender_contents->IsCrossSiteNavigationPending()) {
     prerender_contents.release()->Destroy(
         FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING);
     return false;
   }
 
+  // If the sessionStorage namespaces don't match, don't swap the site in and

[mmenke, 2011/11/02 16:19:17]

nit:  "session storage namespaces" or "SessionStorageNamespaces".  Also "site"
seems a little odd here, I'd suggest "TabContents" or "prerender" or some such
instead.

[cbentzel, 2011/11/02 17:13:49]

Removed the "don't swap the site in" and just said "cancel the prerender".

+  // cancel the prerender.
+  RenderViewHost* old_render_view_host = tab_contents->render_view_host();

[mmenke, 2011/11/02 16:19:17]

What happens if the old tab has crashed?  I think old_render_view_host may be
NULL, and we probably don't want to crash the browser here in a fit of pique. 
May be a little silly, but once we have omnibox prerender tests, may want to add
one for that, too.

[cbentzel, 2011/11/02 16:55:52]

It's old_render_view_host->view() which could be NULL if the render process
crashes, not old_render_view_host.

old_render_view_host is generally non-NULL whenever tab_contents is non-NULL.
There are two exceptions: during the construction phase of the TabContents
(before render_view_host_manager_.Init() is called) and during the destruction
phase (in render_view_host_manager_'s destructor when it NULLs out the value).
Neither is applicable here.

[mmenke, 2011/11/02 17:44:07]

You're right.  As you say, I was getting the RenderWidgetHostView confused with
the RenderWidgetHost.

+  RenderViewHost* new_render_view_host =
+      prerender_contents->prerender_contents()->render_view_host();
+  DCHECK(old_render_view_host);
+  DCHECK(new_render_view_host);
+  if (old_render_view_host->session_storage_namespace() !=
+      new_render_view_host->session_storage_namespace()) {
+    prerender_contents.release()->Destroy(
+        FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH);
+    return false;
+  }
+
   int child_id, route_id;
   CHECK(prerender_contents->GetChildId(&child_id));
   CHECK(prerender_contents->GetRouteId(&route_id));
 
   // Try to set the prerendered page as used, so any subsequent attempts to
   // cancel on other threads will fail.  If this fails because the prerender
   // was already cancelled, possibly on another thread, fail.
   if (!prerender_tracker_->TryUse(child_id, route_id))
     return false;
 
   if (!prerender_contents->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(GetCurrentTimeTicks() -
                                      prerender_contents->load_start_time(),
                                      config_.max_age);
   }
 
   histograms_->RecordPerSessionCount(++prerenders_per_session_count_);
   prerender_contents->set_final_status(FINAL_STATUS_USED);
 
-  RenderViewHost* render_view_host =
-      prerender_contents->prerender_contents()->render_view_host();
-  DCHECK(render_view_host);
-  render_view_host->Send(
-      new ChromeViewMsg_SetIsPrerendering(render_view_host->routing_id(),
+  new_render_view_host->Send(
+      new ChromeViewMsg_SetIsPrerendering(new_render_view_host->routing_id(),
                                           false));
 
   TabContentsWrapper* new_tab_contents =
       prerender_contents->ReleasePrerenderContents();
   TabContentsWrapper* old_tab_contents =
       TabContentsWrapper::GetCurrentWrapperForContents(tab_contents);
   DCHECK(new_tab_contents);
   DCHECK(old_tab_contents);
 
   MarkTabContentsAsPrerendered(new_tab_contents->tab_contents());
@@ skipping 75 matching lines @@
   return (now - start < config_.max_age);
 }
 
 PrerenderContents* PrerenderManager::CreatePrerenderContents(
     const GURL& url,
     const GURL& referrer,
     Origin origin,
     uint8 experiment_id) {
   DCHECK(CalledOnValidThread());
   return prerender_contents_factory_->CreatePrerenderContents(
-      this, prerender_tracker_, profile_, url, referrer, origin, experiment_id);
+      this, prerender_tracker_, profile_, url,
+      referrer, origin, experiment_id);
 }
 
 bool PrerenderManager::IsPendingDelete(PrerenderContents* entry) const {
   DCHECK(CalledOnValidThread());
   for (std::list<PrerenderContents*>::const_iterator it =
           pending_delete_list_.begin();
        it != pending_delete_list_.end();
        ++it) {
     if (*it == entry)
       return true;
@@ skipping 343 matching lines @@
   if (!render_process_host || !render_process_host->browser_context())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->browser_context());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender