Restart running apps when chrome restarts.

chrome/browser/sessions/session_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_
 #define CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_
 
 #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"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/base/ui_base_types.h"
 
 class Profile;
 class SessionCommand;
 class TabContents;
 struct SessionTab;
 struct SessionWindow;
 
 namespace content {
 class NavigationEntry;
 }
 
+namespace extensions {
+  class ExtensionHost;

[sky, 2012/08/23 16:23:52]

don't indent.

[koz (OOO until 15th September), 2012/08/24 02:08:57]

Done.

+}
+
 // SessionService ------------------------------------------------------------
 
 // SessionService is responsible for maintaining the state of open windows
 // and tabs so that they can be restored at a later date. The state of the
 // currently open browsers is referred to as the current session.
 //
 // SessionService supports restoring from the last session. The last session
 // typically corresponds to the last run of the browser, but not always. For
 // example, if the user has a tabbed browser and app window running, closes the
 // tabbed browser, then creates a new tabbed browser the current session is made
@@ skipping 126 matching lines @@
   void SetTabUserAgentOverride(const SessionID& window_id,
                                const SessionID& tab_id,
                                const std::string& user_agent_override);
 
   // Callback from GetSavedSession of GetLastSession.
   //
   // The contents of the supplied vector are deleted after the callback is
   // notified. To take ownership of the vector clear it before returning.
   //
   // The time gives the time the session was closed.
-  typedef base::Callback<void(Handle, std::vector<SessionWindow*>*)>
+  typedef base::Callback<void(Handle, std::vector<SessionWindow*>*,
+                              std::set<std::string>*)>

[sky, 2012/08/23 16:23:52]

Can set the set be by reference?

[koz (OOO until 15th September), 2012/08/24 02:08:57]

Done.

       SessionCallback;
 
   // Fetches the contents of the last session, notifying the callback when
   // done. If the callback is supplied an empty vector of SessionWindows
   // it means the session could not be restored.
   //
   // The created request does NOT directly invoke the callback, rather the
   // callback invokes OnGotSessionCommands from which we map the
   // SessionCommands to browser state, then notify the callback.
   Handle GetLastSession(CancelableRequestConsumerBase* consumer,
@@ skipping 60 matching lines @@
   SessionCommand* CreateSetWindowTypeCommand(const SessionID& window_id,
                                              WindowType type);
 
   SessionCommand* CreatePinnedStateCommand(const SessionID& tab_id,
                                            bool is_pinned);
 
   SessionCommand* CreateSessionStorageAssociatedCommand(
       const SessionID& tab_id,
       const std::string& session_storage_persistent_id);
 
+  SessionCommand* CreateRunAppCommand(const std::string& extension_id);
+  SessionCommand* CreateStopAppCommand(const std::string& extension_id);
+
   // 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

[sky, 2012/08/23 16:23:52]

Update description.

[koz (OOO until 15th September), 2012/08/24 02:08:57]

Done.

   // windows are added to valid_windows. It is up to the caller to delete
   // the windows added to valid_windows.
   //
   // If ignore_recent_closes is true, any window/tab closes within in a certain
   // time frame are ignored.
   void RestoreSessionFromCommands(const std::vector<SessionCommand*>& commands,
-                                  std::vector<SessionWindow*>* valid_windows);
+                                  std::vector<SessionWindow*>* valid_windows,
+                                  std::set<std::string>* apps);
 
   // Iterates through the vector updating the selected_tab_index of each
   // SessionWindow based on the actual tabs that were restored.
   void UpdateSelectedTabIndex(std::vector<SessionWindow*>* windows);
 
   // Returns the window in windows with the specified id. If a window does
   // not exist, one is created.
   SessionWindow* GetWindow(SessionID::id_type window_id,
                            IdToSessionWindow* windows);
 
@@ skipping 28 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>* apps);
 
   // 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,
       TabContents* tab,
       int index_in_window,
@@ skipping 12 matching lines @@
 
   // Iterates over all the known browsers invoking BuildCommandsForBrowser.
   // This only adds browsers that should be tracked
   // (should_track_changes_for_browser_type returns true). All browsers that
   // are tracked are added to windows_to_track (as long as it is non-null).
   void BuildCommandsFromBrowsers(
       std::vector<SessionCommand*>* commands,
       IdToRange* tab_to_available_range,
       std::set<SessionID::id_type>* windows_to_track);
 
+  // Iterates over all known running apps and adds a command to start them to
+  // |comands|.
+  void BuildCommandsFromRunningApps(std::vector<SessionCommand*>* commands);
+
   // Schedules a reset. A reset means the contents of the file are recreated
   // from the state of the browser.
   void ScheduleReset();
 
   // Searches for a pending command that can be replaced with command.
   // If one is found, pending command is removed, command is added to
   // the pending commands and true is returned.
   bool ReplacePendingCommand(SessionCommand* command);
 
   // Schedules the specified command. This method takes ownership of the
@@ skipping 103 matching lines @@
 
   // 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 browser_tests, since we want to simulate the browser shutting down
   // without quitting.
   bool force_browser_not_alive_with_no_windows_;
 
+  // Tracks the apps that are currently running so we can calculate the commands
+  // needed to re-open them in a reset.
+  std::set<extensions::ExtensionHost*> running_apps_;

[sky, 2012/08/23 16:23:52]

I think this should be ordered. Otherwise when you restart the apps won't start
in the order they were launched.

[koz (OOO until 15th September), 2012/08/24 02:08:57]

Due to the asynchronous nature in which apps run I don't think it matters which
order they are started in. That is, we restart the apps by dispatching an
onRestarted() event to them, which will be delivered asynchronously.

+
   DISALLOW_COPY_AND_ASSIGN(SessionService);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_