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 "content/public/browser/browser_thread.h"
+
 #include "chrome/browser/sessions/session_service.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
@@ skipping 10 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_context.h"
+#include "content/browser/in_process_webkit/dom_storage_namespace.h"
+#include "content/browser/in_process_webkit/session_storage_namespace.h"
+#include "content/browser/in_process_webkit/webkit_context.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_cppsafe_mac.h"
 #endif
 
@@ skipping 13 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 57 matching lines @@
 
 typedef IDAndIndexPayload TabNavigationPathPrunedFromFrontPayload;
 
 struct PinnedStatePayload {
   SessionID::id_type tab_id;
   bool pinned_state;
 };
 
 }  // namespace
 
+// SessionService needs to read data from DOMStorageContext and it can be only
+// done on the WEBKIT_DEPRECATED thread. This class is for reading the data. It
+// also takes into account that SessionService might get deleted before we have
+// a change to call it back.
+class SessionService::SessionStorageAssociationReader
+    : public base::RefCountedThreadSafe<
+        SessionService::SessionStorageAssociationReader> {
+ public:
+  SessionStorageAssociationReader(SessionService* session_service,
+                                  int64 namespace_id,
+                                  WebKitContext* webkit_context)
+      : session_service_(session_service),
+        namespace_id_(namespace_id),
+        webkit_context_(webkit_context) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
+        base::Bind(&SessionStorageAssociationReader::ReadData, this));
+  }
+  ~SessionStorageAssociationReader() { }
+
+ private:
+  friend class SessionService;
+
+  void ReadData() {
+    DOMStorageNamespace* dom_storage_namespace = webkit_context_->
+        dom_storage_context()->GetStorageNamespace(namespace_id_, false);
+    if (dom_storage_namespace != NULL) {
+      session_storage_directory_ =
+          dom_storage_namespace->session_storage_directory();
+    }
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&SessionStorageAssociationReader::ForwardData, this));
+  }
+
+  void ForwardData() {
+    // If SessionService gets destroyed before this object, it nullifies this
+    // pointer.
+    if (session_service_) {
+      session_service_->AssociateSessionStorage(this, namespace_id_,
+                                                session_storage_directory_);
+    }
+  }
+
+  SessionService* session_service_;
+  int64 namespace_id_;
+  WebKitContext* webkit_context_;
+  FilePath session_storage_directory_;
+};
+
 // SessionService -------------------------------------------------------------
 
 SessionService::SessionService(Profile* profile)
     : BaseSessionService(SESSION_RESTORE, profile, FilePath()),
       has_open_trackable_browsers_(false),
       move_on_new_browser_(false),
       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
       save_delay_in_hrs_(base::TimeDelta::FromHours(8)) {
   Init();
 }
 
 SessionService::SessionService(const FilePath& save_path)
     : BaseSessionService(SESSION_RESTORE, NULL, save_path),
       has_open_trackable_browsers_(false),
       move_on_new_browser_(false),
       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
       save_delay_in_hrs_(base::TimeDelta::FromHours(8)) {
   Init();
 }
 
 SessionService::~SessionService() {
   Save();
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  for (SessionStorageAssociationReaders::const_iterator it =
+           session_storage_association_readers_.begin();
+       it != session_storage_association_readers_.end();
+       ++it) {
+    // This is done in the UI thread. SessionStorageAssociationReader only
+    // accesses session_service_ in the UI thread, so this is safe.
+    it->first->session_service_ = NULL;
+  }
+  // References from SessionService to SessionStorageAssociationReader will be
+  // automatically dropped as session_storage_association_readers_ is destroyed.
 }
 
 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open) {
   return RestoreIfNecessary(urls_to_open, NULL);
 }
 
 void SessionService::ResetFromCurrentBrowsers() {
   ScheduleReset();
 }
 
@@ skipping 271 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_SESSION_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->web_contents()->GetController().GetSessionStorageNamespace();
+      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_SESSION_STORAGE_NAMESPACE_CREATED: {
+      content::Details<SessionStorageCreatedDetails>
+          namespace_created_details(details);
+      CreateAndScheduleSessionStorageCreatedCommand(
+          namespace_created_details->id,
+          namespace_created_details->session_storage_directory);
+      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 113 matching lines @@
     bool is_pinned) {
   PinnedStatePayload payload = { 0 };
   payload.tab_id = tab_id.id();
   payload.pinned_state = is_pinned;
   SessionCommand* command =
       new SessionCommand(kCommandSetPinnedState, sizeof(payload));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
+void SessionService::CreateAndScheduleSessionStorageCreatedCommand(
+    int64 namespace_id,
+    const FilePath& directory) {
+  SessionStorageNamespaceMap::const_iterator it =
+      session_storage_namespace_map_.find(namespace_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(directory.value());
+    ScheduleCommand(new SessionCommand(kCommandSessionStorageCreated,
+                                       session_storage_created_pickle));
+  }
+}
+
 void SessionService::OnGotSessionCommands(
     Handle handle,
     scoped_refptr<InternalGetCommandsRequest> request) {
   if (request->canceled())
     return;
 
   ScopedVector<SessionWindow> valid_windows;
   RestoreSessionFromCommands(
       request->commands, &(valid_windows.get()));
   static_cast<InternalSessionRequest*>(request.get())->
       real_callback.Run(request->handle(), &(valid_windows.get()));
 }
 
 void SessionService::RestoreSessionFromCommands(
     const std::vector<SessionCommand*>& commands,
     std::vector<SessionWindow*>* valid_windows) {
   std::map<int, SessionTab*> tabs;
   std::map<int, SessionWindow*> windows;
 
-  if (CreateTabsAndWindows(commands, &tabs, &windows)) {
+  // Keeps track of which sessionStorages are in use after session restore, so
+  // that the rest can be deleted.
+  std::set<std::string> needed_session_storages;
+
+  if (CreateTabsAndWindows(commands, &tabs, &windows,
+                           &needed_session_storages)) {
     AddTabsToWindows(&tabs, &windows);
     SortTabsBasedOnVisualOrderAndPrune(&windows, valid_windows);
     UpdateSelectedTabIndex(valid_windows);
   }
+
+  profile()->GetWebKitContext()->DeleteUnneededSessionStorages(
+      needed_session_storages);
+
   STLDeleteValues(&tabs);
   // Don't delete conents of windows, that is done by the caller as all
   // valid windows are added to valid_windows.
 }
 
 void SessionService::UpdateSelectedTabIndex(
     std::vector<SessionWindow*>* windows) {
   for (std::vector<SessionWindow*>::const_iterator i = windows->begin();
        i != windows->end(); ++i) {
     // See note in SessionWindow as to why we do this.
@@ skipping 117 matching lines @@
       // Never got a set tab index in window, or tabs are empty, nothing
       // to do.
       ++i;
     }
   }
 }
 
 bool SessionService::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) {
   // If the file is corrupt (command with wrong size, or unknown command), we
   // still return true and attempt to restore what we we can.
 
   for (std::vector<SessionCommand*>::const_iterator i = data.begin();
        i != data.end(); ++i) {
     const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
     const SessionCommand* command = *i;
 
     switch (command->id()) {
       case kCommandSetTabWindow: {
@@ skipping 155 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);
+        needed_session_storages->insert(session_storage_directory);
+        break;
+      }
 
       default:
         return true;
     }
   }
   return true;
 }
 
 void SessionService::BuildCommandsForTab(
     const SessionID& window_id,
     TabContentsWrapper* tab,
     int index_in_window,
     bool is_pinned,
     std::vector<SessionCommand*>* commands,
     IdToRange* tab_to_available_range) {
   DCHECK(tab && commands && window_id.id());
   const SessionID& session_id(tab->restore_tab_helper()->session_id());
   commands->push_back(CreateSetTabWindowCommand(window_id, session_id));
+
+  // Schedule reading the session storage directory on the WEBKIT_DEPRECATED
+  // thread.
+  int64 namespace_id =
+      tab->web_contents()->GetController().GetSessionStorageNamespace()->id();
+  WebKitContext* webkit_context = profile()->GetWebKitContext();
+  scoped_refptr<SessionStorageAssociationReader> reader =
+      new SessionStorageAssociationReader(this, namespace_id, webkit_context);
+  session_storage_association_readers_[reader.get()] = reader;
+
   const int current_index =
       tab->web_contents()->GetController().GetCurrentEntryIndex();
   const int min_index = std::max(0,
                                  current_index - max_persist_navigation_count);
   const int max_index =
       std::min(current_index + max_persist_navigation_count,
                tab->web_contents()->GetController().GetEntryCount());
   const int pending_index =
       tab->web_contents()->GetController().GetPendingEntryIndex();
   if (tab_to_available_range) {
@@ skipping 384 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);
   }
 }
+
+void SessionService::AssociateSessionStorage(
+    SessionStorageAssociationReader* reader,
+    int64 namespace_id,
+    const FilePath& directory) {
+  if (!directory.empty()) {
+    CreateAndScheduleSessionStorageCreatedCommand(
+        namespace_id, directory);
+  }
+  session_storage_association_readers_.erase(reader);
+}