Make session restore understand that tabs have multiple SessionStorageNamespaces.

chrome/browser/sessions/session_restore.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/sessions/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
@@ skipping 49 matching lines @@
 namespace {
 
 class SessionRestoreImpl;
 class TabLoader;
 
 TabLoader* shared_tab_loader = NULL;
 
 // Pointers to SessionRestoreImpls which are currently restoring the session.
 std::set<SessionRestoreImpl*>* active_session_restorers = NULL;
 
+// Helper to use with BrowserContext::ForEachStoragePartition().
+void StartScavengingUnusedSessionStorage(const std::string& id,
+                                         content::StoragePartition* storage_partition) {
+  storage_partition->GetDOMStorageContext()->
+      StartScavengingUnusedSessionStorage();
+}
+
 // TabLoader ------------------------------------------------------------------
 
 // Initial delay (see class decription for details).
 static const int kInitialDelayTimerMS = 100;
 
 // TabLoader is responsible for loading tabs after session restore creates
 // tabs. New tabs are loaded after the current tab finishes loading, or a delay
 // is reached (initially kInitialDelayTimerMS). If the delay is reached before
 // a tab finishes loading a new tab is loaded and the time of the delay
 // doubled.
@@ skipping 507 matching lines @@
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     if (disposition == CURRENT_TAB) {
       DCHECK(!use_new_window);
       chrome::ReplaceRestoredTab(browser,
                                  tab.navigations,
                                  selected_index,
                                  true,
                                  tab.extension_app_id,
-                                 NULL,
+                                 content::SessionStorageNamespaceMap(),
                                  tab.user_agent_override);
     } else {
       int tab_index = use_new_window ? 0 : browser->active_index() + 1;
       WebContents* web_contents = chrome::AddRestoredTab(
           browser,
           tab.navigations,
           tab_index,
           selected_index,
           tab.extension_app_id,
           false,  // selected
           tab.pinned,
           true,
-          NULL,
+          content::SessionStorageNamespaceMap(),
           tab.user_agent_override);
       // Start loading the tab immediately.
       web_contents->GetController().LoadIfNecessary();
     }
 
     if (use_new_window) {
       chrome::ActivateTabAt(browser, 0, true);
       browser->window()->Show();
     }
     NotifySessionServiceOfRestoredTabs(browser, browser->tab_count());
@@ skipping 113 matching lines @@
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "SessionRestore.TimeToProcessSessions",
         time_to_process_sessions,
         base::TimeDelta::FromMilliseconds(10),
         base::TimeDelta::FromSeconds(1000),
         100);
 
     if (windows->empty()) {
       // Restore was unsuccessful. The DOM storage system can also delete its
       // data, since no session restore will happen at a later point in time.
-      content::BrowserContext::GetDefaultStoragePartition(profile_)->
-          GetDOMStorageContext()->StartScavengingUnusedSessionStorage();
+      content::BrowserContext::ForEachStoragePartition(
+          profile_,
+          base::Bind(&StartScavengingUnusedSessionStorage));
       return FinishedTabCreation(false, false);
     }
 
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-CreatingTabs-Start", false);
 #endif
     StartTabCreation();
 
     // After the for loop this contains the last TABBED_BROWSER. Is null if no
@@ skipping 72 matching lines @@
     // If last_browser is NULL and urls_to_open_ is non-empty,
     // FinishedTabCreation will create a new TabbedBrowser and add the urls to
     // it.
     Browser* finished_browser = FinishedTabCreation(true, has_tabbed_browser);
     if (finished_browser)
       last_browser = finished_browser;
 
     // sessionStorages needed for the session restore have now been recreated
     // by RestoreTab. Now it's safe for the DOM storage system to start
     // deleting leftover data.
-    content::BrowserContext::GetDefaultStoragePartition(profile_)->
-        GetDOMStorageContext()->StartScavengingUnusedSessionStorage();
+    content::BrowserContext::ForEachStoragePartition(
+        profile_,
+        base::Bind(&StartScavengingUnusedSessionStorage));
     return last_browser;
   }
 
   // Record an app launch event (if appropriate) for a tab which is about to
   // be restored. Callers should ensure that selected_index is within the
   // bounds of tab.navigations before calling.
   void RecordAppLaunchForTab(Browser* browser,
                              const SessionTab& tab,
                              int selected_index) {
     DCHECK(selected_index >= 0 &&
@@ skipping 34 matching lines @@
     DCHECK(!tab.navigations.empty());
     int selected_index = tab.current_navigation_index;
     selected_index = std::max(
         0,
         std::min(selected_index,
                  static_cast<int>(tab.navigations.size() - 1)));
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     // Associate sessionStorage (if any) to the restored tab.
-    scoped_refptr<content::SessionStorageNamespace> session_storage_namespace;
-    if (!tab.session_storage_persistent_id.empty()) {
-      session_storage_namespace =
-          content::BrowserContext::GetDefaultStoragePartition(profile_)->
-              GetDOMStorageContext()->RecreateSessionStorage(
-                  tab.session_storage_persistent_id);
+    content::SessionStorageNamespaceMap restored_session_storage_namespaces;
+    for (std::map<std::string, std::string>::const_iterator it =
+          tab.session_storage_persistent_id_map.begin();
+          it != tab.session_storage_persistent_id_map.end();
+          ++it) {
+      using content::BrowserContext;
+      if (BrowserContext::IsValidPartitionId(profile_, it->first)) {
+        content::StoragePartition* partition =
+            BrowserContext::GetStoragePartitionById(profile_, it->first);
+        restored_session_storage_namespaces[it->first] =
+            partition->GetDOMStorageContext()->
+                RecreateSessionStorage(it->second);
+      }
     }
 
     WebContents* web_contents =
         chrome::AddRestoredTab(browser,
                                tab.navigations,
                                tab_index,
                                selected_index,
                                tab.extension_app_id,
                                false,  // select
                                tab.pinned,
                                true,
-                               session_storage_namespace.get(),
+                               restored_session_storage_namespaces,
                                tab.user_agent_override);
     // Regression check: check that the tab didn't start loading right away. The
     // focused tab will be loaded by Browser, and TabLoader will load the rest.
     DCHECK(web_contents->GetController().NeedsReload());
 
     // Set up the file access rights for the selected navigation entry.
     const int id = web_contents->GetRenderProcessHost()->GetID();
     const int read_file_permissions =
         base::PLATFORM_FILE_OPEN |
         base::PLATFORM_FILE_READ |
@@ skipping 185 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }