Persist sessionStorage on disk.

chrome/browser/sessions/session_service.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_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 15 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/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
+#include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_mac.h"
 #endif
 
 using base::Time;
 using content::NavigationEntry;
 
 // Identifier for commands written to file.
@@ skipping 15 matching lines @@
 // 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 kCommandSetWindowAppName = 15;
 static const SessionCommand::id_type kCommandTabClosed = 16;
 static const SessionCommand::id_type kCommandWindowClosed = 17;
 static const SessionCommand::id_type kCommandSetTabUserAgentOverride = 18;
+static const SessionCommand::id_type kCommandSessionStorageAssociated = 19;
 
 // 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 508 matching lines @@
       if (tab->profile() != profile())
         return;
       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());
       }
+
+      // Record the association between the sessionStorage namespace and the
+      // tab.
+      content::SessionStorageNamespace* session_storage_namespace =
+          tab->web_contents()->GetController().GetSessionStorageNamespace();
+      ScheduleCommand(CreateSessionStorageAssociatedCommand(
+          tab->restore_tab_helper()->session_id(),
+          session_storage_namespace->persistent_id()));
       break;
     }
 
     case chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
       TabContentsWrapper* tab =
           content::Source<TabContentsWrapper>(source).ptr();
       if (!tab || tab->profile() != profile())
         return;
+      // Allow the associated sessionStorage to get deleted; it won't be needed
+      // in the session restore.

[michaeln, 2012/06/08 01:04:21]

I see that NOTIFICATION_TAB_CONTENTS_DESTROYED happens when closing a tab. But i
also see that NOTIFICATION_TAB_PARENTED happens to wake it up if the user
reopens a recently closed page via the  drop down menu at the bottom-right of
the new-tab-page. In this reopen case, the same SessionStorageNamespace instance
is there ready to go. But since the data was doomed in
NOTIFICATION_TAB_CONTENTS_DESTROYED, it won't be avaialble for later session
restoration. Do we need an UnDoom() method too for use in the PARENTED case? Or
maybe there's another way to manage which to keep|discard?

What if content::SessionStorageNamespace had another property (getter/setter) to
control keep vs discard behavior?

class SessionStorageNamespace {
  int64 id();
  std::string persistent_id();
  bool should_persist();
  void SetShouldPersist(bool persist);
}

Upon object creation, should persist is false. 
In PARENTED, chrome calls SetShouldPersist(true).
In DESTROYED, chrome calls SetShouldPersist(false).

While the namespace exists, data is put in the db regardless of how the value is
set at. It can toggle back and forth during its lifetime w/o any immediate side
effects. But at SessionStorageNamespace final release time or DomStorageContext
shutdown time (whichever comes first), the attribute value is used to determine
whether to delete or not from the db.

We still have the issue of deleting 'left over' stuff at some point. After
restarting and either restoring tabs or having determined that we wont be
restoring old tabs (when the infobar is dismissed maybe), that might be a good
time to start deleting left over stuff. I think any session in the db for which
there is no live SessionStorageNamespace instance is probably eligible for
deletion at this time. The lower-level DomStorageContext could retrieve a list
of those in the db, remove live ids from that list, and lazily call delete on
the remaining items... delete one every 60 seconds till there gone type of
thing. Something in the public 'content' api to kick that off...
   DOMStorageContext::StartScavengingUnusedSessionStorage().

wdyt?

[marja, 2012/06/19 13:17:17]

Did the SetShouldPersist change; it's cleaner now.

For the DOMStorageContext::StartScavengingUnusedSessionStorage() change I'd need
to add code to send a signal when the infobar is dismissed, and it's harder than
it sounds to add that (at least the last time I tried I bumped into some unclear
ownership of infobars and other complications). If you think it's important that
it's done that way, I'll start working on it.

+      content::SessionStorageNamespace* session_storage_namespace =
+          tab->web_contents()->GetController().GetSessionStorageNamespace();
+      content::BrowserContext::GetDOMStorageContext(profile())->
+          DoomSessionStorage(session_storage_namespace->persistent_id());
       TabClosed(tab->restore_tab_helper()->window_id(),
                 tab->restore_tab_helper()->session_id(),
                 tab->web_contents()->GetClosedByUserGesture());
       RecordSessionUpdateHistogramData(type, &last_updated_tab_closed_time_);
       break;
     }
 
     case content::NOTIFICATION_NAV_LIST_PRUNED: {
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
@@ skipping 215 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;
 }
 
+SessionCommand* SessionService::CreateSessionStorageAssociatedCommand(
+    const SessionID& tab_id,
+    const std::string& session_storage_persistent_id) {
+  Pickle pickle;
+  pickle.WriteInt(tab_id.id());
+  pickle.WriteString(session_storage_persistent_id);
+  return new SessionCommand(kCommandSessionStorageAssociated, 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())->
@@ skipping 376 matching lines @@
         std::string user_agent_override;
         if (!RestoreSetTabUserAgentOverrideCommand(
                 *command, &tab_id, &user_agent_override)) {
           return true;
         }
 
         GetTab(tab_id, tabs)->user_agent_override.swap(user_agent_override);
         break;
       }
 
+      case kCommandSessionStorageAssociated: {
+        scoped_ptr<Pickle> pickle(command->PayloadAsPickle());
+        SessionID::id_type tab_id;
+        std::string session_storage_persistent_id;
+        PickleIterator iter(*pickle.get());
+        pickle->ReadInt(&iter, &tab_id);
+        pickle->ReadString(&iter, &session_storage_persistent_id);
+        // Associate the session storage back.
+        GetTab(tab_id, tabs)->session_storage_persistent_id =
+            session_storage_persistent_id;
+        break;
+      }
+
       default:
         VLOG(1) << "Failed reading an unknown command " << command->id();
         return true;
     }
   }
   return true;
 }
 
 void SessionService::BuildCommandsForTab(
     const SessionID& window_id,
@@ skipping 51 matching lines @@
               kCommandUpdateTabNavigation, session_id.id(), i, *entry));
     }
   }
   commands->push_back(
       CreateSetSelectedNavigationIndexCommand(session_id, current_index));
 
   if (index_in_window != -1) {
     commands->push_back(
         CreateSetTabIndexInWindowCommand(session_id, index_in_window));
   }
+
+  // Record the association between the sessionStorage namespace and the tab.
+  content::SessionStorageNamespace* session_storage_namespace =
+      tab->web_contents()->GetController().GetSessionStorageNamespace();
+  ScheduleCommand(CreateSessionStorageAssociatedCommand(
+      tab->restore_tab_helper()->session_id(),
+      session_storage_namespace->persistent_id()));
 }
 
 void SessionService::BuildCommandsForBrowser(
     Browser* browser,
     std::vector<SessionCommand*>* commands,
     IdToRange* tab_to_available_range,
     std::set<SessionID::id_type>* windows_to_track) {
   DCHECK(browser && commands);
   DCHECK(browser->session_id().id());
 
@@ skipping 362 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);
   }
 }