Move implementation from header to source.

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 <set>
 #include <vector>
@@ skipping 30 matching lines @@
     virtual void TabRestoreServiceChanged(TabRestoreService* service) = 0;
 
     // Sent to all remaining Observers when TabRestoreService's
     // destructor is run.
     virtual void TabRestoreServiceDestroyed(TabRestoreService* service) = 0;
   };
 
   // Interface used to allow the test to provide a custom time.
   class TimeFactory {
    public:
-    virtual ~TimeFactory() {}
+    virtual ~TimeFactory();
     virtual base::Time TimeNow() = 0;
   };
 
   // The type of entry.
   enum Type {
     TAB,
     WINDOW
   };
 
   struct Entry {
     Entry();
     explicit Entry(Type type);
-    virtual ~Entry() {}
+    virtual ~Entry();
 
     // Unique id for this entry. The id is guaranteed to be unique for a
     // session.
     SessionID::id_type id;
 
     // The type of the entry.
     Type type;
 
     // The time when the window or tab was closed.
     base::Time timestamp;
 
     // Is this entry from the last session? This is set to true for entries that
     // were closed during the last session, and false for entries that were
     // closed during this session.
     bool from_last_session;
   };
 
   // Represents a previously open tab.
   struct Tab : public Entry {
     Tab();
+    virtual ~Tab();
 
     bool has_browser() const { return browser_id > 0; }
 
     // The navigations.
     std::vector<TabNavigation> navigations;
 
     // Index of the selected navigation in navigations.
     int current_navigation_index;
 
     // The ID of the browser to which this tab belonged, so it can be restored
     // there. May be 0 (an invalid SessionID) when restoring an entire session.
     SessionID::id_type browser_id;
 
     // Index within the tab strip. May be -1 for an unknown index.
     int tabstrip_index;
 
     // True if the tab was pinned.
     bool pinned;
 
     // If non-empty gives the id of the extension for the tab.
     std::string extension_app_id;
   };
 
   // Represents a previously open window.
   struct Window : public Entry {
     Window();
+    virtual ~Window();
 
     // The tabs that comprised the window, in order.
     std::vector<Tab> tabs;
 
     // Index of the selected tab.
     int selected_tab_index;
   };
 
   typedef std::list<Entry*> Entries;
 
@@ skipping 19 matching lines @@
 
   // Invoked when the browser is done closing.
   void BrowserClosed(Browser* browser);
 
   // Removes all entries from the list and notifies observers the list
   // of tabs has changed.
   void ClearEntries();
 
   // Returns the entries, ordered with most recently closed entries at the
   // front.
-  virtual const Entries& entries() const { return entries_; }
+  virtual const Entries& entries() const;
 
   // 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 |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|. If
   // |browser| is NULL, this creates a new window for the entry.
@@ skipping 178 matching lines @@
   // entries_.
   std::vector<Entry*> staging_entries_;
 
   TimeFactory* time_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabRestoreService);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_TAB_RESTORE_SERVICE_H_