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

components/autofill/core/browser/webdata/autofill_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/autofill/core/browser/webdata/autofill_data_type_controller.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 95 matching lines @@
   const scoped_refptr<base::SingleThreadTaskRunner> db_task_runner_;
   base::Callback<void(void)> db_loaded_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWebDataService);
 };
 
 class SyncAutofillDataTypeControllerTest : public testing::Test {
  public:
   SyncAutofillDataTypeControllerTest()
       : db_thread_("DB_Thread"),
-        last_start_result_(sync_driver::DataTypeController::OK),
+        last_start_result_(syncer::DataTypeController::OK),
         weak_ptr_factory_(this) {}
   ~SyncAutofillDataTypeControllerTest() override {}
 
   void SetUp() override {
     db_thread_.Start();
     web_data_service_ = new FakeWebDataService(
         base::ThreadTaskRunnerHandle::Get(), db_thread_.task_runner());
     autofill_dtc_ = base::MakeUnique<AutofillDataTypeController>(
         db_thread_.task_runner(), base::Bind(&base::DoNothing), &sync_client_,
         web_data_service_);
   }
 
   void TearDown() override {
     web_data_service_->ShutdownOnUIThread();
 
     // Make sure WebDataService is shutdown properly on DB thread before we
     // destroy it.
     base::RunLoop run_loop;
     ASSERT_TRUE(db_thread_.task_runner()->PostTaskAndReply(
         FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure()));
     run_loop.Run();
   }
 
   // Passed to AutofillDTC::Start().
-  void OnStartFinished(sync_driver::DataTypeController::ConfigureResult result,
+  void OnStartFinished(syncer::DataTypeController::ConfigureResult result,
                        const syncer::SyncMergeResult& local_merge_result,
                        const syncer::SyncMergeResult& syncer_merge_result) {
     last_start_result_ = result;
     last_start_error_ = local_merge_result.error();
   }
 
   void OnLoadFinished(syncer::ModelType type, const syncer::SyncError& error) {
     EXPECT_FALSE(error.IsSet());
     EXPECT_EQ(type, syncer::AUTOFILL);
   }
 
   void BlockForDBThread() {
     base::RunLoop run_loop;
     ASSERT_TRUE(db_thread_.task_runner()->PostTaskAndReply(
         FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure()));
     run_loop.Run();
   }
 
  protected:
   base::MessageLoop message_loop_;
   base::Thread db_thread_;
-  sync_driver::FakeSyncClient sync_client_;
+  syncer::FakeSyncClient sync_client_;
   std::unique_ptr<AutofillDataTypeController> autofill_dtc_;
   scoped_refptr<FakeWebDataService> web_data_service_;
 
   // Stores arguments of most recent call of OnStartFinished().
-  sync_driver::DataTypeController::ConfigureResult last_start_result_;
+  syncer::DataTypeController::ConfigureResult last_start_result_;
   syncer::SyncError last_start_error_;
   base::WeakPtrFactory<SyncAutofillDataTypeControllerTest> weak_ptr_factory_;
 };
 
 // Load the WDS's database, then start the Autofill DTC.  It should
 // immediately try to start association and fail (due to missing DB
 // thread).
 TEST_F(SyncAutofillDataTypeControllerTest, StartWDSReady) {
   web_data_service_->LoadDatabase();
   autofill_dtc_->LoadModels(
       base::Bind(&SyncAutofillDataTypeControllerTest::OnLoadFinished,
                  weak_ptr_factory_.GetWeakPtr()));
 
   autofill_dtc_->StartAssociating(
       base::Bind(&SyncAutofillDataTypeControllerTest::OnStartFinished,
                  weak_ptr_factory_.GetWeakPtr()));
   BlockForDBThread();
 
-  EXPECT_EQ(sync_driver::DataTypeController::ASSOCIATION_FAILED,
-            last_start_result_);
+  EXPECT_EQ(syncer::DataTypeController::ASSOCIATION_FAILED, last_start_result_);
   EXPECT_TRUE(last_start_error_.IsSet());
-  EXPECT_EQ(sync_driver::DataTypeController::DISABLED, autofill_dtc_->state());
+  EXPECT_EQ(syncer::DataTypeController::DISABLED, autofill_dtc_->state());
 }
 
 // Start the autofill DTC without the WDS's database loaded, then
 // start the DB.  The Autofill DTC should be in the MODEL_STARTING
 // state until the database in loaded, when it should try to start
 // association and fail (due to missing DB thread).
 TEST_F(SyncAutofillDataTypeControllerTest, StartWDSNotReady) {
   autofill_dtc_->LoadModels(
       base::Bind(&SyncAutofillDataTypeControllerTest::OnLoadFinished,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  EXPECT_EQ(sync_driver::DataTypeController::OK, last_start_result_);
+  EXPECT_EQ(syncer::DataTypeController::OK, last_start_result_);
   EXPECT_FALSE(last_start_error_.IsSet());
-  EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            autofill_dtc_->state());
+  EXPECT_EQ(syncer::DataTypeController::MODEL_STARTING, autofill_dtc_->state());
 
   web_data_service_->LoadDatabase();
 
   autofill_dtc_->StartAssociating(
       base::Bind(&SyncAutofillDataTypeControllerTest::OnStartFinished,
                  weak_ptr_factory_.GetWeakPtr()));
   BlockForDBThread();
 
-  EXPECT_EQ(sync_driver::DataTypeController::ASSOCIATION_FAILED,
-            last_start_result_);
+  EXPECT_EQ(syncer::DataTypeController::ASSOCIATION_FAILED, last_start_result_);
   EXPECT_TRUE(last_start_error_.IsSet());
 
-  EXPECT_EQ(sync_driver::DataTypeController::DISABLED, autofill_dtc_->state());
+  EXPECT_EQ(syncer::DataTypeController::DISABLED, autofill_dtc_->state());
 }
 
 }  // namespace
 
 }  // namespace browser_sync