[sessions] Properly namespace recently-componentized TabRestore code

components/sessions/core/tab_restore_service_helper.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 COMPONENTS_SESSIONS_CORE_TAB_RESTORE_SERVICE_HELPER_H_
 #define COMPONENTS_SESSIONS_CORE_TAB_RESTORE_SERVICE_HELPER_H_
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "components/sessions/core/tab_restore_service.h"
 #include "components/sessions/session_id.h"
 #include "components/sessions/session_types.h"
 #include "components/sessions/sessions_export.h"
 
+namespace sessions {
+
 class TabRestoreService;
+class TabRestoreServiceClient;
 class TabRestoreServiceDelegate;
 class TabRestoreServiceObserver;
 class TimeFactory;
 
-namespace sessions {
-class TabRestoreServiceClient;
-}
-
 // Helper class used to implement InMemoryTabRestoreService and
 // PersistentTabRestoreService. See tab_restore_service.h for method-level
 // comments.
 class SESSIONS_EXPORT TabRestoreServiceHelper {
  public:
   typedef TabRestoreService::Entries Entries;
   typedef TabRestoreService::Entry Entry;
   typedef TabRestoreService::Tab Tab;
   typedef TabRestoreService::TimeFactory TimeFactory;
   typedef TabRestoreService::Window Window;
@@ skipping 20 matching lines @@
   enum {
     // Max number of entries we'll keep around.
     kMaxEntries = 25,
   };
 
   // Creates a new TabRestoreServiceHelper and provides an object that provides
   // the current time. The TabRestoreServiceHelper does not take ownership of
   // |time_factory| and |observer|. Note that |observer| can also be NULL.
   TabRestoreServiceHelper(TabRestoreService* tab_restore_service,
                           Observer* observer,
-                          sessions::TabRestoreServiceClient* client,
+                          TabRestoreServiceClient* client,
                           TimeFactory* time_factory);
 
   ~TabRestoreServiceHelper();
 
   // Helper methods used to implement TabRestoreService.
   void AddObserver(TabRestoreServiceObserver* observer);
   void RemoveObserver(TabRestoreServiceObserver* observer);
-  void CreateHistoricalTab(sessions::LiveTab* live_tab, int index);
+  void CreateHistoricalTab(LiveTab* live_tab, int index);
   void BrowserClosing(TabRestoreServiceDelegate* delegate);
   void BrowserClosed(TabRestoreServiceDelegate* delegate);
   void ClearEntries();
   const Entries& entries() const;
-  std::vector<sessions::LiveTab*> RestoreMostRecentEntry(
+  std::vector<LiveTab*> RestoreMostRecentEntry(
       TabRestoreServiceDelegate* delegate,
       int host_desktop_type);
   Tab* RemoveTabEntryById(SessionID::id_type id);
-  std::vector<sessions::LiveTab*> RestoreEntryById(
-      TabRestoreServiceDelegate* delegate,
-      SessionID::id_type id,
-      int host_desktop_type,
-      WindowOpenDisposition disposition);
+  std::vector<LiveTab*> RestoreEntryById(TabRestoreServiceDelegate* delegate,
+                                         SessionID::id_type id,
+                                         int host_desktop_type,
+                                         WindowOpenDisposition disposition);
 
   // Notifies observers the tabs have changed.
   void NotifyTabsChanged();
 
   // Notifies observers the service has loaded.
   void NotifyLoaded();
 
   // Adds |entry| to the list of entries and takes ownership. 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
@@ skipping 14 matching lines @@
   static bool ValidateEntry(Entry* entry);
 
  private:
   friend class PersistentTabRestoreService;
 
   // Populates the tab's navigations from the LiveTab, and its browser_id and
   // pinned state from the delegate.
   void PopulateTab(Tab* tab,
                    int index,
                    TabRestoreServiceDelegate* delegate,
-                   sessions::LiveTab* live_tab);
+                   LiveTab* live_tab);
 
   // This is a helper function for RestoreEntryById() for restoring a single
   // tab. If |delegate| is NULL, this creates a new window for the entry. This
   // returns the TabRestoreServiceDelegate into which the tab was restored.
   // |disposition| will be respected, but if it is UNKNOWN then the tab's
   // original attributes will be respected instead. If a new
   // TabRestoreServiceDelegate needs to be created for this tab,
   // |host_desktop_type| will be passed to
   // TabRestoreServiceClient::CreateTabRestoreServiceDelegate(). If present,
   // |live_tab| will be populated with the LiveTab of the restored tab.
   TabRestoreServiceDelegate* RestoreTab(const Tab& tab,
                                         TabRestoreServiceDelegate* delegate,
                                         int host_desktop_type,
                                         WindowOpenDisposition disposition,
-                                        sessions::LiveTab** live_tab);
+                                        LiveTab** live_tab);
 
   // 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.
   static bool ValidateTab(Tab* tab);
 
   // Validates all the tabs in a window, plus the window's active tab index.
   static bool ValidateWindow(Window* window);
 
   // Returns true if |tab| is one we care about restoring.
@@ skipping 10 matching lines @@
   void UpdateTabBrowserIDs(SessionID::id_type old_id,
                            SessionID::id_type new_id);
 
   // Gets the current time. This uses the time_factory_ if there is one.
   base::Time TimeNow() const;
 
   TabRestoreService* const tab_restore_service_;
 
   Observer* const observer_;
 
-  sessions::TabRestoreServiceClient* client_;
+  TabRestoreServiceClient* client_;
 
   // Set of entries. They are ordered from most to least recent.
   Entries entries_;
 
   // Are we restoring a tab? If this is true we ignore requests to create a
   // historical tab.
   bool restoring_;
 
   base::ObserverList<TabRestoreServiceObserver> observer_list_;
 
   // Set of delegates that we've received a BrowserClosing method for but no
   // corresponding BrowserClosed. We cache the set of delegates closing to
   // avoid creating historical tabs for them.
   std::set<TabRestoreServiceDelegate*> closing_delegates_;
 
   TimeFactory* const time_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabRestoreServiceHelper);
 };
 
+}  // namespace sessions
+
 #endif  // COMPONENTS_SESSIONS_CORE_TAB_RESTORE_SERVICE_HELPER_H_