Refactoring of SessionService to get componentized.

chrome/browser/sessions/session_service_commands.h

Index: chrome/browser/sessions/session_service_commands.h
diff --git a/chrome/browser/sessions/session_service_commands.h b/chrome/browser/sessions/session_service_commands.h
new file mode 100644
index 0000000000000000000000000000000000000000..a90daa01b5305459f7568be5f1a5e52dae9496ea
--- /dev/null
+++ b/chrome/browser/sessions/session_service_commands.h
@@ -0,0 +1,183 @@
+// Copyright 2014 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_SERVICE_SESSION_COMMANDS_H_
+#define CHROME_BROWSER_SESSIONS_SERVICE_SESSION_COMMANDS_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 "chrome/browser/sessions/base_session_service.h"
+#include "chrome/browser/sessions/session_types.h"
+#include "ui/base/ui_base_types.h"
+
+class BaseSessionServiceDelegate;
+class SessionCommand;
+
+// SessionServiceCommands ------------------------------------------------------------
+
+// SessionServiceCommands adds a layer to |BaseSessionService| which offers
+// command creations and a restoration function. The |GetLastSession| function
+// will create |SessionWindow| and |SessionTab| data structures.
+//
+class SessionServiceCommands : public BaseSessionService {
+ public:
+  // Used to distinguish an application window from a normal one.
+  enum AppType {
+    TYPE_APP,
+    TYPE_NORMAL
+  };
+
+  SessionServiceCommands(BaseSessionService::SessionType type,
+                         const base::FilePath& path,
+                         scoped_ptr<BaseSessionServiceDelegate> delegate);
+  virtual ~SessionServiceCommands();
+
+  // 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;
+
+  // 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);
+
+  // Implemented by the ...TODO: Do not call back into creator?
+  virtual bool ShouldTrackChangesOfWindowType(
+      SessionWindow::WindowType type,
+      SessionServiceCommands::AppType app_type) const = 0;
+  // Schedule to re...TODO:  Do not call back into creator?
+  virtual void ScheduleResetCommands() = 0;
+
+  // Methods to create the various commands. It is up to the caller to delete
+  // the returned SessionCommand* object.
+  SessionCommand* CreateSetSelectedTabInWindow(const SessionID& window_id,
+                                               int index);
+  SessionCommand* CreateSetTabWindow(const SessionID& window_id,
+                                     const SessionID& tab_id);
+  SessionCommand* CreateSetWindowBounds(const SessionID& window_id,
+                                        const gfx::Rect& bounds,
+                                        ui::WindowShowState show_state);
+  SessionCommand* CreateSetTabIndexInWindow(const SessionID& tab_id,
+                                            int new_index);
+  SessionCommand* CreateTabClosed(SessionID::id_type tab_id);
+  SessionCommand* CreateWindowClosed(SessionID::id_type tab_id);
+  SessionCommand* CreateSetSelectedNavigationIndex(const SessionID& tab_id,
+                                                   int index);
+  SessionCommand* CreateSetWindowType(const SessionID& window_id,
+                                      SessionWindow::WindowType type);
+  SessionCommand* CreatePinnedState(const SessionID& tab_id, bool is_pinned);
+  SessionCommand* CreateSessionStorageAssociated(
+      const SessionID& tab_id,
+      const std::string& session_storage_persistent_id);
+  SessionCommand* CreateSetActiveWindow(const SessionID& window_id);
+  SessionCommand* CreateTabNavigationPathPrunedFromBack(const SessionID& tab_id,
+                                                        int count);
+  SessionCommand* CreateTabNavigationPathPrunedFromFront(
+      const SessionID& tab_id,
+      int count);
+  SessionCommand* CreateUpdateTabNavigation(
+      const SessionID& tab_id,
+      const sessions::SerializedNavigationEntry& navigation);
+  SessionCommand* CreateSetTabExtensionAppID(const SessionID& tab_id,
+                                             const std::string& extension_id);
+  SessionCommand* CreateSetTabUserAgentOverride(
+      const SessionID& tab_id,
+      const std::string& user_agent_override);
+  SessionCommand* CreateSetWindowAppName(const SessionID& window_id,
+                                         const std::string& app_name);
+
+  // BaseSessionService:
+  // Schedules the specified command. This method takes ownership of the
+  // command.
+  void ScheduleCommand(SessionCommand* command) override;
+
+ private:
+  typedef std::map<SessionID::id_type, SessionTab*> IdToSessionTab;
+  typedef std::map<SessionID::id_type, SessionWindow*> IdToSessionWindow;
+
+  // Converts |commands| to SessionWindows and notifies the callback.
+  void OnGotSessionServiceCommands(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);
+
+  // 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);
+
+  base::WeakPtrFactory<SessionServiceCommands> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SessionServiceCommands);
+};
+
+#endif  // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_COMMANDS_H_