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

chrome/browser/prerender/prerender_contents.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_contents.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 21 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_view.h"
 #include "ui/gfx/rect.h"
 
 using content::DownloadItem;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::ResourceRedirectDetails;
 using content::SessionStorageNamespace;
+using content::SessionStorageNamespaceMap;
 using content::WebContents;
 
 namespace prerender {
 
 namespace {
 
 // Tells the render process at |child_id| whether |url| is a new prerendered
 // page, or whether |url| is being removed as a prerendered page. Currently
 // this will only inform the render process that created the prerendered page
 // with <link rel="prerender"> tags about it. This means that if the user
@@ skipping 151 matching lines @@
            pending_prerenders_.begin();
        it != pending_prerenders_.end();
        ++it) {
     if (it->weak_prerender_handle.get() == &prerender_handle)
       return true;
   }
   return false;
 }
 
 void PrerenderContents::StartPendingPrerenders() {
-  SessionStorageNamespace* session_storage_namespace = NULL;
-  if (prerender_contents_.get()) {
-    // TODO(ajwong): This does not correctly handle storage for isolated apps.
-    session_storage_namespace =
-        prerender_contents_->web_contents()->GetController()
-            .GetSessionStorageNamespaceMap().find("")->second;
-  }
-  DCHECK(child_id_ == -1 || session_storage_namespace);
+  const SessionStorageNamespaceMap& session_storage_namespace_map =
+      prerender_contents_->web_contents()->GetController()
+      .GetSessionStorageNamespaceMap();
+  DCHECK(child_id_ == -1 || !session_storage_namespace_map.empty());
 
   std::vector<PendingPrerenderInfo> pending_prerender_list;
   pending_prerender_list.swap(pending_prerenders_);
   for (std::vector<PendingPrerenderInfo>::iterator it =
            pending_prerender_list.begin();
        it != pending_prerender_list.end();
        ++it) {
     if (it->weak_prerender_handle && it->weak_prerender_handle->IsValid()) {
       prerender_manager_->StartPendingPrerender(
           it->weak_prerender_handle.get(), ORIGIN_LINK_REL_PRERENDER, child_id_,
-          it->url, it->referrer, it->size, session_storage_namespace);
+          it->url, it->referrer, it->size, session_storage_namespace_map);
     }
   }
 }
 
 PrerenderContents::PendingPrerenderInfo::PendingPrerenderInfo(
     const base::WeakPtr<PrerenderHandle> weak_prerender_handle,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size)
     : weak_prerender_handle(weak_prerender_handle),
@@ skipping 13 matching lines @@
     const content::Referrer& referrer,
     Origin origin,
     uint8 experiment_id)
     : prerendering_has_started_(false),
       prerender_manager_(prerender_manager),
       prerender_tracker_(prerender_tracker),
       prerender_url_(url),
       referrer_(referrer),
       profile_(profile),
       page_id_(0),
-      session_storage_namespace_id_(-1),
       has_stopped_loading_(false),
       has_finished_loading_(false),
       final_status_(FINAL_STATUS_MAX),
       match_complete_status_(MATCH_COMPLETE_DEFAULT),
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
       origin_(origin),
       experiment_id_(experiment_id),
       creator_child_id_(-1) {
   DCHECK(prerender_manager != NULL);
 }
 
 void PrerenderContents::MakeIntoDummyReplacementOf(
     const PrerenderContents* original_prerender_contents) {
   load_start_time_ = original_prerender_contents->load_start_time_;
-  session_storage_namespace_id_ =
-      original_prerender_contents->session_storage_namespace_id_;
+  session_storage_namespace_ids_ =
+      original_prerender_contents->session_storage_namespace_ids_;
 }
 
 bool PrerenderContents::Init() {
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     int creator_child_id,
     const gfx::Size& size,
-    SessionStorageNamespace* session_storage_namespace,
+    const SessionStorageNamespaceMap& session_storage_namespace_map,
     bool is_control_group) {
   DCHECK(profile_ != NULL);
   DCHECK(!size.IsEmpty());
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
   DCHECK_EQ(-1, creator_child_id_);
   DCHECK(size_.IsEmpty());
   DCHECK_EQ(1U, alias_urls_.size());
 
   creator_child_id_ = creator_child_id;
-  session_storage_namespace_id_ = session_storage_namespace->id();
   size_ = size;
+  for (SessionStorageNamespaceMap::const_iterator it =
+           session_storage_namespace_map.begin();
+       it != session_storage_namespace_map.end();
+       ++it) {
+    session_storage_namespace_ids_.insert(it->second->id());
+  }
 
   InformRenderProcessAboutPrerender(prerender_url_, true,
                                     creator_child_id_);
 
   DCHECK(load_start_time_.is_null());
   load_start_time_ = base::TimeTicks::Now();
 
   // Everything after this point sets up the WebContents object and associated
   // RenderView for the prerender page. Don't do this for members of the
   // control group.
   if (is_control_group)
     return;
 
   prerendering_has_started_ = true;
 
-  WebContents* new_contents = CreateWebContents(session_storage_namespace);
+  WebContents* new_contents = CreateWebContents(session_storage_namespace_map);
   prerender_contents_.reset(new TabContents(new_contents));
   content::WebContentsObserver::Observe(new_contents);
 
   tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   new_contents->SetDelegate(tab_contents_delegate_.get());
 
   // Set the size of the prerender WebContents.
   prerender_contents_->web_contents()->GetView()->SizeContents(size_);
 
   // Register as an observer of the RenderViewHost so we get messages.
@@ skipping 159 matching lines @@
       NOTREACHED() << "Unexpected notification sent.";
       break;
   }
 }
 
 void PrerenderContents::OnRenderViewHostCreated(
     RenderViewHost* new_render_view_host) {
 }
 
 WebContents* PrerenderContents::CreateWebContents(
-    SessionStorageNamespace* session_storage_namespace) {
-  // TODO(ajwong): Remove the temporary map once prerendering is aware of
-  // multiple session storage namespaces per tab.
-  content::SessionStorageNamespaceMap session_storage_namespace_map;
-  session_storage_namespace_map[""] = session_storage_namespace;
-  return  WebContents::CreateWithSessionStorage(
-      profile_, NULL, MSG_ROUTING_NONE, NULL, session_storage_namespace_map);
+    const SessionStorageNamespaceMap& session_storage_namespace_map) {
+  return WebContents::CreateWithSessionStorage(profile_, NULL,
+                                               MSG_ROUTING_NONE, NULL,
+                                               session_storage_namespace_map);
 }
 
 void PrerenderContents::OnUpdateFaviconURL(
     int32 page_id,
     const std::vector<FaviconURL>& urls) {
   VLOG(1) << "PrerenderContents::OnUpdateFaviconURL" << icon_url_;
   for (std::vector<FaviconURL>::const_iterator it = urls.begin();
        it != urls.end(); ++it) {
     if (it->icon_type == FaviconURL::FAVICON) {
       icon_url_ = it->icon_url;
@@ skipping 31 matching lines @@
     PrerenderContents* other_pc) {
   for (std::vector<GURL>::const_iterator it = other_pc->alias_urls_.begin();
        it != other_pc->alias_urls_.end();
        ++it) {
     alias_urls_.push_back(*it);
   }
 }
 
 bool PrerenderContents::Matches(
     const GURL& url,
-    const SessionStorageNamespace* session_storage_namespace) const {
-  DCHECK(child_id_ == -1 || session_storage_namespace);
-  if (session_storage_namespace &&
-      session_storage_namespace_id_ != session_storage_namespace->id())
+    const SessionStorageNamespaceMap& session_storage_namespace_map) const {
+  DCHECK(child_id_ == -1 || !session_storage_namespace_map.empty());
+
+  // We must have the same session storage objects to match.
+  if (session_storage_namespace_ids_.size() !=
+          session_storage_namespace_map.size()) {
     return false;
+  }
+
+  for (SessionStorageNamespaceMap::const_iterator it =
+           session_storage_namespace_map.begin();
+       it != session_storage_namespace_map.end();
+       ++it) {
+    if (session_storage_namespace_ids_.find(it->second->id()) ==
+            session_storage_namespace_ids_.end()) {
+      return false;
+    }
+  }
+
   return std::count_if(alias_urls_.begin(), alias_urls_.end(),
                        std::bind2nd(std::equal_to<GURL>(), url)) != 0;
 }
 
 void PrerenderContents::RenderViewGone(base::TerminationStatus status) {
   Destroy(FINAL_STATUS_RENDERER_CRASHED);
 }
 
 void PrerenderContents::DidStopLoading(
     content::RenderViewHost* render_view_host) {
@@ skipping 136 matching lines @@
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_.get() || !prerender_contents_->web_contents())
     return false;
   const WebContents* web_contents = prerender_contents_->web_contents();
   return (web_contents->GetSiteInstance() !=
           web_contents->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender