Refactoring of SessionService to get componentized.

chrome/browser/sessions/session_service.h

Index: chrome/browser/sessions/session_service.h
diff --git a/chrome/browser/sessions/session_service.h b/chrome/browser/sessions/session_service.h
index d602669ea8aebd5c943ae437b61d310b5b0b600b..6ecc461b5e00bc66708de4b7186287475046309b 100644
--- a/chrome/browser/sessions/session_service.h
+++ b/chrome/browser/sessions/session_service.h
@@ -16,6 +16,7 @@
 #include "base/time/time.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/sessions/base_session_service.h"
+#include "chrome/browser/sessions/session_service_commands.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list_observer.h"
@@ -49,24 +50,19 @@ class WebContents;
 // illusion that app windows run in separate processes. Similar behavior occurs
 // with incognito windows.
 //
-// SessionService itself maintains a set of SessionCommands that allow
+// SessionService itself maintains a set of SessionServiceCommands that allow
 // SessionService to rebuild the open state of the browser (as SessionWindow,
 // SessionTab and SerializedNavigationEntry). The commands are periodically
 // flushed to SessionBackend and written to a file. Every so often
 // SessionService rebuilds the contents of the file from the open state of the
 // browser.
-class SessionService : public BaseSessionService,
+class SessionService : // public BaseSessionService,
                        public KeyedService,
                        public content::NotificationObserver,
-                       public chrome::BrowserListObserver {
+                       public chrome::BrowserListObserver,
+                       public SessionServiceCommands {
   friend class SessionServiceTestHelper;
  public:
-  // Used to distinguish an application window from a normal one.
-  enum AppType {
-    TYPE_APP,
-    TYPE_NORMAL
-  };
-
   // Creates a SessionService for the specified profile.
   explicit SessionService(Profile* profile);
   // For testing.
@@ -144,7 +140,7 @@ class SessionService : public BaseSessionService,
 
   // Sets the type of window. In order for the contents of a window to be
   // tracked SetWindowType must be invoked with a type we track
-  // (should_track_changes_for_browser_type returns true).
+  // (ShouldTrackChangesOfWindowType returns true).
   void SetWindowType(const SessionID& window_id,
                      Browser::Type type,
                      AppType app_type);
@@ -189,18 +185,16 @@ class SessionService : public BaseSessionService,
                                const SessionID& tab_id,
                                const std::string& user_agent_override);
 
-  // Callback from GetLastSession.
-  // The second parameter is the id of the window that was last active.
-  typedef base::Callback<void(ScopedVector<SessionWindow>, SessionID::id_type)>
-      SessionCallback;
+  // Sets the application extension id of the specified tab.
+  void SetTabExtensionAppID(const SessionID& window_id,
+                            const SessionID& tab_id,
+                            const std::string& extension_app_id);
 
-  // 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.
-  base::CancelableTaskTracker::TaskId GetLastSession(
-      const SessionCallback& callback,
-      base::CancelableTaskTracker* tracker);
 
+  // SessionServiceCommands:
+  bool ShouldTrackChangesOfWindowType(SessionWindow::WindowType type,
+                                      AppType app_type) const override;
+  void ScheduleResetCommands() override;
   // Overridden from BaseSessionService because we want some UMA reporting on
   // session update activities.
   void Save() override;
@@ -212,18 +206,6 @@ class SessionService : public BaseSessionService,
   FRIEND_TEST_ALL_PREFIXES(NoStartupWindowTest, DontInitSessionServiceForApps);
 
   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 {
-    TYPE_TABBED = 0,
-    TYPE_POPUP = 1
-  };
 
   void Init();
 
@@ -245,111 +227,6 @@ class SessionService : public BaseSessionService,
   void OnBrowserRemoved(Browser* browser) override {}
   void OnBrowserSetLastActive(Browser* browser) override;
 
-  // Sets the application extension id of the specified tab.
-  void SetTabExtensionAppID(const SessionID& window_id,
-                            const SessionID& tab_id,
-                            const std::string& extension_app_id);
-
-  // Methods to create the various commands. It is up to the caller to delete
-  // the returned the SessionCommand* object.
-  SessionCommand* CreateSetSelectedTabInWindow(const SessionID& window_id,
-                                               int index);
-
-  SessionCommand* CreateSetTabWindowCommand(const SessionID& window_id,
-                                            const SessionID& tab_id);
-
-  SessionCommand* CreateSetWindowBoundsCommand(const SessionID& window_id,
-                                               const gfx::Rect& bounds,
-                                               ui::WindowShowState show_state);
-
-  SessionCommand* CreateSetTabIndexInWindowCommand(const SessionID& tab_id,
-                                                   int new_index);
-
-  SessionCommand* CreateTabClosedCommand(SessionID::id_type tab_id);
-
-  SessionCommand* CreateWindowClosedCommand(SessionID::id_type tab_id);
-
-  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);
-
-  SessionCommand* CreateSessionStorageAssociatedCommand(
-      const SessionID& tab_id,
-      const std::string& session_storage_persistent_id);
-
-  SessionCommand* CreateSetActiveWindowCommand(const SessionID& window_id);
-
-  // Converts |commands| to SessionWindows and notifies the callback.
-  void OnGotSessionCommands(const SessionCallback& callback,
-                            ScopedVector<SessionCommand> commands);
-
-  // 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. |active_window_id| will be set with the
-  // id of the last active window, but it's only valid when this id corresponds
-  // to the id of one of the windows in valid_windows.
-  void RestoreSessionFromCommands(const std::vector<SessionCommand*>& commands,
-                                  std::vector<SessionWindow*>* valid_windows,
-                                  SessionID::id_type* active_window_id);
-
-  // 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);
-
-  // Returns the tab with the specified id in tabs. If a tab does not exist,
-  // it is created.
-  SessionTab* GetTab(SessionID::id_type tab_id,
-                     IdToSessionTab* tabs);
-
-  // Returns an iterator into navigations pointing to the navigation whose
-  // index matches |index|. If no navigation index matches |index|, the first
-  // navigation with an index > |index| is returned.
-  //
-  // This assumes the navigations are ordered by index in ascending order.
-  std::vector<sessions::SerializedNavigationEntry>::iterator
-  FindClosestNavigationWithIndex(
-      std::vector<sessions::SerializedNavigationEntry>* navigations,
-      int index);
-
-  // Does the following:
-  // . Deletes and removes any windows with no tabs or windows with types other
-  //   than tabbed_browser or browser. NOTE: constrained windows that have
-  //   been dragged out are of type browser. As such, this preserves any dragged
-  //   out constrained windows (aka popups that have been dragged out).
-  // . Sorts the tabs in windows with valid tabs based on the tabs
-  //   visual order, and adds the valid windows to windows.
-  void SortTabsBasedOnVisualOrderAndPrune(
-      std::map<int, SessionWindow*>* windows,
-      std::vector<SessionWindow*>* valid_windows);
-
-  // Adds tabs to their parent window based on the tab's window_id. This
-  // ignores tabs with no navigations.
-  void AddTabsToWindows(std::map<int, SessionTab*>* tabs,
-                        std::map<int, SessionWindow*>* windows);
-
-  // Creates tabs and windows from the commands specified in |data|. The created
-  // tabs and windows are added to |tabs| and |windows| respectively, with the
-  // id of the active window set in |active_window_id|. 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,
-                            SessionID::id_type* active_window_id);
-
   // 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).
@@ -374,26 +251,13 @@ class SessionService : public BaseSessionService,
 
   // 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
+  // (ShouldTrackChangesOfWindowType 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);
 
-  // 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
-  // command.
-  void ScheduleCommand(SessionCommand* command) override;
-
   // Converts all pending tab/window closes to commands and schedules them.
   void CommitPendingCloses();
 
@@ -403,8 +267,8 @@ class SessionService : public BaseSessionService,
 
   // Returns true if there are open trackable browser windows whose ids do
   // match |window_id| with our profile. A trackable window is a window from
-  // which |should_track_changes_for_browser_type| returns true. See
-  // |should_track_changes_for_browser_type| for details.
+  // which |ShouldTrackChangesOfWindowType| returns true. See
+  // |ShouldTrackChangesOfWindowType| for details.
   bool HasOpenTrackableBrowsers(const SessionID& window_id) const;
 
   // Returns true if changes to tabs in the specified window should be tracked.
@@ -413,11 +277,6 @@ class SessionService : public BaseSessionService,
   // Returns true if we track changes to the specified browser.
   bool ShouldTrackBrowser(Browser* browser) const;
 
-  // Returns true if we track changes to the specified browser type.
-  static bool should_track_changes_for_browser_type(
-      Browser::Type type,
-      AppType app_type);
-
   // Call when certain session relevant notifications
   // (tab_closed, nav_list_pruned) occur.  In addition, this is
   // currently called when Save() is called to compare how often the
@@ -439,8 +298,8 @@ class SessionService : public BaseSessionService,
 
   // Convert back/forward between the Browser and SessionService DB window
   // types.
-  static WindowType WindowTypeForBrowserType(Browser::Type type);
-  static Browser::Type BrowserTypeForWindowType(WindowType type);
+  static SessionWindow::WindowType WindowTypeForBrowserType(Browser::Type type);
+  static Browser::Type BrowserTypeForWindowType(SessionWindow::WindowType type);
 
   // The profile. This may be null during testing.
   Profile* profile_;
@@ -472,7 +331,7 @@ class SessionService : public BaseSessionService,
   WindowClosingIDs window_closing_ids_;
 
   // Set of windows we're tracking changes to. This is only browsers that
-  // return true from should_track_changes_for_browser_type.
+  // return true from ShouldTrackChangesOfWindowType.
   typedef std::set<SessionID::id_type> WindowsTracking;
   WindowsTracking windows_tracking_;
 
@@ -500,8 +359,6 @@ class SessionService : public BaseSessionService,
   // without quitting.
   bool force_browser_not_alive_with_no_windows_;
 
-  base::WeakPtrFactory<SessionService> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(SessionService);
 };