Move SessionStorageNamespace entirely into NavigationController and support StoragePartitions.

content/browser/web_contents/web_contents_impl.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 "content/browser/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_plugin/old/browser_plugin_host.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/debugger/devtools_manager_impl.h"
+#include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/mhtml_generation_manager.h"
 #include "content/browser/download/save_package.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/host_zoom_map_impl.h"
 #include "content/browser/intents/web_intents_dispatcher_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ skipping 232 matching lines @@
 }
 
 }  // namespace
 
 namespace content {
 
 WebContents* WebContents::Create(
     BrowserContext* browser_context,
     SiteInstance* site_instance,
     int routing_id,
+    const WebContents* base_web_contents) {
+  return WebContentsImpl::Create(
+      browser_context, site_instance, routing_id,
+      static_cast<const WebContentsImpl*>(base_web_contents));
+}
+
+WebContents* WebContents::CreateWithSessionStorage(
+    BrowserContext* browser_context,
+    SiteInstance* site_instance,
+    int routing_id,
     const WebContents* base_web_contents,
-    SessionStorageNamespace* session_storage_namespace) {
-  return new WebContentsImpl(
-      browser_context,
-      site_instance,
-      routing_id,
-      static_cast<const WebContentsImpl*>(base_web_contents),
-      NULL,
-      static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace));
+    const SessionStorageNamespaceMap& session_storage_namespace_map) {
+  WebContentsImpl* new_contents = new WebContentsImpl(browser_context, NULL);
+
+  for (SessionStorageNamespaceMap::const_iterator it =
+           session_storage_namespace_map.begin();
+       it != session_storage_namespace_map.end();
+       ++it) {
+    new_contents->GetController().SetSessionStorageNamespace(it->first,
+                                                             it->second);
+  }
+
+  new_contents->Init(browser_context, site_instance, routing_id,
+                     static_cast<const WebContentsImpl*>(base_web_contents));
+  return new_contents;
 }
 
 WebContents* WebContents::FromRenderViewHost(const RenderViewHost* rvh) {
   return rvh->GetDelegate()->GetAsWebContents();
 }
 
 }
 
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(
     content::BrowserContext* browser_context,
-    SiteInstance* site_instance,
-    int routing_id,
-    const WebContentsImpl* base_web_contents,
-    WebContentsImpl* opener,
-    SessionStorageNamespaceImpl* session_storage_namespace)
+    WebContentsImpl* opener)
     : delegate_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(controller_(
-          this, browser_context, session_storage_namespace)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(controller_(this, browser_context)),
       render_view_host_delegate_view_(NULL),
       opener_(opener),
       ALLOW_THIS_IN_INITIALIZER_LIST(render_manager_(this, this, this)),
       is_loading_(false),
       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       crashed_error_code_(0),
       waiting_for_response_(false),
       load_state_(net::LOAD_STATE_IDLE, string16()),
       upload_size_(0),
       upload_position_(0),
       displayed_insecure_content_(false),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
       dialog_creator_(NULL),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
       closed_by_user_gesture_(false),
       minimum_zoom_percent_(
           static_cast<int>(content::kMinimumZoomFactor * 100)),
       maximum_zoom_percent_(
           static_cast<int>(content::kMaximumZoomFactor * 100)),
       temporary_zoom_settings_(false),
       content_restrictions_(0),
       color_chooser_(NULL) {
-  render_manager_.Init(browser_context, site_instance, routing_id);
-
-  view_.reset(content::GetContentClient()->browser()->
-      OverrideCreateWebContentsView(this, &render_view_host_delegate_view_));
-  if (view_.get()) {
-    CHECK(render_view_host_delegate_view_);
-  } else {
-    content::WebContentsViewDelegate* delegate =
-        content::GetContentClient()->browser()->GetWebContentsViewDelegate(
-            this);
-    view_.reset(CreateWebContentsView(
-        this, delegate, &render_view_host_delegate_view_));
-    CHECK(render_view_host_delegate_view_);
-  }
-  CHECK(view_.get());
-
-  // We have the initial size of the view be based on the size of the view of
-  // the passed in WebContents.
-  view_->CreateView(base_web_contents ?
-      base_web_contents->GetView()->GetContainerSize() : gfx::Size());
-
-  // Listen for whether our opener gets destroyed.
-  if (opener_) {
-    registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                   content::Source<WebContents>(opener_));
-  }
-
-  registrar_.Add(this,
-                 content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-                 content::NotificationService::AllBrowserContextsAndSources());
-
-#if defined(ENABLE_JAVA_BRIDGE)
-  java_bridge_dispatcher_host_manager_.reset(
-      new JavaBridgeDispatcherHostManager(this));
-#endif
-
-  browser_plugin_host_.reset(new content::BrowserPluginHost(this));
 }
 
 WebContentsImpl::~WebContentsImpl() {
   is_being_destroyed_ = true;
 
   // Clear out any JavaScript state.
   if (dialog_creator_)
     dialog_creator_->ResetJavaScriptState(this);
 
   if (color_chooser_)
@@ skipping 24 matching lines @@
         base::TimeTicks::Now() - close_start_time_);
   }
 
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     WebContentsImplDestroyed());
 
   SetDelegate(NULL);
 }
 
+WebContentsImpl* WebContentsImpl::Create(
+    BrowserContext* browser_context,
+    SiteInstance* site_instance,
+    int routing_id,
+    const WebContentsImpl* base_web_contents) {
+  return CreateWithOpener(browser_context, site_instance, routing_id,
+                          base_web_contents, NULL);
+}
+
+WebContentsImpl* WebContentsImpl::CreateWithOpener(
+    BrowserContext* browser_context,
+    SiteInstance* site_instance,
+    int routing_id,
+    const WebContentsImpl* base_web_contents,
+    WebContentsImpl* opener) {
+  WebContentsImpl* new_contents = new WebContentsImpl(browser_context, opener);
+
+  new_contents->Init(browser_context, site_instance, routing_id,
+                     static_cast<const WebContentsImpl*>(base_web_contents));
+  return new_contents;
+}
+
 WebPreferences WebContentsImpl::GetWebkitPrefs(RenderViewHost* rvh,
                                                const GURL& url) {
   WebPreferences prefs;
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   prefs.developer_extras_enabled = true;
   prefs.javascript_enabled =
       !command_line.HasSwitch(switches::kDisableJavaScript);
   prefs.web_security_enabled =
@@ skipping 190 matching lines @@
   prefs.fixed_position_creates_stacking_context = !command_line.HasSwitch(
       switches::kDisableFixedPositionCreatesStackingContext);
 
   prefs.number_of_cpu_cores = base::SysInfo::NumberOfProcessors();
 
   content::GetContentClient()->browser()->OverrideWebkitPrefs(rvh, url, &prefs);
 
   return prefs;
 }
 
-NavigationControllerImpl& WebContentsImpl::GetControllerImpl() {
-  return controller_;
-}
-
 RenderViewHostManager* WebContentsImpl::GetRenderManagerForTesting() {
   return &render_manager_;
 }
 
 bool WebContentsImpl::OnMessageReceived(RenderViewHost* render_view_host,
                                         const IPC::Message& message) {
   if (GetWebUI() &&
       static_cast<WebUIImpl*>(GetWebUI())->OnMessageReceived(message)) {
     return true;
   }
@@ skipping 55 matching lines @@
   return handled;
 }
 
 void WebContentsImpl::RunFileChooser(
     RenderViewHost* render_view_host,
     const content::FileChooserParams& params) {
   if (delegate_)
     delegate_->RunFileChooser(this, params);
 }
 
-NavigationController& WebContentsImpl::GetController() {
+NavigationControllerImpl& WebContentsImpl::GetController() {
   return controller_;
 }
 
-const NavigationController& WebContentsImpl::GetController() const {
+const NavigationControllerImpl& WebContentsImpl::GetController() const {
   return controller_;
 }
 
 content::BrowserContext* WebContentsImpl::GetBrowserContext() const {
   return controller_.GetBrowserContext();
 }
 
 const GURL& WebContentsImpl::GetURL() const {
   // We may not have a navigation entry yet
   NavigationEntry* entry = controller_.GetActiveEntry();
@@ skipping 293 matching lines @@
 
 void WebContentsImpl::Stop() {
   render_manager_.Stop();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, StopNavigation());
 }
 
 WebContents* WebContentsImpl::Clone() {
   // We use our current SiteInstance since the cloned entry will use it anyway.
   // We pass |this| for the |base_web_contents| to size the view correctly, and
   // our own opener so that the cloned page can access it if it was before.
-  WebContentsImpl* tc = new WebContentsImpl(
-      GetBrowserContext(), GetSiteInstance(),
-      MSG_ROUTING_NONE, this, opener_, NULL);
-  tc->GetControllerImpl().CopyStateFrom(controller_);
+  WebContentsImpl* tc = CreateWithOpener(GetBrowserContext(),
+                                         GetSiteInstance(), MSG_ROUTING_NONE,
+                                         this, opener_);
+  tc->GetController().CopyStateFrom(controller_);
   return tc;
 }
 
 void WebContentsImpl::AddNewContents(WebContents* new_contents,
                                      WindowOpenDisposition disposition,
                                      const gfx::Rect& initial_pos,
                                      bool user_gesture) {
   if (!delegate_)
     return;
 
@@ skipping 34 matching lines @@
           break;
         }
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+void WebContentsImpl::Init(BrowserContext* browser_context,
+                           SiteInstance* site_instance,
+                           int routing_id,
+                           const WebContents* base_web_contents) {
+  render_manager_.Init(browser_context, site_instance, routing_id);
+
+  view_.reset(content::GetContentClient()->browser()->
+      OverrideCreateWebContentsView(this, &render_view_host_delegate_view_));
+  if (view_.get()) {
+    CHECK(render_view_host_delegate_view_);
+  } else {
+    content::WebContentsViewDelegate* delegate =
+        content::GetContentClient()->browser()->GetWebContentsViewDelegate(
+            this);
+    view_.reset(CreateWebContentsView(
+        this, delegate, &render_view_host_delegate_view_));
+    CHECK(render_view_host_delegate_view_);
+  }
+  CHECK(view_.get());
+
+  // We have the initial size of the view be based on the size of the view of
+  // the passed in WebContents.
+  view_->CreateView(base_web_contents ?
+      base_web_contents->GetView()->GetContainerSize() : gfx::Size());
+
+  // Listen for whether our opener gets destroyed.
+  if (opener_) {
+    registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                   content::Source<WebContents>(opener_));
+  }
+
+  registrar_.Add(this,
+                 content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+
+#if defined(ENABLE_JAVA_BRIDGE)
+  java_bridge_dispatcher_host_manager_.reset(
+      new JavaBridgeDispatcherHostManager(this));
+#endif
+
+  browser_plugin_host_.reset(new content::BrowserPluginHost(this));
+}
+
 void WebContentsImpl::OnWebContentsDestroyed(WebContents* web_contents) {
   // Clear the opener if it has been closed.
   if (web_contents == opener_) {
     registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                       content::Source<WebContents>(opener_));
     opener_ = NULL;
   }
 }
 
 void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
@@ skipping 94 matching lines @@
   // script-related windows), by passing in the current SiteInstance.  However,
   // if the opener is being suppressed, we create a new SiteInstance in its own
   // BrowsingInstance.
   scoped_refptr<SiteInstance> site_instance =
       params.opener_suppressed ?
       SiteInstance::Create(GetBrowserContext()) :
       GetSiteInstance();
 
   // Create the new web contents. This will automatically create the new
   // WebContentsView. In the future, we may want to create the view separately.
-  WebContentsImpl* new_contents = new WebContentsImpl(
-      GetBrowserContext(),
-                          site_instance,
-                          route_id,
-                          this,
-                          params.opener_suppressed ? NULL : this,
-      static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace));
+  WebContentsImpl* new_contents =
+      CreateWithOpener(GetBrowserContext(),
+                       site_instance, route_id, this,
+                       params.opener_suppressed ? NULL : this);
+
+  int process_id = site_instance->GetProcess()->GetID();
+  const std::string& partition_id =
+      content::GetContentClient()->browser()
+          ->GetStoragePartitionIdForChildProcess(GetBrowserContext(),
+                                                 process_id);
+  SessionStorageNamespaceImpl* session_storage_namespace_impl =
+      static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
+  DOMStorageContextImpl* dom_storage_context =
+      static_cast<DOMStorageContextImpl*>(
+          BrowserContext::GetDOMStorageContextByPartitionId(GetBrowserContext(),
+                                                            partition_id));
+  CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
+  new_contents->GetController().SetSessionStorageNamespace(
+      partition_id,
+      session_storage_namespace);
   new_contents->set_opener_web_ui_type(GetWebUITypeForCurrentState());
 
   if (!params.opener_suppressed) {
     content::WebContentsView* new_view = new_contents->GetView();
 
     // TODO(brettw): It seems bogus that we have to call this function on the
     // newly created object and give it one of its own member variables.
     new_view->CreateViewForWidget(new_contents->GetRenderViewHost());
 
     // Save the created window associated with the route so we can show it
@@ skipping 773 matching lines @@
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
       content::Source<NavigationController>(&controller_),
       content::Details<content::LoadFromMemoryCacheDetails>(&details));
 }
 
 void WebContentsImpl::OnDidDisplayInsecureContent() {
   content::RecordAction(UserMetricsAction("SSL.DisplayedInsecureContent"));
   displayed_insecure_content_ = true;
-  SSLManager::NotifySSLInternalStateChanged(&GetControllerImpl());
+  SSLManager::NotifySSLInternalStateChanged(&GetController());
 }
 
 void WebContentsImpl::OnDidRunInsecureContent(
     const std::string& security_origin, const GURL& target_url) {
   LOG(INFO) << security_origin << " ran insecure content from "
             << target_url.possibly_invalid_spec();
   content::RecordAction(UserMetricsAction("SSL.RanInsecureContent"));
   if (EndsWith(security_origin, kDotGoogleDotCom, false))
     content::RecordAction(UserMetricsAction("SSL.RanInsecureContentGoogle"));
   controller_.ssl_manager()->DidRunInsecureContent(security_origin);
   displayed_insecure_content_ = true;
-  SSLManager::NotifySSLInternalStateChanged(&GetControllerImpl());
+  SSLManager::NotifySSLInternalStateChanged(&GetController());
 }
 
 void WebContentsImpl::OnDocumentLoadedInFrame(int64 frame_id) {
   controller_.DocumentLoadedInFrame();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DocumentLoadedInFrame(frame_id, message_source_));
 }
 
 void WebContentsImpl::OnDidFinishLoad(
     int64 frame_id,
@@ skipping 1004 matching lines @@
   // SiteInstance as well.
   if (opener_)
     opener_route_id = opener_->CreateOpenerRenderViews(instance);
 
   // Create a swapped out RenderView in the given SiteInstance if none exists,
   // setting its opener to the given route_id.  Return the new view's route_id.
   return render_manager_.CreateRenderView(instance, opener_route_id, true);
 }
 
 NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
-  return GetControllerImpl();
+  return GetController();
 }
 
 WebUIImpl* WebContentsImpl::CreateWebUIForRenderManager(const GURL& url) {
   return static_cast<WebUIImpl*>(CreateWebUI(url));
 }
 
 NavigationEntry*
     WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
@@ skipping 104 matching lines @@
       browser_plugin_host()->embedder_render_process_host();
   *embedder_container_id = browser_plugin_host()->instance_id();
   int embedder_process_id =
       embedder_render_process_host ? embedder_render_process_host->GetID() : -1;
   if (embedder_process_id != -1) {
     *embedder_channel_name =
         StringPrintf("%d.r%d", render_view_host->GetProcess()->GetID(),
                      embedder_process_id);
   }
 }