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

chrome/browser/prerender/prerender_contents.h

 // 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.
 
 #ifndef CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_
 
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 95 matching lines @@
   // starting a prerender, without actually creating the RenderView.
   // |creator_child_id| is the id of the child process that caused the prerender
   // to be created, and is needed so that the prerendered URLs can be sent to it
   // so render-initiated navigations will swap in the prerendered page. |size|
   // indicates the rectangular dimensions that the prerendered page should be.
   // |session_storage_namespace| indicates the namespace that the prerendered
   // page should be part of.
   virtual void StartPrerendering(
       int creator_child_id,
       const gfx::Size& size,
-      content::SessionStorageNamespace* session_storage_namespace,
+      const content::SessionStorageNamespaceMap& session_storage_namespace_map,
       bool is_control_group);
 
   // Verifies that the prerendering is not using too many resources, and kills
   // it if not.
   void DestroyWhenUsingTooManyResources();
 
   content::RenderViewHost* GetRenderViewHostMutable();
   const content::RenderViewHost* GetRenderViewHost() const;
 
   string16 title() const { return title_; }
@@ skipping 27 matching lines @@
 
   Origin origin() const { return origin_; }
   uint8 experiment_id() const { return experiment_id_; }
 
   base::TimeTicks load_start_time() const { return load_start_time_; }
 
   // Indicates whether this prerendered page can be used for the provided
   // |url| and |session_storage_namespace|.
   bool Matches(
       const GURL& url,
-      const content::SessionStorageNamespace* session_storage_namespace) const;
+      const content::SessionStorageNamespaceMap& session_storage_namespace_map)
+          const;
 
   // content::WebContentsObserver implementation.
   virtual void DidStopLoading(
       content::RenderViewHost* render_view_host) OVERRIDE;
   virtual void DidStartProvisionalLoadForFrame(
       int64 frame_id,
       bool is_main_frame,
       const GURL& validated_url,
       bool is_error_page,
       content::RenderViewHost* render_view_host) OVERRIDE;
@@ skipping 65 matching lines @@
         const content::Referrer& referrer,
         const gfx::Size& size);
     ~PendingPrerenderInfo();
 
     base::WeakPtr<PrerenderHandle> weak_prerender_handle;
     GURL url;
     content::Referrer referrer;
     gfx::Size size;
   };
 
+  // TODO(ajwong): These protected virtuals are only around for unittests. Make
+  // them private.
+
   PrerenderContents(PrerenderManager* prerender_manager,
                     PrerenderTracker* prerender_tracker,
                     Profile* profile,
                     const GURL& url,
                     const content::Referrer& referrer,
                     Origin origin,
                     uint8 experiment_id);
 
   // Called whenever a RenderViewHost is created for prerendering.  Only called
   // once the RenderViewHost has a RenderView and RenderWidgetHostView.
   virtual void OnRenderViewHostCreated(
       content::RenderViewHost* new_render_view_host);
 
   content::NotificationRegistrar& notification_registrar() {
     return notification_registrar_;
   }
 
   const std::vector<PendingPrerenderInfo>& pending_prerenders() const {
     return pending_prerenders_;
   }
 
   bool prerendering_has_been_cancelled() const {
     return prerendering_has_been_cancelled_;
   }
 
   virtual content::WebContents* CreateWebContents(
-      content::SessionStorageNamespace* session_storage_namespace);
+      const content::SessionStorageNamespaceMap&
+          session_storage_namespace_map);
 
   bool prerendering_has_started_;
 
   // Time at which we started to load the URL.  This is used to compute
   // the time elapsed from initiating a prerender until the time the
   // (potentially only partially) prerendered page is shown to the user.
   base::TimeTicks load_start_time_;
 
  private:
   class TabContentsDelegateImpl;
@@ skipping 36 matching lines @@
   int32 page_id_;
   GURL url_;
   GURL icon_url_;
   content::NotificationRegistrar notification_registrar_;
 
   // A vector of URLs that this prerendered page matches against.
   // This array can contain more than element as a result of redirects,
   // such as HTTP redirects or javascript redirects.
   std::vector<GURL> alias_urls_;
 
-  // The session storage namespace id for use in matching. We must save it
+  // The session storage namespace ids for use in matching. We must save it
   // rather than get it from the RenderViewHost since in the control group
   // we won't have a RenderViewHost.
-  int64 session_storage_namespace_id_;
+  std::set<int64> session_storage_namespace_ids_;
 
   bool has_stopped_loading_;
 
   // True when the main frame has finished loading.
   bool has_finished_loading_;
 
   // This must be the same value as the PrerenderTracker has recorded for
   // |this|, when |this| has a RenderView.
   FinalStatus final_status_;
 
@@ skipping 35 matching lines @@
 
   // The size of the WebView from the launching page.
   gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderContents);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_