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

components/sync_bookmarks/bookmark_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/sync_bookmarks/bookmark_data_type_controller.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 12 matching lines @@
 #include "components/sync/driver/data_type_controller_mock.h"
 #include "components/sync/driver/fake_sync_client.h"
 #include "components/sync/driver/fake_sync_service.h"
 #include "components/sync/driver/model_associator_mock.h"
 #include "components/sync/driver/sync_api_component_factory_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using bookmarks::BookmarkModel;
 using sync_bookmarks::BookmarkDataTypeController;
-using sync_driver::ChangeProcessorMock;
-using sync_driver::DataTypeController;
-using sync_driver::ModelAssociatorMock;
-using sync_driver::ModelLoadCallbackMock;
-using sync_driver::StartCallbackMock;
+using syncer::ChangeProcessorMock;
+using syncer::DataTypeController;
+using syncer::ModelAssociatorMock;
+using syncer::ModelLoadCallbackMock;
+using syncer::StartCallbackMock;
 using testing::_;
 using testing::DoAll;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::SetArgumentPointee;
 
 namespace {
 
 class HistoryMock : public history::HistoryService {
  public:
   HistoryMock() : history::HistoryService() {}
   MOCK_METHOD0(BackendLoaded, bool(void));
 
   ~HistoryMock() override {}
 };
 
 }  // namespace
 
 class SyncBookmarkDataTypeControllerTest : public testing::Test,
-                                           public sync_driver::FakeSyncClient {
+                                           public syncer::FakeSyncClient {
  public:
   SyncBookmarkDataTypeControllerTest() {}
 
   // FakeSyncClient overrides.
   BookmarkModel* GetBookmarkModel() override { return bookmark_model_.get(); }
   history::HistoryService* GetHistoryService() override {
     return history_service_.get();
   }
-  sync_driver::SyncService* GetSyncService() override {
-    return &service_;
-  }
-  sync_driver::SyncApiComponentFactory* GetSyncApiComponentFactory() override {
+  syncer::SyncService* GetSyncService() override { return &service_; }
+  syncer::SyncApiComponentFactory* GetSyncApiComponentFactory() override {
     return profile_sync_factory_.get();
   }
 
   void SetUp() override {
     model_associator_ = new ModelAssociatorMock();
     change_processor_ = new ChangeProcessorMock();
     history_service_.reset(new HistoryMock());
-    profile_sync_factory_.reset(
-        new SyncApiComponentFactoryMock(model_associator_,
-                                             change_processor_));
+    profile_sync_factory_.reset(new syncer::SyncApiComponentFactoryMock(
+        model_associator_, change_processor_));
     bookmark_dtc_.reset(
         new BookmarkDataTypeController(base::Bind(&base::DoNothing), this));
   }
 
  protected:
   enum BookmarkLoadPolicy {
     DONT_LOAD_MODEL,
     LOAD_MODEL,
   };
 
@@ skipping 37 matching lines @@
         base::Bind(&StartCallbackMock::Run,
                    base::Unretained(&start_callback_)));
     base::RunLoop().RunUntilIdle();
   }
 
   void NotifyHistoryServiceLoaded() {
     history_service_->NotifyHistoryServiceLoaded();
   }
 
   base::MessageLoop message_loop_;
-  std::unique_ptr<SyncApiComponentFactoryMock> profile_sync_factory_;
+  std::unique_ptr<syncer::SyncApiComponentFactoryMock> profile_sync_factory_;
   std::unique_ptr<BookmarkModel> bookmark_model_;
   std::unique_ptr<HistoryMock> history_service_;
   std::unique_ptr<BookmarkDataTypeController> bookmark_dtc_;
-  sync_driver::FakeSyncService service_;
+  syncer::FakeSyncService service_;
   ModelAssociatorMock* model_associator_;
   ChangeProcessorMock* change_processor_;
   StartCallbackMock start_callback_;
   ModelLoadCallbackMock model_load_callback_;
 };
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartDependentsReady) {
   CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   SetAssociateExpectations();
@@ skipping 141 matching lines @@
   SetStopExpectations();
 
   EXPECT_EQ(DataTypeController::NOT_RUNNING, bookmark_dtc_->state());
 
   EXPECT_CALL(start_callback_, Run(DataTypeController::OK, _, _));
   Start();
   EXPECT_EQ(DataTypeController::RUNNING, bookmark_dtc_->state());
   bookmark_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, bookmark_dtc_->state());
 }