[Sync] Move //components/sync to the syncer namespace.

components/sync_sessions/session_data_type_controller_unittest.cc

 // Copyright 2014 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 "components/sync_sessions/session_data_type_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/sync/device_info/local_device_info_provider_mock.h"
 #include "components/sync/driver/fake_sync_client.h"
 #include "components/sync/driver/sync_api_component_factory_mock.h"
 #include "components/sync_sessions/fake_sync_sessions_client.h"
 #include "components/sync_sessions/synced_window_delegate.h"
 #include "components/sync_sessions/synced_window_delegates_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using sync_driver::LocalDeviceInfoProviderMock;
+using syncer::LocalDeviceInfoProviderMock;
 
 namespace sync_sessions {
 
 namespace {
 
 const char* kSavingBrowserHistoryDisabled = "history_disabled";
 
 class MockSyncedWindowDelegate : public SyncedWindowDelegate {
  public:
   MockSyncedWindowDelegate() : is_restore_in_progress_(false) {}
@@ skipping 51 matching lines @@
   void SetSyncedWindowDelegatesGetter(
       SyncedWindowDelegatesGetter* synced_window_getter) {
     synced_window_getter_ = synced_window_getter;
   }
 
  private:
   SyncedWindowDelegatesGetter* synced_window_getter_;
 };
 
 class SessionDataTypeControllerTest : public testing::Test,
-                                      public sync_driver::FakeSyncClient {
+                                      public syncer::FakeSyncClient {
  public:
   SessionDataTypeControllerTest()
-      : sync_driver::FakeSyncClient(&profile_sync_factory_),
+      : syncer::FakeSyncClient(&profile_sync_factory_),
         load_finished_(false),
         last_type_(syncer::UNSPECIFIED) {}
   ~SessionDataTypeControllerTest() override {}
 
   // FakeSyncClient overrides.
   PrefService* GetPrefService() override { return &prefs_; }
 
   SyncSessionsClient* GetSyncSessionsClient() override {
     return sync_sessions_client_.get();
   }
@@ skipping 65 matching lines @@
 
     if (!is_restore_in_progress)
       controller_->OnSessionRestoreComplete();
   }
 
  private:
   base::MessageLoop message_loop_;
   TestingPrefServiceSimple prefs_;
   std::unique_ptr<MockSyncedWindowDelegate> synced_window_delegate_;
   std::unique_ptr<MockSyncedWindowDelegatesGetter> synced_window_getter_;
-  SyncApiComponentFactoryMock profile_sync_factory_;
+  syncer::SyncApiComponentFactoryMock profile_sync_factory_;
   std::unique_ptr<TestSyncSessionsClient> sync_sessions_client_;
   std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
   std::unique_ptr<SessionDataTypeController> controller_;
 
   bool load_finished_;
   syncer::ModelType last_type_;
   syncer::SyncError last_error_;
 };
 
 TEST_F(SessionDataTypeControllerTest, StartModels) {
   Start();
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_LOADED, controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest, StartModelsDelayedByLocalDevice) {
   local_device()->SetInitialized(false);
   Start();
   EXPECT_FALSE(load_finished());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, controller()->state());
 
   local_device()->SetInitialized(true);
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_LOADED, controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest, StartModelsDelayedByRestoreInProgress) {
   SetSessionRestoreInProgress(true);
   Start();
   EXPECT_FALSE(load_finished());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, controller()->state());
 
   SetSessionRestoreInProgress(false);
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_LOADED, controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest,
        StartModelsDelayedByLocalDeviceThenRestoreInProgress) {
   local_device()->SetInitialized(false);
   SetSessionRestoreInProgress(true);
   Start();
   EXPECT_FALSE(load_finished());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, controller()->state());
 
   local_device()->SetInitialized(true);
   EXPECT_FALSE(load_finished());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, controller()->state());
 
   SetSessionRestoreInProgress(false);
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_LOADED, controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest,
        StartModelsDelayedByRestoreInProgressThenLocalDevice) {
   local_device()->SetInitialized(false);
   SetSessionRestoreInProgress(true);
   Start();
   EXPECT_FALSE(load_finished());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, controller()->state());
 
   SetSessionRestoreInProgress(false);
   EXPECT_FALSE(load_finished());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, controller()->state());
 
   local_device()->SetInitialized(true);
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller()->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_LOADED, controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 }  // namespace
 
 }  // namespace sync_sessions