Abstract WebContents/NavigationController from core TabRestore code

chrome/browser/sessions/tab_restore_service.h

 // Copyright 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_TAB_RESTORE_SERVICE_H_
 #define CHROME_BROWSER_SESSIONS_TAB_RESTORE_SERVICE_H_
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/sessions/core/tab_restore_service_client.h"
 #include "components/sessions/serialized_navigation_entry.h"
 #include "components/sessions/session_id.h"
 #include "components/sessions/session_types.h"
 #include "ui/base/window_open_disposition.h"
 
 class TabRestoreServiceDelegate;
 class TabRestoreServiceObserver;
 
-namespace content {
-class WebContents;
+namespace sessions {
+class LiveTab;
 }
 
 // TabRestoreService is responsible for maintaining the most recently closed
 // tabs and windows. When a tab is closed
 // TabRestoreService::CreateHistoricalTab is invoked and a Tab is created to
 // represent the tab. Similarly, when a browser is closed, BrowserClosing is
 // invoked and a Window is created to represent the window.
 //
 // To restore a tab/window from the TabRestoreService invoke RestoreEntryById
 // or RestoreMostRecentEntry.
@@ skipping 89 matching lines @@
 
   typedef std::list<Entry*> Entries;
 
   ~TabRestoreService() override;
 
   // Adds/removes an observer. TabRestoreService does not take ownership of
   // the observer.
   virtual void AddObserver(TabRestoreServiceObserver* observer) = 0;
   virtual void RemoveObserver(TabRestoreServiceObserver* observer) = 0;
 
-  // Creates a Tab to represent |contents| and notifies observers the list of
+  // Creates a Tab to represent |live_tab| and notifies observers the list of
   // entries has changed.
-  virtual void CreateHistoricalTab(content::WebContents* contents,
-                                   int index) = 0;
+  virtual void CreateHistoricalTab(sessions::LiveTab* live_tab, int index) = 0;
 
   // Invoked when a browser is closing. If |delegate| is a tabbed browser with
   // at least one tab, a Window is created, added to entries and observers are
   // notified.
   virtual void BrowserClosing(TabRestoreServiceDelegate* delegate) = 0;
 
   // Invoked when the browser is done closing.
   virtual void BrowserClosed(TabRestoreServiceDelegate* delegate) = 0;
 
   // Removes all entries from the list and notifies observers the list
   // of tabs has changed.
   virtual void ClearEntries() = 0;
 
   // Returns the entries, ordered with most recently closed entries at the
   // front.
   virtual const Entries& entries() const = 0;
 
   // Restores the most recently closed entry. Does nothing if there are no
   // entries to restore. If the most recently restored entry is a tab, it is
   // added to |delegate|. |host_desktop_type| is a value that is opaque to this
   // class and will be used only to pass back to the embedder via
-  // TabRestoreServiceClient if necessary. Returns the WebContents of the
+  // TabRestoreServiceClient if necessary. Returns the LiveTab instances of the
   // restored tab(s).
-  virtual std::vector<content::WebContents*> RestoreMostRecentEntry(
+  virtual std::vector<sessions::LiveTab*> RestoreMostRecentEntry(
       TabRestoreServiceDelegate* delegate,
       int host_desktop_type) = 0;
 
   // Removes the Tab with id |id| from the list and returns it; ownership is
   // passed to the caller.
   virtual Tab* RemoveTabEntryById(SessionID::id_type id) = 0;
 
   // Restores an entry by id. If there is no entry with an id matching |id|,
   // this does nothing. If |delegate| is NULL, this creates a new window for the
   // entry. |disposition| is respected, but the attributes (tabstrip index,
   // browser window) of the tab when it was closed will be respected if
   // disposition is UNKNOWN.  |host_desktop_type| is a value that is opaque to
   // this class and will be used only to pass back to the embedder via
-  // TabRestoreServiceClient if necessary.  Returns the WebContents of the
+  // TabRestoreServiceClient if necessary.  Returns the LiveTab instances of the
   // restored tab(s).
-  virtual std::vector<content::WebContents*> RestoreEntryById(
+  virtual std::vector<sessions::LiveTab*> RestoreEntryById(
       TabRestoreServiceDelegate* delegate,
       SessionID::id_type id,
       int host_desktop_type,
       WindowOpenDisposition disposition) = 0;
 
   // Loads the tabs and previous session. This does nothing if the tabs
   // from the previous session have already been loaded.
   virtual void LoadTabsFromLastSession() = 0;
 
   // Returns true if the tab entries have been loaded.
   virtual bool IsLoaded() const = 0;
 
   // Deletes the last session.
   virtual void DeleteLastSession() = 0;
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_TAB_RESTORE_SERVICE_H_