Makes the tab restore service contain any windows that were open at...

chrome/browser/sessions/tab_restore_service.h

 // Copyright (c) 2006-2008 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_TAB_RESTORE_SERVICE_H_
 #define CHROME_BROWSER_SESSIONS_TAB_RESTORE_SERVICE_H_
 
 #include <list>
+#include <vector>
 
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "chrome/browser/sessions/base_session_service.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/sessions/session_types.h"
 
 class Browser;
 class NavigationController;
 class Profile;
@@ skipping 100 matching lines @@
   // added to |browser|.
   void RestoreMostRecentEntry(Browser* browser);
 
   // Restores an entry by id. If there is no entry with an id matching |id|,
   // this does nothing. If |replace_existing_tab| is true and id identifies a
   // tab, the newly created tab replaces the selected tab in |browser|.
   void RestoreEntryById(Browser* browser,
                         SessionID::id_type id,
                         bool replace_existing_tab);
 
-  // Loads the tabs from the previous session. This does nothing if the tabs
+  // Loads the tabs and previous session. This does nothing if the tabs
   // from the previous session have already been loaded.
   void LoadTabsFromLastSession();
 
+  // Max number of entries we'll keep around.
+  static const size_t kMaxEntries;
+
  protected:
   virtual void Save();
 
  private:
+  // Used to indicate what has loaded.
+  enum LoadState {
+    // Indicates we haven't loaded anything.
+    NOT_LOADED           = 1 << 0,
+
+    // Indicates we've asked for the last sessions and tabs but haven't gotten
+    // the result back yet.
+    LOADING              = 1 << 2,
+
+    // Indicates we finished loading the last tabs (but not necessarily the
+    // last session).
+    LOADED_LAST_TABS     = 1 << 3,
+
+    // Indicates we finished loading the last session (but not necessarily the
+    // last tabs).
+    LOADED_LAST_SESSION  = 1 << 4
+  };
+
   // Populates tabs->navigations from the NavigationController.
   void PopulateTabFromController(NavigationController* controller,
                                  Tab* tab);
 
   // Notifies observers the tabs have changed.
   void NotifyTabsChanged();
 
   // Adds |entry| to the list of entries. If |prune| is true |PruneAndNotify|
   // is invoked. If |to_front| is true the entry is added to the front,
   // otherwise the back. Normal closes go to the front, but tab/window closes
@@ skipping 25 matching lines @@
 
   // Creates a restore command.
   SessionCommand* CreateRestoredEntryCommand(SessionID::id_type entry_id);
 
   // Returns the index to persist as the selected index. This is the same
   // as |tab.current_navigation_index| unless the entry at
   // |tab.current_navigation_index| shouldn't be persisted. Returns -1 if
   // no valid navigation to persist.
   int GetSelectedNavigationIndexToPersist(const Tab& tab);
 
-  // Invoked when we've loaded the session commands from the previous run.
-  // This creates entries and adds them to entries_, notifying the observer.
+  // Invoked when we've loaded the session commands that identify the
+  // previously closed tabs. This creates entries, adds them to
+  // staging_entries_, and invokes LoadState.
   void OnGotLastSessionCommands(
       Handle handle,
       scoped_refptr<InternalGetCommandsRequest> request);
 
+  // Populates |loaded_entries| with Entries from |request|.
+  void CreateEntriesFromCommands(
+      scoped_refptr<InternalGetCommandsRequest> request,
+      std::vector<Entry*>* loaded_entries);
+
   // Returns true if |tab| has more than one navigation. If |tab| has more
   // than one navigation |tab->current_navigation_index| is constrained based
   // on the number of navigations.
   bool ValidateTab(Tab* tab);
 
   // Validates all entries in |entries|, deleting any with no navigations.
   // This also deletes any entries beyond the max number of entries we can
   // hold.
   void ValidateAndDeleteEmptyEntries(std::vector<Entry*>* entries);
 
+  // Callback from SessionService when we've received the windows from the
+  // previous session. This creates and add entries to |staging_entries_|
+  // and invokes LoadStateChanged.
+  void OnGotPreviousSession(Handle handle,
+                            std::vector<SessionWindow*>* windows);
+
+  // Creates and add entries to |entries| for each of the windows in |windows|.
+  void CreateEntriesFromWindows(
+      std::vector<SessionWindow*>* windows,
+      std::vector<Entry*>* entries);
+
+  // Converts a SessionWindow into a Window, returning true on success.
+  bool ConvertSessionWindowToWindow(
+      SessionWindow* session_window,
+      Window* window);
+
+  // Invoked when previous tabs or session is loaded. If both have finished
+  // loading the entries in staging_entries_ are added to entries_ and
+  // observers are notified.
+  void LoadStateChanged();
+
   // Set of entries.
   Entries entries_;
 
   // Whether we've loaded the last session.
-  bool loaded_last_session_;
+  int load_state_;
 
   // Are we restoring a tab? If this is true we ignore requests to create a
   // historical tab.
   bool restoring_;
 
   // Have the max number of entries ever been created?
   bool reached_max_;
 
   // The number of entries to write.
   int entries_to_write_;
 
   // Number of entries we've written.
   int entries_written_;
 
   ObserverList<Observer> observer_list_;
 
   // Set of tabs that we've received a BrowserClosing method for but no
   // corresponding BrowserClosed. We cache the set of browsers closing to
   // avoid creating historical tabs for them.
   std::set<Browser*> closing_browsers_;
 
-  // Used when loading commands from the previous session.
-  CancelableRequestConsumer load_tabs_consumer_;
+  // Used when loading previous tabs/session.
+  CancelableRequestConsumer load_consumer_;
+
+  // Results from previously closed tabs/sessions is first added here. When
+  // the results from both us and the session restore service have finished
+  // loading LoadStateChanged is invoked, which adds these entries to
+  // entries_.
+  std::vector<Entry*> staging_entries_;
 
   DISALLOW_COPY_AND_ASSIGN(TabRestoreService);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_TAB_RESTORE_SERVICE_H_