Move SessionStorageNamespace entirely into NavigationController and support StoragePartitions.

content/browser/web_contents/navigation_controller_impl.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 CONTENT_BROWSER_WEB_CONTENTS_NAVIGATION_CONTROLLER_IMPL_H_
 #define CONTENT_BROWSER_WEB_CONTENTS_NAVIGATION_CONTROLLER_IMPL_H_
 
 #include "build/build_config.h"
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/time.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/public/browser/android/navigation_controller_webview.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_type.h"
 
-class SessionStorageNamespaceImpl;
 struct ViewHostMsg_FrameNavigate_Params;
 class WebContentsImpl;
 
 namespace content {
 class NavigationEntryImpl;
 struct LoadCommittedDetails;
 class SiteInstance;
 }
 
 class CONTENT_EXPORT NavigationControllerImpl
     : public NON_EXPORTED_BASE(content::NavigationController),
       public NON_EXPORTED_BASE(content::NavigationControllerWebView) {
  public:
   NavigationControllerImpl(
       WebContentsImpl* web_contents,
-      content::BrowserContext* browser_context,
-      SessionStorageNamespaceImpl* session_storage_namespace);
+      content::BrowserContext* browser_context);
   virtual ~NavigationControllerImpl();
 
   // NavigationController implementation:
   virtual content::WebContents* GetWebContents() const OVERRIDE;
   virtual content::BrowserContext* GetBrowserContext() const OVERRIDE;
   virtual void SetBrowserContext(
       content::BrowserContext* browser_context) OVERRIDE;
   virtual void Restore(
       int selected_navigation,
       bool from_last_session,
@@ skipping 35 matching lines @@
       bool is_renderer_initiated) OVERRIDE;
   virtual void LoadIfNecessary() OVERRIDE;
   virtual bool CanGoBack() const OVERRIDE;
   virtual bool CanGoForward() const OVERRIDE;
   virtual bool CanGoToOffset(int offset) const OVERRIDE;
   virtual void GoBack() OVERRIDE;
   virtual void GoForward() OVERRIDE;
   virtual void GoToIndex(int index) OVERRIDE;
   virtual void GoToOffset(int offset) OVERRIDE;
   virtual void RemoveEntryAtIndex(int index) OVERRIDE;
-  virtual content::SessionStorageNamespace*
-      GetSessionStorageNamespace() const OVERRIDE;
+  virtual const content::SessionStorageNamespaceMap&
+      GetSessionStorageNamespaceMap() const OVERRIDE;
   virtual void SetMaxRestoredPageID(int32 max_id) OVERRIDE;
   virtual int32 GetMaxRestoredPageID() const OVERRIDE;
   virtual bool NeedsReload() const OVERRIDE;
   virtual void CancelPendingReload() OVERRIDE;
   virtual void ContinuePendingReload() OVERRIDE;
   virtual bool IsInitialNavigation() OVERRIDE;
   virtual void Reload(bool check_for_repost) OVERRIDE;
   virtual void ReloadIgnoringCache(bool check_for_repost) OVERRIDE;
   virtual void NotifyEntryChanged(const content::NavigationEntry* entry,
                                  int index) OVERRIDE;
   virtual void CopyStateFrom(
       const content::NavigationController& source) OVERRIDE;
   virtual void CopyStateFromAndPrune(
       content::NavigationController* source) OVERRIDE;
   virtual void PruneAllButActive() OVERRIDE;
 
   // NavigationControllerWebView implementation.
   virtual void LoadDataWithBaseURL(
       const GURL& data_url,
       const content::Referrer& referrer,
       const GURL& base_url,
       const GURL& history_url,
       bool is_overriding_user_agent) OVERRIDE;
   virtual void PostURL(const GURL& url,
                        const content::Referrer& referrer,
                        const base::RefCountedMemory& http_body,
                        bool is_overriding_user_agent) OVERRIDE;
 
+  // The session storage namespace that all child RenderViews in the renderer
+  // process with the given ID should use.
+  content::SessionStorageNamespace* GetSessionStorageNamespace(
+      content::SiteInstance* instance);
+
   // Returns the index of the specified entry, or -1 if entry is not contained
   // in this NavigationController.
   int GetIndexOfEntry(const content::NavigationEntryImpl* entry) const;
 
   // Return the index of the entry with the corresponding instance and page_id,
   // or -1 if not found.
   int GetEntryIndexWithPageID(content::SiteInstance* instance,
                               int32 page_id) const;
 
   // Return the entry with the corresponding instance and page_id, or NULL if
@@ skipping 48 matching lines @@
   // is no last committed entry, then nothing will be in-page.
   //
   // Special note: if the URLs are the same, it does NOT count as an in-page
   // navigation. Neither does an input URL that has no ref, even if the rest is
   // the same. This may seem weird, but when we're considering whether a
   // navigation happened without loading anything, the same URL would be a
   // reload, while only a different ref would be in-page (pages can't clear
   // refs without reload, only change to "#" which we don't count as empty).
   bool IsURLInPageNavigation(const GURL& url) const;
 
+  // Sets the SessionStorageNamespace for the given |partition_id|. This is
+  // used during initialization of a new NavigationController to allow
+  // pre-population of the SessionStorageNamespace objects. Session restore,
+  // prerendering, and the implementaion of window.open() are the primary users
+  // of this API.
+  //
+  // Calling this function when a SessionStorageNamespace has already been
+  // associated with a |partition_id| will CHECK() fail.
+  void SetSessionStorageNamespace(
+      const std::string& partition_id,
+      content::SessionStorageNamespace* session_storage_namespace);
+
   // Random data ---------------------------------------------------------------
 
   SSLManager* ssl_manager() { return &ssl_manager_; }
 
   // Maximum number of entries before we start removing entries from the front.
   static void set_max_entry_count_for_testing(size_t max_entry_count) {
     max_entry_count_for_testing_ = max_entry_count;
   }
   static size_t max_entry_count();
 
@@ skipping 134 matching lines @@
 
   // Manages the SSL security UI
   SSLManager ssl_manager_;
 
   // Whether we need to be reloaded when made active.
   bool needs_reload_;
 
   // The time ticks at which the last document was loaded.
   base::TimeTicks last_document_loaded_;
 
-  // The session storage id that any (indirectly) owned RenderView should use.
-  scoped_refptr<SessionStorageNamespaceImpl> session_storage_namespace_;
+  // Used to find the appropriate SessionStorageNamespace for the storage
+  // partition of a NavigationEntry.
+  //
+  // A NavigationController may contain NavigationEntries that correspond to
+  // different StoragePartitions. Even though they are part of the same
+  // NavigationController, only entries in the same StoragePartition may
+  // share session storage state with one another.
+  content::SessionStorageNamespaceMap session_storage_namespace_map_;
 
   // The maximum number of entries that a navigation controller can store.
   static size_t max_entry_count_for_testing_;
 
   // If a repost is pending, its type (RELOAD or RELOAD_IGNORING_CACHE),
   // NO_RELOAD otherwise.
   ReloadType pending_reload_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationControllerImpl);
 };
 
 #endif  // CONTENT_BROWSER_WEB_CONTENTS_NAVIGATION_CONTROLLER_IMPL_H_