Restore sessionStorage when chrome restarts.

chrome/browser/sessions/session_service.cc

 // Copyright (c) 2011 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_service.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 14 matching lines @@
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
+#include "content/browser/in_process_webkit/dom_storage_namespace.h"
+#include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_details.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_cppsafe_mac.h"
 #endif
 
@@ skipping 12 matching lines @@
 static const SessionCommand::id_type kCommandSetSelectedNavigationIndex = 7;
 static const SessionCommand::id_type kCommandSetSelectedTabInIndex = 8;
 static const SessionCommand::id_type kCommandSetWindowType = 9;
 // OBSOLETE Superseded by kCommandSetWindowBounds3. Except for data migration.
 // static const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
+static const SessionCommand::id_type kCommandSessionStorageCreated = 15;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
 // The callback from GetLastSession is internally routed to SessionService
 // first and then the caller. This is done so that the SessionWindows can be
 // recreated from the SessionCommands and the SessionWindows passed to the
 // caller. The following class is used for this.
@@ skipping 371 matching lines @@
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
       content::NotificationService::AllSources());
+  registrar_.Add(this, content::NOTIFICATION_DOM_STORAGE_NAMESPACE_CREATED,
+                 content::NotificationService::AllSources());
 }
 
 bool SessionService::ShouldNewWindowStartSession() {
   if (!has_open_trackable_browsers_ && !BrowserInit::InProcessStartup() &&
       !SessionRestore::IsRestoring()
 #if defined(OS_MACOSX)
       // OSX has a fairly different idea of application lifetime than the
       // other platforms. We need to check that we aren't opening a window
       // from the dock or the menubar.
       && !app_controller_mac::IsOpeningNewWindow()
@@ skipping 42 matching lines @@
       RestoreIfNecessary(std::vector<GURL>(), browser);
       SetWindowType(browser->session_id(), browser->type());
       break;
     }
 
     case content::NOTIFICATION_TAB_PARENTED: {
       TabContentsWrapper* tab =
           content::Source<TabContentsWrapper>(source).ptr();
       if (tab->profile() != profile())
         return;
+
+      // Record the association between the sessionStorage namespace and the
+      // tab.
+      SessionStorageNamespace* session_storage_namespace =
+          tab->tab_contents()->controller().session_storage_namespace();
+      session_storage_namespace_map_[session_storage_namespace->id()] =
+          std::make_pair(tab->restore_tab_helper()->window_id(),
+                         tab->restore_tab_helper()->session_id());
+
       SetTabWindow(tab->restore_tab_helper()->window_id(),
                    tab->restore_tab_helper()->session_id());
       if (tab->extension_tab_helper()->extension_app()) {
         SetTabExtensionAppID(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->extension_tab_helper()->extension_app()->id());
       }
       break;
     }
@@ skipping 88 matching lines @@
       if (extension_tab_helper->extension_app()) {
         RestoreTabHelper* helper =
             extension_tab_helper->tab_contents_wrapper()->restore_tab_helper();
         SetTabExtensionAppID(helper->window_id(),
                              helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
     }
 
+    case content::NOTIFICATION_DOM_STORAGE_NAMESPACE_CREATED: {
+      content::Details<DOMStorageNamespaceCreatedDetails>
+          namespace_created_details(details);
+
+      SessionStorageNamespaceMap::const_iterator it =
+          session_storage_namespace_map_.find(namespace_created_details->id);
+      if (it != session_storage_namespace_map_.end()) {
+        Pickle session_storage_created_pickle;
+        session_storage_created_pickle.WriteInt(it->second.first.id());
+        session_storage_created_pickle.WriteInt(it->second.second.id());
+        session_storage_created_pickle.WriteString(
+            namespace_created_details->session_storage_directory.value());
+        ScheduleCommand(new SessionCommand(kCommandSessionStorageCreated,

[michaeln, 2011/12/13 20:40:03]

I'm not at all familiar with this SessionService class or its base. Can you tell
me about what it means to 'schedule a command' and wassup with the ResetCommand
stuff?

[marja, 2012/01/11 15:17:53]

ScheduleCommand puts the command into a queue and schedules it to be written to
the disk later. When the session is restored, these commands are then read from
the disk and the session is constructed based on them.

ScheduleReset builds the set of commands again based on the current windows,
tabs, and navigations, and when they are eventually written to the disk, the
previous commands are discarded.

And this CL has a problem that it doesn't take the ScheduleReset into account.
Yet.

+                                           session_storage_created_pickle));
+      }
+      break;
+    }
+
     default:
       NOTREACHED();
   }
 }
 
 void SessionService::SetTabExtensionAppID(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& extension_app_id) {
   if (!ShouldTrackChangesToWindow(window_id))
@@ skipping 450 matching lines @@
         SessionID::id_type tab_id;
         std::string extension_app_id;
         if (!RestoreSetTabExtensionAppIDCommand(
                 *command, &tab_id, &extension_app_id)) {
           return true;
         }
 
         GetTab(tab_id, tabs)->extension_app_id.swap(extension_app_id);
         break;
       }
+      case kCommandSessionStorageCreated: {
+        scoped_ptr<Pickle> pickle(command->PayloadAsPickle());
+        SessionID::id_type window_id;
+        SessionID::id_type tab_id;
+        std::string session_storage_directory;
+        void* iter = NULL;
+        pickle->ReadInt(&iter, &window_id);
+        pickle->ReadInt(&iter, &tab_id);
+        pickle->ReadString(&iter, &session_storage_directory);
+        GetTab(tab_id, tabs)->session_storage_directory =
+            FilePath(session_storage_directory);
+        break;
+      }
 
       default:
         return true;
     }
   }
   return true;
 }
 
 void SessionService::BuildCommandsForTab(
     const SessionID& window_id,
@@ skipping 402 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }