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

chrome/browser/prerender/prerender_browsertest.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 <deque>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 28 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.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/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "grit/generated_resources.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
+using content::SessionStorageNamespaceMap;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::DevToolsClientHost;
 using content::DevToolsManager;
 using content::NavigationController;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
@@ skipping 168 matching lines @@
       const gfx::Size& size) OVERRIDE {
     PrerenderContents::AddPendingPrerender(
         weak_prerender_handle, url, referrer, size);
     if (expected_pending_prerenders_ > 0 &&
         pending_prerenders().size() == expected_pending_prerenders_) {
       MessageLoop::current()->Quit();
     }
   }
 
   virtual WebContents* CreateWebContents(
-      content::SessionStorageNamespace* session_storage_namespace) OVERRIDE {
+      const SessionStorageNamespaceMap& session_storage_namespace_map)
+          OVERRIDE {
     WebContents* web_contents = PrerenderContents::CreateWebContents(
-        session_storage_namespace);
+        session_storage_namespace_map);
     string16 ready_title = ASCIIToUTF16(kReadyTitle);
     if (prerender_should_wait_for_ready_title_)
       ready_title_watcher_.reset(new content::TitleWatcher(
           web_contents, ready_title));
     return web_contents;
   }
 
   void WaitForPrerenderToHaveReadyTitleIfRequired() {
     if (ready_title_watcher_.get()) {
       string16 ready_title = ASCIIToUTF16(kReadyTitle);
@@ skipping 248 matching lines @@
 #if defined(ENABLE_SAFE_BROWSING)
         safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
 #endif
         use_https_src_server_(false),
         call_javascript_(true),
         loader_path_("files/prerender/prerender_loader.html"),
         explicitly_set_browser_(NULL) {}
 
   virtual ~PrerenderBrowserTest() {}
 
-  content::SessionStorageNamespace* GetSessionStorageNamespace() const {
+  const SessionStorageNamespaceMap& GetSessionStorageNamespaceMap() const {
     TabContents* tab_contents =
         current_browser()->tab_strip_model()->GetActiveTabContents();
     if (!tab_contents)
-      return NULL;
+      return kEmptyMap;
     return tab_contents->web_contents()->GetController()
-        .GetSessionStorageNamespaceMap().find("")->second;
+        .GetSessionStorageNamespaceMap();
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 #if defined(ENABLE_SAFE_BROWSING)
     SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
 #endif
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitchASCII(switches::kPrerenderMode,
@@ skipping 200 matching lines @@
     GURL dest_url = test_server()->GetURL(dest_html_file);
     NavigateToURLImpl(dest_url, CURRENT_TAB);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
     return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
   }
 
   bool UrlIsInPrerenderManager(const GURL& url) const {
     return GetPrerenderManager()->FindPrerenderData(
-        url, GetSessionStorageNamespace()) != NULL;
+        url, GetSessionStorageNamespaceMap()) != NULL;
   }
 
   // This only checks to see if the URL is pending in our TestPrerenderContents.
   bool UrlIsPending(const std::string& html_file) const {
     TestPrerenderContents* test_prerender_contents = GetPrerenderContents();
     if (!test_prerender_contents)
       return false;
     GURL dest_url = test_server()->GetURL(html_file);
     return test_prerender_contents->UrlIsPending(dest_url);
   }
@@ skipping 41 matching lines @@
 
 #if defined(ENABLE_SAFE_BROWSING)
   FakeSafeBrowsingService* GetSafeBrowsingService() {
     return safe_browsing_factory_->most_recent_service();
   }
 #endif
 
   TestPrerenderContents* GetPrerenderContents() const {
     PrerenderManager::PrerenderData* prerender_data =
         GetPrerenderManager()->FindPrerenderData(
-            dest_url_, GetSessionStorageNamespace());
+            dest_url_, GetSessionStorageNamespaceMap());
     return static_cast<TestPrerenderContents*>(
         prerender_data ? prerender_data->contents() : NULL);
   }
 
   void set_loader_path(const std::string& path) {
     loader_path_ = path;
   }
 
   void set_loader_query_and_fragment(const std::string& query_and_fragment) {
     loader_query_and_fragment_ = query_and_fragment;
@@ skipping 208 matching lines @@
   WaitForLoadPrerenderContentsFactory* prerender_contents_factory_;
 #if defined(ENABLE_SAFE_BROWSING)
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
 #endif
   GURL dest_url_;
   bool use_https_src_server_;
   bool call_javascript_;
   std::string loader_path_;
   std::string loader_query_and_fragment_;
   Browser* explicitly_set_browser_;
+  const SessionStorageNamespaceMap kEmptyMap;  // Used for an error return.
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
@@ skipping 1335 matching lines @@
   ResultCatcher catcher;
 
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 }  // namespace prerender