Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

components/search_engines/search_engine_data_type_controller_unittest.cc

 // Copyright (c) 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 "components/search_engines/search_engine_data_type_controller.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 14 matching lines @@
 
 using testing::_;
 using testing::DoAll;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::SetArgumentPointee;
 
 namespace browser_sync {
 namespace {
 
-class SyncSearchEngineDataTypeControllerTest : public testing::Test,
-                                               public syncer::FakeSyncClient {
+class SyncSearchEngineDataTypeControllerTest
+    : public testing::Test,
+      public sync_driver::FakeSyncClient {
  public:
   SyncSearchEngineDataTypeControllerTest()
-      : syncer::FakeSyncClient(&profile_sync_factory_),
+      : sync_driver::FakeSyncClient(&profile_sync_factory_),
         template_url_service_(nullptr, 0),
         search_engine_dtc_(base::Closure(), this, &template_url_service_) {
     // Disallow the TemplateURLService from loading until
     // PreloadTemplateURLService() is called .
     template_url_service_.set_disable_load(true);
   }
 
   // FakeSyncClient overrides.
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) override {
     return syncable_service_.AsWeakPtr();
   }
 
   void TearDown() override {
     // Must be done before we pump the loop.
     syncable_service_.StopSyncing(syncer::SEARCH_ENGINES);
   }
 
  protected:
   void PreloadTemplateURLService() {
     template_url_service_.set_disable_load(false);
     template_url_service_.Load();
   }
 
   void SetStartExpectations() {
     search_engine_dtc_.SetGenericChangeProcessorFactoryForTest(
-        base::WrapUnique<syncer::GenericChangeProcessorFactory>(
-            new syncer::FakeGenericChangeProcessorFactory(
-                base::MakeUnique<syncer::FakeGenericChangeProcessor>(
+        base::WrapUnique<sync_driver::GenericChangeProcessorFactory>(
+            new sync_driver::FakeGenericChangeProcessorFactory(
+                base::MakeUnique<sync_driver::FakeGenericChangeProcessor>(
                     syncer::SEARCH_ENGINES, this))));
     EXPECT_CALL(model_load_callback_, Run(_, _));
   }
 
   void Start() {
     search_engine_dtc_.LoadModels(
-        base::Bind(&syncer::ModelLoadCallbackMock::Run,
+        base::Bind(&sync_driver::ModelLoadCallbackMock::Run,
                    base::Unretained(&model_load_callback_)));
-    search_engine_dtc_.StartAssociating(base::Bind(
-        &syncer::StartCallbackMock::Run, base::Unretained(&start_callback_)));
+    search_engine_dtc_.StartAssociating(
+        base::Bind(&sync_driver::StartCallbackMock::Run,
+                   base::Unretained(&start_callback_)));
     base::RunLoop().RunUntilIdle();
   }
 
   base::MessageLoop message_loop_;
   TemplateURLService template_url_service_;
   SearchEngineDataTypeController search_engine_dtc_;
-  syncer::SyncApiComponentFactoryMock profile_sync_factory_;
+  SyncApiComponentFactoryMock profile_sync_factory_;
   syncer::FakeSyncableService syncable_service_;
-  syncer::StartCallbackMock start_callback_;
-  syncer::ModelLoadCallbackMock model_load_callback_;
+  sync_driver::StartCallbackMock start_callback_;
+  sync_driver::ModelLoadCallbackMock model_load_callback_;
 };
 
 TEST_F(SyncSearchEngineDataTypeControllerTest, StartURLServiceReady) {
   SetStartExpectations();
   // We want to start ready.
   PreloadTemplateURLService();
-  EXPECT_CALL(start_callback_, Run(syncer::DataTypeController::OK, _, _));
+  EXPECT_CALL(start_callback_, Run(sync_driver::DataTypeController::OK, _, _));
 
-  EXPECT_EQ(syncer::DataTypeController::NOT_RUNNING,
+  EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
   Start();
-  EXPECT_EQ(syncer::DataTypeController::RUNNING, search_engine_dtc_.state());
+  EXPECT_EQ(sync_driver::DataTypeController::RUNNING,
+            search_engine_dtc_.state());
   EXPECT_TRUE(syncable_service_.syncing());
 }
 
 TEST_F(SyncSearchEngineDataTypeControllerTest, StartURLServiceNotReady) {
   EXPECT_CALL(model_load_callback_, Run(_, _));
   EXPECT_FALSE(syncable_service_.syncing());
   search_engine_dtc_.LoadModels(
-      base::Bind(&syncer::ModelLoadCallbackMock::Run,
+      base::Bind(&sync_driver::ModelLoadCallbackMock::Run,
                  base::Unretained(&model_load_callback_)));
   EXPECT_TRUE(search_engine_dtc_.GetSubscriptionForTesting());
-  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING,
+  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
 
   // Send the notification that the TemplateURLService has started.
   PreloadTemplateURLService();
   EXPECT_EQ(NULL, search_engine_dtc_.GetSubscriptionForTesting());
-  EXPECT_EQ(syncer::DataTypeController::MODEL_LOADED,
+  EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
             search_engine_dtc_.state());
 
   // Wait until WebDB is loaded before we shut it down.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SyncSearchEngineDataTypeControllerTest, StartAssociationFailed) {
   SetStartExpectations();
   PreloadTemplateURLService();
   EXPECT_CALL(start_callback_,
-              Run(syncer::DataTypeController::ASSOCIATION_FAILED, _, _));
+              Run(sync_driver::DataTypeController::ASSOCIATION_FAILED, _, _));
   syncable_service_.set_merge_data_and_start_syncing_error(
       syncer::SyncError(FROM_HERE,
                         syncer::SyncError::DATATYPE_ERROR,
                         "Error",
                         syncer::SEARCH_ENGINES));
 
   Start();
-  EXPECT_EQ(syncer::DataTypeController::DISABLED, search_engine_dtc_.state());
+  EXPECT_EQ(sync_driver::DataTypeController::DISABLED,
+            search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
   search_engine_dtc_.Stop();
-  EXPECT_EQ(syncer::DataTypeController::NOT_RUNNING,
+  EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
 }
 
 TEST_F(SyncSearchEngineDataTypeControllerTest, Stop) {
   SetStartExpectations();
   PreloadTemplateURLService();
-  EXPECT_CALL(start_callback_, Run(syncer::DataTypeController::OK, _, _));
+  EXPECT_CALL(start_callback_, Run(sync_driver::DataTypeController::OK, _, _));
 
-  EXPECT_EQ(syncer::DataTypeController::NOT_RUNNING,
+  EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
   Start();
-  EXPECT_EQ(syncer::DataTypeController::RUNNING, search_engine_dtc_.state());
+  EXPECT_EQ(sync_driver::DataTypeController::RUNNING,
+            search_engine_dtc_.state());
   EXPECT_TRUE(syncable_service_.syncing());
   search_engine_dtc_.Stop();
-  EXPECT_EQ(syncer::DataTypeController::NOT_RUNNING,
+  EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
 }
 
 TEST_F(SyncSearchEngineDataTypeControllerTest, StopBeforeLoaded) {
   EXPECT_FALSE(syncable_service_.syncing());
   search_engine_dtc_.LoadModels(
-      base::Bind(&syncer::ModelLoadCallbackMock::Run,
+      base::Bind(&sync_driver::ModelLoadCallbackMock::Run,
                  base::Unretained(&model_load_callback_)));
   EXPECT_TRUE(search_engine_dtc_.GetSubscriptionForTesting());
-  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING,
+  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
   search_engine_dtc_.Stop();
   EXPECT_EQ(NULL, search_engine_dtc_.GetSubscriptionForTesting());
-  EXPECT_EQ(syncer::DataTypeController::NOT_RUNNING,
+  EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING,
             search_engine_dtc_.state());
   EXPECT_FALSE(syncable_service_.syncing());
 }
 
 }  // namespace
 }  // namespace browser_sync