[Sync] Fix namespaces for the sync_sessions component.

chrome/browser/ui/toolbar/recent_tabs_sub_menu_model_unittest.cc

 // 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.
 
 #include "chrome/browser/ui/toolbar/recent_tabs_sub_menu_model.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 35 matching lines @@
 
 namespace {
 
 // This copies parts of MenuModelTest::Delegate and combines them with the
 // RecentTabsSubMenuModel since RecentTabsSubMenuModel is a
 // SimpleMenuModel::Delegate and not just derived from SimpleMenuModel.
 class TestRecentTabsSubMenuModel : public RecentTabsSubMenuModel {
  public:
   TestRecentTabsSubMenuModel(ui::AcceleratorProvider* provider,
                              Browser* browser,
-                             sync_driver::OpenTabsUIDelegate* delegate)
+                             sync_sessions::OpenTabsUIDelegate* delegate)
       : RecentTabsSubMenuModel(provider, browser, delegate),
         execute_count_(0),
         enable_count_(0) {}
 
   // Testing overrides to ui::SimpleMenuModel::Delegate:
   bool IsCommandIdEnabled(int command_id) const override {
     bool val = RecentTabsSubMenuModel::IsCommandIdEnabled(command_id);
     if (val)
       ++enable_count_;
     return val;
@@ skipping 33 matching lines @@
 
   bool got_changes() const { return got_changes_; }
 
  private:
   ui::MenuModel* model_;
   bool got_changes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRecentTabsMenuModelDelegate);
 };
 
-class DummyRouter : public browser_sync::LocalSessionEventRouter {
+class DummyRouter : public sync_sessions::LocalSessionEventRouter {
  public:
   ~DummyRouter() override {}
   void StartRoutingTo(
-      browser_sync::LocalSessionEventHandler* handler) override {}
+      sync_sessions::LocalSessionEventHandler* handler) override {}
   void Stop() override {}
 };
 
 }  // namespace
 
 class RecentTabsSubMenuModelTest
     : public BrowserWithTestWindowTest {
  public:
   RecentTabsSubMenuModelTest()
       : sync_service_(CreateProfileSyncServiceParamsForTest(&testing_profile_)),
         local_device_(new sync_driver::LocalDeviceInfoProviderMock(
             "RecentTabsSubMenuModelTest",
             "Test Machine",
             "Chromium 10k",
             "Chrome 10k",
             sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
             "device_id")) {
     sync_prefs_.reset(new sync_driver::SyncPrefs(testing_profile_.GetPrefs()));
-    manager_.reset(new browser_sync::SessionsSyncManager(
+    manager_.reset(new sync_sessions::SessionsSyncManager(
         sync_service_.GetSyncClient()->GetSyncSessionsClient(),
         sync_prefs_.get(), local_device_.get(),
-        std::unique_ptr<browser_sync::LocalSessionEventRouter>(
+        std::unique_ptr<sync_sessions::LocalSessionEventRouter>(
             new DummyRouter()),
         base::Closure(), base::Closure()));
     manager_->MergeDataAndStartSyncing(
         syncer::SESSIONS, syncer::SyncDataList(),
         std::unique_ptr<syncer::SyncChangeProcessor>(
             new syncer::FakeSyncChangeProcessor),
         std::unique_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock));
   }
 
   void WaitForLoadFromLastSession() {
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   static std::unique_ptr<KeyedService> GetTabRestoreService(
       content::BrowserContext* browser_context) {
     return base::MakeUnique<sessions::PersistentTabRestoreService>(
         base::WrapUnique(new ChromeTabRestoreServiceClient(
             Profile::FromBrowserContext(browser_context))),
         nullptr);
   }
 
-  sync_driver::OpenTabsUIDelegate* GetOpenTabsDelegate() {
+  sync_sessions::OpenTabsUIDelegate* GetOpenTabsDelegate() {
     return manager_.get();
   }
 
   void RegisterRecentTabs(RecentTabsBuilderTestHelper* helper) {
     helper->ExportToSessionsSyncManager(manager_.get());
   }
 
  private:
   TestingProfile testing_profile_;
   ProfileSyncServiceMock sync_service_;
   std::unique_ptr<sync_driver::SyncPrefs> sync_prefs_;
-  std::unique_ptr<browser_sync::SessionsSyncManager> manager_;
+  std::unique_ptr<sync_sessions::SessionsSyncManager> manager_;
   std::unique_ptr<sync_driver::LocalDeviceInfoProviderMock> local_device_;
 };
 
 // Test disabled "Recently closed" header with no foreign tabs.
 TEST_F(RecentTabsSubMenuModelTest, NoTabs) {
   TestRecentTabsSubMenuModel model(NULL, browser(), NULL);
 
   // Expected menu:
   // Menu index  Menu items
   // ---------------------------------------------
@@ skipping 425 matching lines @@
   // 2           Recently closed heaer (disabled)
   // 3           <separator>
   // 4           No tabs from other Devices
 
   TestRecentTabsSubMenuModel model(NULL, browser(), NULL);
   EXPECT_EQ(5, model.GetItemCount());
   EXPECT_EQ(-1, model.GetMaxWidthForItemAtIndex(2));
   EXPECT_NE(-1, model.GetMaxWidthForItemAtIndex(3));
   EXPECT_EQ(-1, model.GetMaxWidthForItemAtIndex(4));
 }