Modify prerendering to support having multiple session storage namespaces per tab.

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 37 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_view.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
-using content::SessionStorageNamespace;
+using content::SessionStorageNamespaceMap;
 using content::WebContents;
 
 namespace prerender {
 
 namespace {
 
 // Time interval at which periodic cleanups are performed.
 const int kPeriodicCleanupIntervalMs = 1000;
 
 // Valid HTTP methods for prerendering.
@@ skipping 132 matching lines @@
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender(
     int process_id,
     int route_id,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size) {
 #if defined(OS_ANDROID)
   // TODO(jcivelli): http://crbug.com/113322 We should have an option to disable
   //                link-prerender and enable omnibox-prerender only.
-  return NULL;
+  return false;
 #else
   DCHECK(!size.IsEmpty());
   if (PrerenderData* parent_prerender_data =
           FindPrerenderDataForChildAndRoute(process_id, route_id)) {
     // Instead of prerendering from inside of a running prerender, we will defer
     // this request until its launcher is made visible.
     if (PrerenderContents* contents = parent_prerender_data->contents_) {
       pending_prerender_list_.push_back(
           linked_ptr<PrerenderData>(new PrerenderData(this)));
       PrerenderHandle* prerender_handle =
           new PrerenderHandle(pending_prerender_list_.back().get());
       contents->AddPendingPrerender(
           prerender_handle->weak_ptr_factory_.GetWeakPtr(),
           url, referrer, size);
       return prerender_handle;
     }
   }
 
   // Unit tests pass in a process_id == -1.
-  SessionStorageNamespace* session_storage_namespace = NULL;
-  if (process_id != -1) {
-    RenderViewHost* source_render_view_host =
-        RenderViewHost::FromID(process_id, route_id);
-    if (!source_render_view_host)
-      return NULL;
-    WebContents* source_web_contents =
-        WebContents::FromRenderViewHost(source_render_view_host);
-    if (!source_web_contents)
-      return NULL;
-    // TODO(ajwong): This does not correctly handle storage for isolated apps.
-    session_storage_namespace =
-        source_web_contents->GetController()
-            .GetSessionStorageNamespaceMap().find("")->second;
+  if (process_id == -1) {
+    return AddPrerender(ORIGIN_LINK_REL_PRERENDER,
+                        process_id, url, referrer, size,
+                        SessionStorageNamespaceMap());
   }
 
+  RenderViewHost* source_render_view_host =
+      RenderViewHost::FromID(process_id, route_id);
+  if (!source_render_view_host)
+    return NULL;
+
+  WebContents* source_web_contents =
+      WebContents::FromRenderViewHost(source_render_view_host);
   return AddPrerender(ORIGIN_LINK_REL_PRERENDER,
                       process_id, url, referrer, size,
-                      session_storage_namespace);
+                      source_web_contents->GetController()
+                          .GetSessionStorageNamespaceMap());
 #endif
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
-    SessionStorageNamespace* session_storage_namespace,
+    const SessionStorageNamespaceMap& session_storage_namespace_map,
     const gfx::Size& size) {
   if (!IsOmniboxEnabled(profile_))
     return NULL;
   return AddPrerender(ORIGIN_OMNIBOX, -1, url, content::Referrer(), size,
-                      session_storage_namespace);
+                      session_storage_namespace_map);
 }
 
 void PrerenderManager::DestroyPrerenderForRenderView(
     int process_id, int view_id, FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
   if (PrerenderData* prerender_data =
           FindPrerenderDataForChildAndRoute(process_id, view_id)) {
     prerender_data->contents_->Destroy(final_status);
   }
 }
 
 void PrerenderManager::CancelAllPrerenders() {
   DCHECK(CalledOnValidThread());
   while (!active_prerender_list_.empty()) {
     PrerenderContents* prerender_contents =
         active_prerender_list_.front()->contents();
     prerender_contents->Destroy(FINAL_STATUS_CANCELLED);
   }
 }
 
 bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
                                                const GURL& url) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsWebContentsPrerendering(web_contents));
 
+  const SessionStorageNamespaceMap& old_session_storage_namespace_map =
+      web_contents->GetController().GetSessionStorageNamespaceMap();
   DeleteOldEntries();
   DeletePendingDeleteEntries();
-  // TODO(ajwong): This doesn't handle isolated apps correctly.
-  PrerenderData* prerender_data = FindPrerenderData(
-          url,
-          web_contents->GetController().GetSessionStorageNamespaceMap()
-              .find("")->second);
+  PrerenderData* prerender_data =
+      FindPrerenderData(url, old_session_storage_namespace_map);
   if (!prerender_data)
     return false;
   DCHECK(prerender_data->contents_);
   if (IsNoSwapInExperiment(prerender_data->contents_->experiment_id()))
     return false;
 
   if (TabContents* new_tab_contents =
       prerender_data->contents_->prerender_contents()) {
     if (web_contents == new_tab_contents->web_contents())
       return false;  // Do not swap in to ourself.
@@ skipping 500 matching lines @@
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 void PrerenderManager::StartPendingPrerender(
     PrerenderHandle* existing_prerender_handle,
     Origin origin,
     int process_id,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size,
-    content::SessionStorageNamespace* session_storage_namespace) {
+    const content::SessionStorageNamespaceMap& session_storage_namespace_map) {
   DCHECK(existing_prerender_handle);
   DCHECK(existing_prerender_handle->IsValid());
   DCHECK(existing_prerender_handle->IsPending());
 
   DVLOG(6) << "StartPendingPrerender";
   DVLOG(6) << "existing_prerender_handle->handle_count_ = " <<
       existing_prerender_handle->prerender_data_->handle_count_;
 
-  DCHECK(process_id == -1 || session_storage_namespace);
+  DCHECK(process_id == -1 || !session_storage_namespace_map.empty());
 
   scoped_ptr<PrerenderHandle> swap_prerender_handle(AddPrerender(
-      origin, process_id, url, referrer, size, session_storage_namespace));
+      origin, process_id, url, referrer, size, session_storage_namespace_map));
   if (swap_prerender_handle.get()) {
     // AddPrerender has returned a new prerender handle to us. We want to make
     // |existing_prerender_handle| active, so swap the underlying PrerenderData
     // between the two handles, and delete our old handle (which will release
     // our entry in the pending_prerender_list_).
     existing_prerender_handle->SwapPrerenderDataWith(
         swap_prerender_handle.get());
     swap_prerender_handle->OnCancel();
     return;
   }
@@ skipping 28 matching lines @@
   DCHECK(active_prerender_list_.empty());
 }
 
 // private
 PrerenderHandle* PrerenderManager::AddPrerender(
     Origin origin,
     int process_id,
     const GURL& url_arg,
     const content::Referrer& referrer,
     const gfx::Size& size,
-    SessionStorageNamespace* session_storage_namespace) {
+    const SessionStorageNamespaceMap& session_storage_namespace_map) {
   DCHECK(CalledOnValidThread());
 
   if (!IsEnabled())
     return NULL;
 
   if (origin == ORIGIN_LINK_REL_PRERENDER &&
       IsGoogleSearchResultURL(referrer.url)) {
     origin = ORIGIN_GWS_PRERENDER;
   }
 
   DeleteOldEntries();
   DeletePendingDeleteEntries();
 
   GURL url = url_arg;
   GURL alias_url;
   uint8 experiment = GetQueryStringBasedExperiment(url_arg);
   bool control_group_behavior =
       IsControlGroup() || IsControlGroupExperiment(experiment);
   if (control_group_behavior &&
       MaybeGetQueryStringBasedAliasURL(url, &alias_url)) {
     url = alias_url;
   }
 
   // From here on, we will record a FinalStatus so we need to register with the
   // histogram tracking.
   histograms_->RecordPrerender(origin, url_arg);
 
   if (PrerenderData* preexisting_prerender_data =
-          FindPrerenderData(url, session_storage_namespace)) {
+          FindPrerenderData(url, session_storage_namespace_map)) {
     RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE);
     return new PrerenderHandle(preexisting_prerender_data);
   }
 
   // Do not prerender if there are too many render processes, and we would
   // have to use an existing one.  We do not want prerendering to happen in
   // a shared process, so that we can always reliably lower the CPU
   // priority for prerendering.
   // In single-process mode, ShouldTryToUseExistingProcessHost() always returns
   // true, so that case needs to be explicitly checked for.
@@ skipping 31 matching lines @@
       linked_ptr<PrerenderData>(new PrerenderData(this, prerender_contents)));
   PrerenderHandle* prerender_handle =
       new PrerenderHandle(active_prerender_list_.back().get());
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
   gfx::Size contents_size =
       size.IsEmpty() ? config_.default_tab_bounds.size() : size;
 
   prerender_contents->StartPrerendering(process_id, contents_size,
-                                        session_storage_namespace,
+                                        session_storage_namespace_map,
                                         control_group_behavior);
 
   while (active_prerender_list_.size() > config_.max_concurrency) {
     prerender_contents = active_prerender_list_.front()->contents_;
     DCHECK(prerender_contents);
     prerender_contents->Destroy(FINAL_STATUS_EVICTED);
   }
 
   histograms_->RecordConcurrency(active_prerender_list_.size());
 
@@ skipping 91 matching lines @@
 void PrerenderManager::DeletePendingDeleteEntries() {
   while (!pending_delete_list_.empty()) {
     PrerenderContents* contents = pending_delete_list_.front();
     pending_delete_list_.pop_front();
     delete contents;
   }
 }
 
 PrerenderManager::PrerenderData* PrerenderManager::FindPrerenderData(
     const GURL& url,
-    const SessionStorageNamespace* session_storage_namespace) {
+    const SessionStorageNamespaceMap& session_storage_namespace_map) {
   for (std::list<linked_ptr<PrerenderData> >::iterator
            it = active_prerender_list_.begin();
        it != active_prerender_list_.end();
        ++it) {
     PrerenderContents* prerender_contents = it->get()->contents_;
-    if (prerender_contents->Matches(url, session_storage_namespace))
+    if (prerender_contents->Matches(url, session_storage_namespace_map))
       return it->get();
   }
   return NULL;
 }
 
 PrerenderManager::PrerenderData*
 PrerenderManager::FindPrerenderDataForChildAndRoute(
     const int child_id, const int route_id) {
   for (std::list<linked_ptr<PrerenderData> >::iterator
            it = active_prerender_list_.begin();
@@ skipping 152 matching lines @@
   if (!render_process_host || !render_process_host->GetBrowserContext())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->GetBrowserContext());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender