Changing SessionService to have a BaseSessionService, not being one.

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/sessions/session_service_utils.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 "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/base/ui_base_types.h"
 
@@ skipping 20 matching lines @@
 // 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 uses functions from session_service_commands 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 BaseSessionService,
+class SessionService : public BaseSessionServiceDelegateImpl,
                        public KeyedService,
                        public content::NotificationObserver,
                        public chrome::BrowserListObserver {
   friend class SessionServiceTestHelper;
  public:
   // Used to distinguish an application from a ordinary content window.
   enum AppType {
     TYPE_APP,
     TYPE_NORMAL
   };
@@ skipping 23 matching lines @@
 
   // 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 87 matching lines @@
   typedef base::Callback<void(ScopedVector<SessionWindow>, SessionID::id_type)>
       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.
   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;
+  // BaseSessionServiceDelegateImpl:
+  void OnSavedCommands() override;
 
  private:
   // Allow tests to access our innards for testing purposes.
+  FRIEND_TEST_ALL_PREFIXES(SessionServiceTest, SavedSessionNotification);
   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;
 
   void Init();
 
   // Returns true if a window of given |window_type| and |app_type| should get
   // restored upon session restore.
   bool ShouldRestoreWindowOfType(SessionWindow::WindowType type,
                                  AppType app_type) const;
 
   // Removes unrestorable windows from the previous windows list.
   void RemoveUnusedRestoreWindows(std::vector<SessionWindow*>* window_list);
 
-  // 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;
 
   // Converts |commands| to SessionWindows and notifies the callback.
   void OnGotSessionCommands(const SessionCallback& callback,
                             ScopedVector<SessionCommand> commands);
 
   // 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,
-      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,
-      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 (|ShouldRestoreWindowOfType|
   // returns true). All browsers that are tracked are added to windows_to_track
   // (as long as it is non-null).
   void BuildCommandsFromBrowsers(
-      ScopedVector<SessionCommand>* commands,
       IdToRange* tab_to_available_range,
       std::set<SessionID::id_type>* windows_to_track);
 
   // 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();
 
   // Schedules the specified command.
-  void ScheduleCommand(scoped_ptr<SessionCommand> command) override;
+  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
@@ skipping 19 matching lines @@
   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();
 
+  // Unit test accessors.
+  BaseSessionService* GetBaseSessionServiceForTest();
+
   // The profile. This may be null during testing.
   Profile* profile_;
 
+  // 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
@@ skipping 41 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_