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..0d8510e58b80b492c951944160f90d7cfc7d1b3a
--- /dev/null
+++ b/chrome/browser/sessions/session_service_commands.h
@@ -0,0 +1,179 @@
+// 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_SESSION_SERVICE_COMMANDS_H_
+#define CHROME_BROWSER_SESSIONS_SESSION_SERVICE_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 SessionCommand;
+
+// SessionServiceCommands ------------------------------------------------------
+
+// SessionServiceCommands supplies functions to create sequentialized change
+// commands which are required to reconstruct the current session state. It
+// furthermore offers a |RestoreSessionFromCommands| function which will create
+// |SessionWindow| and |SessionTab| data structures from a list of commands.
+//
+class SessionServiceCommands {
+ public:
+  // Used to distinguish an application from a ordinary content window.
+  // TODO(skuhne): Move with ShouldRestoreWindowOfType to delegate.
+  enum AppType {
+    TYPE_APP,
+    TYPE_NORMAL
+  };
+
+  SessionServiceCommands();
+  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);
+
+  // Returns true if a window of given |window_type| and |app_type| should get
+  // restored upon session restore.
+  virtual bool ShouldRestoreWindowOfType(
+      SessionWindow::WindowType type,
+      SessionServiceCommands::AppType app_type) const = 0;
+
+  // Methods to create the various commands. It is up to the caller to delete
+  // the returned SessionCommand* object.
+  SessionCommand* CreateSetSelectedTabInWindowCommand(
+      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,
+                                             SessionWindow::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);
+  SessionCommand* CreateTabNavigationPathPrunedFromBackCommand(
+      const SessionID& tab_id,
+      int count);
+  SessionCommand* CreateTabNavigationPathPrunedFromFrontCommand(
+      const SessionID& tab_id,
+      int count);
+  SessionCommand* CreateUpdateTabNavigationCommand(
+      const SessionID& tab_id,
+      const sessions::SerializedNavigationEntry& navigation);
+  SessionCommand* CreateSetTabExtensionAppIDCommand(
+      const SessionID& tab_id,
+      const std::string& extension_id);
+  SessionCommand* CreateSetTabUserAgentOverrideCommand(
+      const SessionID& tab_id,
+      const std::string& user_agent_override);
+  SessionCommand* CreateSetWindowAppNameCommand(const SessionID& window_id,
+                                                const std::string& app_name);
+
+  // Searches for a pending command in |pending_commands| 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,
+                             std::vector<SessionCommand*>& pending_commands);
+
+  // Returns true if provided |command| either closes a window or a tab.
+  bool IsClosingCommand(SessionCommand* command) const;
+
+  // 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);
+
+ private:
+  typedef std::map<SessionID::id_type, SessionTab*> IdToSessionTab;
+  typedef std::map<SessionID::id_type, SessionWindow*> IdToSessionWindow;
+
+  // 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);
+
+  DISALLOW_COPY_AND_ASSIGN(SessionServiceCommands);
+};
+
+#endif  // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_COMMANDS_H_