Refactoring of SessionService to get componentized.

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 <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "chrome/browser/defaults.h"
-#include "chrome/browser/sessions/base_session_service.h"
+#include "chrome/browser/sessions/base_session_service_delegate_impl.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"
 #include "components/keyed_service/core/keyed_service.h"
-#include "components/sessions/session_id.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;
 struct SessionTab;
 struct SessionWindow;
 
 namespace content {
 class NavigationEntry;
 class WebContents;
 }
 
 // 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
 // the last session and the current session reset. This is done to provide the
 // illusion that app windows run in separate processes. Similar behavior occurs
 // with incognito windows.
 //
-// SessionService itself maintains a set of SessionCommands 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,
+// SessionService itself uses |SessionServiceCommands| to store commands which
+// can 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 BaseSessionServiceDelegateImpl,
+                       public SessionServiceCommandsDelegate,
                        public KeyedService,
                        public content::NotificationObserver,
                        public chrome::BrowserListObserver {
   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.
   explicit SessionService(const base::FilePath& save_path);
 
   ~SessionService() 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;
+
+  // Convert back/forward between the Browser and SessionService DB window
+  // types.
+  static SessionWindow::WindowType WindowTypeForBrowserType(Browser::Type type);
+  static Browser::Type BrowserTypeForWindowType(SessionWindow::WindowType type);
+
   // This may be NULL during testing.
   Profile* profile() const { return profile_; }
 
   // Returns true if a new window opening should really be treated like the
   // start of a session (with potential session restore, startup URLs, etc.).
   // In particular, this is true if there are no tabbed browsers running
   // currently (eg. because only background or other app pages are running).
   bool ShouldNewWindowStartSession();
 
   // Invoke at a point when you think session restore might occur. For example,
   // during startup and window creation this is invoked to see if a session
   // needs to be restored. If a session needs to be restored it is done so
   // asynchronously and true is returned. If false is returned the session was
   // not restored and the caller needs to create a new window.
   bool RestoreIfNecessary(const std::vector<GURL>& urls_to_open);
 
   // Resets the contents of the file from the current state of all open
   // browsers whose profile matches our profile.
   void ResetFromCurrentBrowsers();
 
   // Moves the current session to the last session. This is useful when a
   // checkpoint occurs, such as when the user launches the app and no tabbed
   // browsers are running.
   void MoveCurrentSessionToLastSession();
 
+  // Deletes the last session.
+  void DeleteLastSession();
+
   // Associates a tab with a window.
   void SetTabWindow(const SessionID& window_id,
                     const SessionID& tab_id);
 
   // Sets the bounds of a window.
   void SetWindowBounds(const SessionID& window_id,
                        const gfx::Rect& bounds,
                        ui::WindowShowState show_state);
 
   // Sets the visual index of the tab in its parent window.
@@ skipping 25 matching lines @@
   void WindowClosed(const SessionID& window_id);
 
   // Called when a tab is inserted.
   void TabInserted(content::WebContents* contents);
 
   // Called when a tab is closing.
   void TabClosing(content::WebContents* contents);
 
   // 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).
+  // (ShouldRestoreOfWindowType returns true).
   void SetWindowType(const SessionID& window_id,
                      Browser::Type type,
-                     AppType app_type);
+                     SessionServiceCommands::AppType app_type);
 
   // Sets the application name of the specified window.
   void SetWindowAppName(const SessionID& window_id,
                         const std::string& app_name);
 
   // Invoked when the NavigationController has removed entries from the back of
   // the list. |count| gives the number of entries in the navigation controller.
   void TabNavigationPathPrunedFromBack(const SessionID& window_id,
                                        const SessionID& tab_id,
                                        int count);
@@ skipping 21 matching lines @@
                                   int index);
 
   // Sets the index of the selected tab in the specified window.
   void SetSelectedTabInWindow(const SessionID& window_id, int index);
 
   // Sets the user agent override of the specified tab.
   void SetTabUserAgentOverride(const SessionID& window_id,
                                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);
 
-  // Overridden from BaseSessionService because we want some UMA reporting on
-  // session update activities.
-  void Save() override;
+  // SessionServiceCommandsDelegate:
+  bool ShouldRestoreWindowOfType(
+      SessionWindow::WindowType type,
+      SessionServiceCommands::AppType app_type) const override;
+
+  // BaseSessionServiceDelegateImpl:
+  void OnWillSaveCommands() override;
+  void OnSavedCommands() override;
+
+  // Unit test accessors.
+  SessionServiceCommands* GetSessionCommandsForTest();
+  BaseSessionService* GetBaseSessionServiceForTest();
 
  private:
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST_ALL_PREFIXES(SessionServiceTest, RestoreActivation1);
   FRIEND_TEST_ALL_PREFIXES(SessionServiceTest, RestoreActivation2);
   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();
 
-  // Returns true if we have scheduled any commands, or any scheduled commands
-  // have been saved.
-  bool processed_any_commands();
-
   // Implementation of RestoreIfNecessary. If |browser| is non-null and we need
   // to restore, the tabs are added to it, otherwise a new browser is created.
   bool RestoreIfNecessary(const std::vector<GURL>& urls_to_open,
                           Browser* browser);
 
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // chrome::BrowserListObserver
   void OnBrowserAdded(Browser* browser) override {}
   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).
   // A pair is added to tab_to_available_range indicating the range of
   // indices that were written.
   void BuildCommandsForTab(
       const SessionID& window_id,
       content::WebContents* tab,
       int index_in_window,
       bool is_pinned,
-      std::vector<SessionCommand*>* commands,
+      ScopedVector<SessionCommand>* commands,
       IdToRange* tab_to_available_range);
 
   // Adds commands to create the specified browser, and invokes
   // BuildCommandsForTab for each of the tabs in the browser. This ignores
   // any tabs not in the profile we were created with.
   void BuildCommandsForBrowser(
       Browser* browser,
-      std::vector<SessionCommand*>* commands,
+      ScopedVector<SessionCommand>* commands,
       IdToRange* tab_to_available_range,
       std::set<SessionID::id_type>* windows_to_track);
 
   // 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).
+  // This only adds browsers that should be tracked (|ShouldRestoreWindowOfType|
+  // 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,
+      ScopedVector<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();
+  // Schedules a reset of the existing commands. A reset means the contents
+  // of the file are recreated from the state of the browser.
+  void ScheduleResetCommands();
 
-  // 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;
+  // Schedules the specified command.
+  void ScheduleCommand(scoped_ptr<SessionCommand> command);
 
   // Converts all pending tab/window closes to commands and schedules them.
   void CommitPendingCloses();
 
   // Returns true if there is only one window open with a single tab that shares
   // our profile.
   bool IsOnlyOneTabLeft() const;
 
   // 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 |ShouldRestoreWindowOfType| returns true. See
+  // |ShouldRestoreWindowOfType| for details.
   bool HasOpenTrackableBrowsers(const SessionID& window_id) const;
 
   // Returns true if changes to tabs in the specified window should be tracked.
   bool ShouldTrackChangesToWindow(const SessionID& window_id) const;
 
   // 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
   // session data is currently saved verses when we may want to save it.
   // It records the data in UMA stats.
   void RecordSessionUpdateHistogramData(int type,
     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);
 
   // Deletes session data if no windows are open for the current profile.
   void MaybeDeleteSessionOnlyData();
 
-  // Convert back/forward between the Browser and SessionService DB window
-  // types.
-  static WindowType WindowTypeForBrowserType(Browser::Type type);
-  static Browser::Type BrowserTypeForWindowType(WindowType type);
-
   // The profile. This may be null during testing.
   Profile* profile_;
 
+  // The interface to create session commands and restore session information
+  // from them.
+  scoped_ptr<SessionServiceCommands> session_commands_;
+
+  // The owned BaseSessionService.
+  scoped_ptr<BaseSessionService> base_session_service_;
+
   content::NotificationRegistrar registrar_;
 
   // Maps from session tab id to the range of navigation entries that has
   // been written to disk.
   //
   // This is only used if not all the navigation entries have been
   // written.
   IdToRange tab_to_available_range_;
 
   // When the user closes the last window, where the last window is the
   // last tabbed browser and no more tabbed browsers are open with the same
   // profile, the window ID is added here. These IDs are only committed (which
   // marks them as closed) if the user creates a new tabbed browser.
   typedef std::set<SessionID::id_type> PendingWindowCloseIDs;
   PendingWindowCloseIDs pending_window_close_ids_;
 
   // Set of tabs that have been closed by way of the last window or last tab
   // closing, but not yet committed.
   typedef std::set<SessionID::id_type> PendingTabCloseIDs;
   PendingTabCloseIDs pending_tab_close_ids_;
 
   // When a window other than the last window (see description of
   // pending_window_close_ids) is closed, the id is added to this set.
   typedef std::set<SessionID::id_type> WindowClosingIDs;
   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 |ShouldRestoreWindowOfType|.
   typedef std::set<SessionID::id_type> WindowsTracking;
   WindowsTracking windows_tracking_;
 
   // 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.
@@ skipping 13 matching lines @@
   // For browser_tests, since we want to simulate the browser shutting down
   // without quitting.
   bool force_browser_not_alive_with_no_windows_;
 
   base::WeakPtrFactory<SessionService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionService);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_