[sessions] Properly namespace recently-componentized TabRestore code

chrome/browser/ui/ash/chrome_new_window_delegate.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/ui/ash/chrome_new_window_delegate.h"
 
 #include "ash/wm/window_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/ui/ash/chrome_shell_delegate.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "components/sessions/core/tab_restore_service.h"
 #include "components/sessions/core/tab_restore_service_observer.h"
 
 namespace {
 
 void RestoreTabUsingProfile(Profile* profile) {
-  TabRestoreService* service = TabRestoreServiceFactory::GetForProfile(profile);
+  sessions::TabRestoreService* service =
+      TabRestoreServiceFactory::GetForProfile(profile);
   service->RestoreMostRecentEntry(NULL, chrome::HOST_DESKTOP_TYPE_ASH);
 }
 
 // Returns the browser for the active window, if any.
 Browser* GetBrowserForActiveWindow() {
   return chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow());
 }
 
 }  // namespace
 
 ChromeNewWindowDelegate::ChromeNewWindowDelegate() {}
 ChromeNewWindowDelegate::~ChromeNewWindowDelegate() {}
 
 // TabRestoreHelper is used to restore a tab. In particular when the user
 // attempts to a restore a tab if the TabRestoreService hasn't finished loading
 // this waits for it. Once the TabRestoreService finishes loading the tab is
 // restored.
 class ChromeNewWindowDelegate::TabRestoreHelper
-    : public TabRestoreServiceObserver {
+    : public sessions::TabRestoreServiceObserver {
  public:
   TabRestoreHelper(ChromeNewWindowDelegate* delegate,
                    Profile* profile,
-                   TabRestoreService* service)
-      : delegate_(delegate),
-        profile_(profile),
-        tab_restore_service_(service) {
+                   sessions::TabRestoreService* service)
+      : delegate_(delegate), profile_(profile), tab_restore_service_(service) {
     tab_restore_service_->AddObserver(this);
   }
 
   ~TabRestoreHelper() override { tab_restore_service_->RemoveObserver(this); }
 
-  TabRestoreService* tab_restore_service() { return tab_restore_service_; }
+  sessions::TabRestoreService* tab_restore_service() {
+    return tab_restore_service_;
+  }
 
-  void TabRestoreServiceChanged(TabRestoreService* service) override {}
+  void TabRestoreServiceChanged(sessions::TabRestoreService* service) override {
+  }
 
-  void TabRestoreServiceDestroyed(TabRestoreService* service) override {
+  void TabRestoreServiceDestroyed(
+      sessions::TabRestoreService* service) override {
     // This destroys us.
     delegate_->tab_restore_helper_.reset();
   }
 
-  void TabRestoreServiceLoaded(TabRestoreService* service) override {
+  void TabRestoreServiceLoaded(sessions::TabRestoreService* service) override {
     RestoreTabUsingProfile(profile_);
     // This destroys us.
     delegate_->tab_restore_helper_.reset();
   }
 
  private:
   ChromeNewWindowDelegate* delegate_;
   Profile* profile_;
-  TabRestoreService* tab_restore_service_;
+  sessions::TabRestoreService* tab_restore_service_;
 
   DISALLOW_COPY_AND_ASSIGN(TabRestoreHelper);
 };
 
 void ChromeNewWindowDelegate::NewTab() {
   Browser* browser = GetBrowserForActiveWindow();
   if (browser && browser->is_type_tabbed()) {
     chrome::NewTab(browser);
     return;
   }
@@ skipping 21 matching lines @@
     DCHECK(!tab_restore_helper_->tab_restore_service()->IsLoaded());
     return;
   }
 
   Browser* browser = GetBrowserForActiveWindow();
   Profile* profile = browser ? browser->profile() : NULL;
   if (!profile)
     profile = ProfileManager::GetActiveUserProfile();
   if (profile->IsOffTheRecord())
     return;
-  TabRestoreService* service =
+  sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile);
   if (!service)
     return;
 
   if (service->IsLoaded()) {
     RestoreTabUsingProfile(profile);
   } else {
     tab_restore_helper_.reset(new TabRestoreHelper(this, profile, service));
     service->LoadTabsFromLastSession();
   }
 }
 
 void ChromeNewWindowDelegate::ShowTaskManager() {
   chrome::OpenTaskManager(NULL);
 }
 
 void ChromeNewWindowDelegate::OpenFeedbackPage() {
   chrome::OpenFeedbackDialog(GetBrowserForActiveWindow());
 }