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

components/browser_sync/profile_sync_components_factory_impl.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/browser_sync/profile_sync_components_factory_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/dump_without_crashing.h"
@@ skipping 35 matching lines @@
 #include "components/sync_bookmarks/bookmark_model_associator.h"
 #include "components/sync_sessions/session_data_type_controller.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "google_apis/gaia/oauth2_token_service_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using bookmarks::BookmarkModel;
 using sync_bookmarks::BookmarkChangeProcessor;
 using sync_bookmarks::BookmarkDataTypeController;
 using sync_bookmarks::BookmarkModelAssociator;
-using sync_driver::DataTypeController;
-using sync_driver::DataTypeManager;
-using sync_driver::DataTypeManagerImpl;
-using sync_driver::DataTypeManagerObserver;
-using sync_driver::DeviceInfoDataTypeController;
-using sync_driver::ProxyDataTypeController;
-using sync_driver::UIDataTypeController;
-using sync_driver_v2::UIModelTypeController;
+using syncer::DataTypeController;
+using syncer::DataTypeManager;
+using syncer::DataTypeManagerImpl;
+using syncer::DataTypeManagerObserver;
+using syncer::DeviceInfoDataTypeController;
+using syncer::ProxyDataTypeController;
+using syncer::UIDataTypeController;
+using syncer::UIModelTypeController;
 using sync_sessions::SessionDataTypeController;
 
 namespace browser_sync {
 
 namespace {
 
 syncer::ModelTypeSet GetDisabledTypesFromCommandLine(
     const base::CommandLine& command_line) {
   syncer::ModelTypeSet disabled_types;
   std::string disabled_types_str =
@@ skipping 11 matching lines @@
 // Used to gate syncing preferences, see crbug.com/374865 for more information.
 // Has always been on for desktop/ChromeOS, so default to on. This feature is
 // mainly to give us a kill switch should something go wrong with starting to
 // sync prefs on mobile.
 const base::Feature kSyncPreferencesFeature{"SyncPreferences",
                                             base::FEATURE_ENABLED_BY_DEFAULT};
 
 }  // namespace
 
 ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
-    sync_driver::SyncClient* sync_client,
+    syncer::SyncClient* sync_client,
     version_info::Channel channel,
     const std::string& version,
     bool is_tablet,
     const base::CommandLine& command_line,
     const char* history_disabled_pref,
     const GURL& sync_service_url,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
     OAuth2TokenService* token_service,
     net::URLRequestContextGetter* url_request_context_getter,
@@ skipping 13 matching lines @@
       web_data_service_(web_data_service),
       password_store_(password_store),
       weak_factory_(this) {
   DCHECK(token_service_);
   DCHECK(url_request_context_getter_);
 }
 
 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {}
 
 void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
-    sync_driver::SyncService* sync_service,
+    syncer::SyncService* sync_service,
     const RegisterDataTypesMethod& register_platform_types_method) {
   syncer::ModelTypeSet disabled_types =
       GetDisabledTypesFromCommandLine(command_line_);
   syncer::ModelTypeSet enabled_types =
       GetEnabledTypesFromCommandLine(command_line_);
   RegisterCommonDataTypes(sync_service, disabled_types, enabled_types);
   if (!register_platform_types_method.is_null())
     register_platform_types_method.Run(sync_service, disabled_types,
                                        enabled_types);
 }
 
 void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes(
-    sync_driver::SyncService* sync_service,
+    syncer::SyncService* sync_service,
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types) {
   base::Closure error_callback =
-      base::Bind(&ChromeReportUnrecoverableError, channel_);
+      base::Bind(&syncer::ChromeReportUnrecoverableError, channel_);
 
   // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes?
   if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) {
     // Use an error callback that always uploads a stacktrace if it can to help
     // get USS as stable as possible.
     sync_service->RegisterDataTypeController(
         base::MakeUnique<UIModelTypeController>(
             syncer::DEVICE_INFO, base::Bind(&base::debug::DumpWithoutCrashing),
             sync_client_));
   } else {
@@ skipping 124 matching lines @@
     sync_service->RegisterDataTypeController(
         base::MakeUnique<UIDataTypeController>(syncer::ARTICLES, error_callback,
                                                sync_client_));
   }
 }
 
 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const DataTypeController::TypeMap* controllers,
-    const sync_driver::DataTypeEncryptionHandler* encryption_handler,
-    SyncBackendHost* backend,
+    const syncer::DataTypeEncryptionHandler* encryption_handler,
+    syncer::SyncBackendHost* backend,
     DataTypeManagerObserver* observer) {
   return new DataTypeManagerImpl(debug_info_listener, controllers,
                                  encryption_handler, backend, observer);
 }
 
-SyncBackendHost* ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
+syncer::SyncBackendHost*
+ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
     const std::string& name,
     invalidation::InvalidationService* invalidator,
-    const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
+    const base::WeakPtr<syncer::SyncPrefs>& sync_prefs,
     const base::FilePath& sync_folder) {
-  return new SyncBackendHostImpl(name, sync_client_, ui_thread_, invalidator,
-                                 sync_prefs, sync_folder);
+  return new syncer::SyncBackendHostImpl(name, sync_client_, ui_thread_,
+                                         invalidator, sync_prefs, sync_folder);
 }
 
-std::unique_ptr<sync_driver::LocalDeviceInfoProvider>
+std::unique_ptr<syncer::LocalDeviceInfoProvider>
 ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() {
-  return base::MakeUnique<LocalDeviceInfoProviderImpl>(channel_, version_,
-                                                       is_tablet_);
+  return base::MakeUnique<syncer::LocalDeviceInfoProviderImpl>(
+      channel_, version_, is_tablet_);
 }
 
 class TokenServiceProvider
     : public OAuth2TokenServiceRequest::TokenServiceProvider {
  public:
   TokenServiceProvider(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       OAuth2TokenService* token_service);
 
   // OAuth2TokenServiceRequest::TokenServiceProvider implementation.
@@ skipping 67 matching lines @@
       base::TimeDelta::FromMinutes(30);
   const base::TimeDelta max_backoff_delay = base::TimeDelta::FromHours(4);
   std::unique_ptr<syncer::AttachmentService> attachment_service(
       new syncer::AttachmentServiceImpl(
           std::move(attachment_store), std::move(attachment_uploader),
           std::move(attachment_downloader), delegate, initial_backoff_delay,
           max_backoff_delay));
   return attachment_service;
 }
 
-sync_driver::SyncApiComponentFactory::SyncComponents
+syncer::SyncApiComponentFactory::SyncComponents
 ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
-    sync_driver::SyncService* sync_service,
+    syncer::SyncService* sync_service,
     std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) {
   BookmarkModel* bookmark_model =
       sync_service->GetSyncClient()->GetBookmarkModel();
   syncer::UserShare* user_share = sync_service->GetUserShare();
 // TODO(akalin): We may want to propagate this switch up eventually.
 #if defined(OS_ANDROID) || defined(OS_IOS)
   const bool kExpectMobileBookmarksFolder = true;
 #else
   const bool kExpectMobileBookmarksFolder = false;
 #endif
   BookmarkModelAssociator* model_associator = new BookmarkModelAssociator(
       bookmark_model, sync_service->GetSyncClient(), user_share,
       error_handler->Copy(), kExpectMobileBookmarksFolder);
   BookmarkChangeProcessor* change_processor =
       new BookmarkChangeProcessor(sync_service->GetSyncClient(),
                                   model_associator, std::move(error_handler));
   return SyncComponents(model_associator, change_processor);
 }
 
 // static
 void ProfileSyncComponentsFactoryImpl::OverridePrefsForUssTest(bool use_uss) {
   override_prefs_controller_to_uss_for_test_ = use_uss;
 }
 
 bool ProfileSyncComponentsFactoryImpl::
     override_prefs_controller_to_uss_for_test_ = false;
 
 }  // namespace browser_sync