Restore sessionStorage when chrome restarts.

chrome/browser/sessions/session_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_
 #define CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_
 #pragma once
 
 #include <map>
+#include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/time.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/sessions/base_session_service.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 151 matching lines @@
   // callback invokes OnGotSessionCommands from which we map the
   // SessionCommands to browser state, then notify the callback.
   Handle GetLastSession(CancelableRequestConsumerBase* consumer,
                         const SessionCallback& callback);
 
   // Overridden from BaseSessionService because we want some UMA reporting on
   // session update activities.
   virtual void Save() OVERRIDE;
 
  private:
+  class SessionStorageAssociationReader;
+
   typedef std::map<SessionID::id_type, std::pair<int, int> > IdToRange;
   typedef std::map<SessionID::id_type, SessionTab*> IdToSessionTab;
   typedef std::map<SessionID::id_type, SessionWindow*> IdToSessionWindow;
 
 
   // These types mirror Browser::Type, but are re-defined here because these
   // specific enumeration _values_ are written into the session database and
   // are needed to maintain forward compatibility.
   // Note that we only store browsers of type TYPE_TABBED and TYPE_POPUP.
   enum WindowType {
@@ skipping 39 matching lines @@
   SessionCommand* CreateSetSelectedNavigationIndexCommand(
       const SessionID& tab_id,
       int index);
 
   SessionCommand* CreateSetWindowTypeCommand(const SessionID& window_id,
                                              WindowType type);
 
   SessionCommand* CreatePinnedStateCommand(const SessionID& tab_id,
                                            bool is_pinned);
 
+  void CreateAndScheduleSessionStorageCreatedCommand(
+      int64 namespace_id,
+      const FilePath& directory);
+
   // Callback from the backend for getting the commands from the save file.
   // Converts the commands in SessionWindows and notifies the real callback.
   void OnGotSessionCommands(
       Handle handle,
       scoped_refptr<InternalGetCommandsRequest> request);
 
   // Converts the commands into SessionWindows. On return any valid
   // windows are added to valid_windows. It is up to the caller to delete
   // the windows added to valid_windows.
   //
@@ skipping 42 matching lines @@
                         std::map<int, SessionWindow*>* windows);
 
   // Creates tabs and windows from the specified commands. The created tabs
   // and windows are added to |tabs| and |windows| respectively. It is up to
   // the caller to delete the tabs and windows added to |tabs| and |windows|.
   //
   // This does NOT add any created SessionTabs to SessionWindow.tabs, that is
   // done by AddTabsToWindows.
   bool CreateTabsAndWindows(const std::vector<SessionCommand*>& data,
                             std::map<int, SessionTab*>* tabs,
-                            std::map<int, SessionWindow*>* windows);
+                            std::map<int, SessionWindow*>* windows,
+                            std::set<std::string>* needed_session_storages);
 
   // Adds commands to commands that will recreate the state of the specified
   // tab. This adds at most kMaxNavigationCountToPersist navigations (in each
   // direction from the current navigation index).
   // A pair is added to tab_to_available_range indicating the range of
   // indices that were written.
   void BuildCommandsForTab(
       const SessionID& window_id,
       TabContentsWrapper* tab,
       int index_in_window,
@@ skipping 72 matching lines @@
     base::TimeTicks* last_updated_time);
 
   // Helper methods to record the histogram data
   void RecordUpdatedTabClosed(base::TimeDelta delta, bool use_long_period);
   void RecordUpdatedNavListPruned(base::TimeDelta delta, bool use_long_period);
   void RecordUpdatedNavEntryCommit(base::TimeDelta delta, bool use_long_period);
   void RecordUpdatedSaveTime(base::TimeDelta delta, bool use_long_period);
   void RecordUpdatedSessionNavigationOrTab(base::TimeDelta delta,
                                            bool use_long_period);
 
+  // Callback for SessionStorageAssociationReader.
+  void AssociateSessionStorage(SessionStorageAssociationReader* reader,
+                               int64 namespace_id,
+                               const FilePath& directory);
+
   // Convert back/forward between the Browser and SessionService DB window
   // types.
   static WindowType WindowTypeForBrowserType(Browser::Type type);
   static Browser::Type BrowserTypeForWindowType(WindowType type);
 
   content::NotificationRegistrar registrar_;
 
   // Maps from session tab id to the range of navigation entries that has
   // been written to disk.
   //
@@ skipping 25 matching lines @@
 
   // Are there any open trackable browsers?
   bool has_open_trackable_browsers_;
 
   // If true and a new tabbed browser is created and there are no opened tabbed
   // browser (has_open_trackable_browsers_ is false), then the current session
   // is made the last session. See description above class for details on
   // current/last session.
   bool move_on_new_browser_;
 
+  // Map from session storage namespace id (stored by |SessionStorageNamespace|)
+  // to a pair (window_id, tab_id).
+  typedef std::map<int64,
+                   std::pair<SessionID, SessionID> > SessionStorageNamespaceMap;
+
+  SessionStorageNamespaceMap session_storage_namespace_map_;
+
   // Used for reporting frequency of session altering operations.
   base::TimeTicks last_updated_tab_closed_time_;
   base::TimeTicks last_updated_nav_list_pruned_time_;
   base::TimeTicks last_updated_nav_entry_commit_time_;
   base::TimeTicks last_updated_save_time_;
 
   // Constants used in calculating histogram data.
   const base::TimeDelta save_delay_in_millis_;
   const base::TimeDelta save_delay_in_mins_;
   const base::TimeDelta save_delay_in_hrs_;
 
+  // For keeping track of |SessionStorageAssociationReader|s which are active at
+  // the moment. When destructed, this map will drop the references to them. The
+  // destructor of |SessionService| uses this map for nullifying the pointers in
+  // the |SessionStorageAssociationReader|s so that they won't call
+  // |SessionService| back after finishing their operations.
+  typedef std::map<SessionStorageAssociationReader*,
+                   scoped_refptr<SessionStorageAssociationReader> >
+      SessionStorageAssociationReaders;
+  SessionStorageAssociationReaders session_storage_association_readers_;
+
   DISALLOW_COPY_AND_ASSIGN(SessionService);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_