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

components/sync/driver/shared_change_processor.cc

Index: components/sync/driver/shared_change_processor.cc
diff --git a/components/sync/driver/shared_change_processor.cc b/components/sync/driver/shared_change_processor.cc
index 15176a477b51cb743f4e6e501515f6c8117f4797..59659ab670f3528f75841ca61940537b09ba35ea 100644
--- a/components/sync/driver/shared_change_processor.cc
+++ b/components/sync/driver/shared_change_processor.cc
@@ -21,19 +21,19 @@ namespace syncer {
 class AttachmentService;
 }  // namespace syncer
 
-namespace sync_driver {
+namespace syncer {
 
-SharedChangeProcessor::SharedChangeProcessor(syncer::ModelType type)
+SharedChangeProcessor::SharedChangeProcessor(ModelType type)
     : disconnected_(false),
       type_(type),
       frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       generic_change_processor_(NULL) {
-  DCHECK_NE(type_, syncer::UNSPECIFIED);
+  DCHECK_NE(type_, UNSPECIFIED);
 }
 
 SharedChangeProcessor::~SharedChangeProcessor() {
   // We can either be deleted when the DTC is destroyed (on UI
-  // thread), or when the syncer::SyncableService stops syncing (datatype
+  // thread), or when the SyncableService stops syncing (datatype
   // thread).  |generic_change_processor_|, if non-NULL, must be
   // deleted on |backend_loop_|.
   if (backend_task_runner_.get()) {
@@ -54,16 +54,15 @@ SharedChangeProcessor::~SharedChangeProcessor() {
 void SharedChangeProcessor::StartAssociation(
     StartDoneCallback start_done,
     SyncClient* const sync_client,
-    syncer::UserShare* user_share,
-    std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) {
+    UserShare* user_share,
+    std::unique_ptr<DataTypeErrorHandler> error_handler) {
   DCHECK(user_share);
-  syncer::SyncMergeResult local_merge_result(type_);
-  syncer::SyncMergeResult syncer_merge_result(type_);
-  base::WeakPtrFactory<syncer::SyncMergeResult> weak_ptr_factory(
-      &syncer_merge_result);
+  SyncMergeResult local_merge_result(type_);
+  SyncMergeResult syncer_merge_result(type_);
+  base::WeakPtrFactory<SyncMergeResult> weak_ptr_factory(&syncer_merge_result);
 
   // Connect |shared_change_processor| to the syncer and get the
-  // syncer::SyncableService associated with type_.
+  // SyncableService associated with type_.
   // Note that it's possible the shared_change_processor has already been
   // disconnected at this point, so all our accesses to the syncer from this
   // point on are through it.
@@ -72,8 +71,8 @@ void SharedChangeProcessor::StartAssociation(
       Connect(sync_client, &factory, user_share, std::move(error_handler),
               weak_ptr_factory.GetWeakPtr());
   if (!local_service_.get()) {
-    syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                            "Failed to connect to syncer.", type_);
+    SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
+                    "Failed to connect to syncer.", type_);
     local_merge_result.set_error(error);
     start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result,
                    syncer_merge_result);
@@ -81,8 +80,7 @@ void SharedChangeProcessor::StartAssociation(
   }
 
   if (!CryptoReadyIfNecessary()) {
-    syncer::SyncError error(FROM_HERE, syncer::SyncError::CRYPTO_ERROR, "",
-                            type_);
+    SyncError error(FROM_HERE, SyncError::CRYPTO_ERROR, "", type_);
     local_merge_result.set_error(error);
     start_done.Run(DataTypeController::NEEDS_CRYPTO, local_merge_result,
                    syncer_merge_result);
@@ -91,8 +89,8 @@ void SharedChangeProcessor::StartAssociation(
 
   bool sync_has_nodes = false;
   if (!SyncModelHasUserCreatedNodes(&sync_has_nodes)) {
-    syncer::SyncError error(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR,
-                            "Failed to load sync nodes", type_);
+    SyncError error(FROM_HERE, SyncError::UNRECOVERABLE_ERROR,
+                    "Failed to load sync nodes", type_);
     local_merge_result.set_error(error);
     start_done.Run(DataTypeController::UNRECOVERABLE_ERROR, local_merge_result,
                    syncer_merge_result);
@@ -102,11 +100,10 @@ void SharedChangeProcessor::StartAssociation(
   // Scope for |initial_sync_data| which might be expensive, so we don't want
   // to keep it in memory longer than necessary.
   {
-    syncer::SyncDataList initial_sync_data;
+    SyncDataList initial_sync_data;
 
     base::TimeTicks start_time = base::TimeTicks::Now();
-    syncer::SyncError error =
-        GetAllSyncDataReturnError(type_, &initial_sync_data);
+    SyncError error = GetAllSyncDataReturnError(type_, &initial_sync_data);
     if (error.IsSet()) {
       local_merge_result.set_error(error);
       start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result,
@@ -117,17 +114,16 @@ void SharedChangeProcessor::StartAssociation(
     std::string datatype_context;
     if (GetDataTypeContext(&datatype_context)) {
       local_service_->UpdateDataTypeContext(
-          type_, syncer::SyncChangeProcessor::NO_REFRESH, datatype_context);
+          type_, SyncChangeProcessor::NO_REFRESH, datatype_context);
     }
 
     syncer_merge_result.set_num_items_before_association(
         initial_sync_data.size());
     // Passes a reference to |shared_change_processor|.
     local_merge_result = local_service_->MergeDataAndStartSyncing(
-        type_, initial_sync_data, std::unique_ptr<syncer::SyncChangeProcessor>(
+        type_, initial_sync_data, std::unique_ptr<SyncChangeProcessor>(
                                       new SharedChangeProcessorRef(this)),
-        std::unique_ptr<syncer::SyncErrorFactory>(
-            new SharedChangeProcessorRef(this)));
+        std::unique_ptr<SyncErrorFactory>(new SharedChangeProcessorRef(this)));
     RecordAssociationTime(base::TimeTicks::Now() - start_time);
     if (local_merge_result.error().IsSet()) {
       start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result,
@@ -143,25 +139,25 @@ void SharedChangeProcessor::StartAssociation(
                  local_merge_result, syncer_merge_result);
 }
 
-base::WeakPtr<syncer::SyncableService> SharedChangeProcessor::Connect(
+base::WeakPtr<SyncableService> SharedChangeProcessor::Connect(
     SyncClient* sync_client,
     GenericChangeProcessorFactory* processor_factory,
-    syncer::UserShare* user_share,
-    std::unique_ptr<syncer::DataTypeErrorHandler> error_handler,
-    const base::WeakPtr<syncer::SyncMergeResult>& merge_result) {
+    UserShare* user_share,
+    std::unique_ptr<DataTypeErrorHandler> error_handler,
+    const base::WeakPtr<SyncMergeResult>& merge_result) {
   DCHECK(sync_client);
   DCHECK(error_handler);
   backend_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   AutoLock lock(monitor_lock_);
   if (disconnected_)
-    return base::WeakPtr<syncer::SyncableService>();
+    return base::WeakPtr<SyncableService>();
   error_handler_ = std::move(error_handler);
-  base::WeakPtr<syncer::SyncableService> local_service =
+  base::WeakPtr<SyncableService> local_service =
       sync_client->GetSyncableServiceForType(type_);
   if (!local_service.get()) {
     LOG(WARNING) << "SyncableService destroyed before DTC was stopped.";
     disconnected_ = true;
-    return base::WeakPtr<syncer::SyncableService>();
+    return base::WeakPtr<SyncableService>();
   }
 
   generic_change_processor_ = processor_factory
@@ -170,7 +166,7 @@ base::WeakPtr<syncer::SyncableService> SharedChangeProcessor::Connect(
                                       local_service, merge_result, sync_client)
                                   .release();
   // If available, propagate attachment service to the syncable service.
-  std::unique_ptr<syncer::AttachmentService> attachment_service =
+  std::unique_ptr<AttachmentService> attachment_service =
       generic_change_processor_->GetAttachmentService();
   if (attachment_service) {
     local_service->SetAttachmentService(std::move(attachment_service));
@@ -203,54 +199,53 @@ int SharedChangeProcessor::GetSyncCount() {
   return generic_change_processor_->GetSyncCount();
 }
 
-syncer::SyncError SharedChangeProcessor::ProcessSyncChanges(
+SyncError SharedChangeProcessor::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const syncer::SyncChangeList& list_of_changes) {
+    const SyncChangeList& list_of_changes) {
   DCHECK(backend_task_runner_.get());
   DCHECK(backend_task_runner_->BelongsToCurrentThread());
   AutoLock lock(monitor_lock_);
   if (disconnected_) {
     // The DTC that disconnects us must ensure it posts a StopSyncing task.
     // If we reach this, it means it just hasn't executed yet.
-    syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                            "Change processor disconnected.", type_);
+    SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
+                    "Change processor disconnected.", type_);
     return error;
   }
   return generic_change_processor_->ProcessSyncChanges(from_here,
                                                        list_of_changes);
 }
 
-syncer::SyncDataList SharedChangeProcessor::GetAllSyncData(
-    syncer::ModelType type) const {
-  syncer::SyncDataList data;
+SyncDataList SharedChangeProcessor::GetAllSyncData(ModelType type) const {
+  SyncDataList data;
   GetAllSyncDataReturnError(type, &data);  // Handles the disconnect case.
   return data;
 }
 
-syncer::SyncError SharedChangeProcessor::GetAllSyncDataReturnError(
-    syncer::ModelType type,
-    syncer::SyncDataList* data) const {
+SyncError SharedChangeProcessor::GetAllSyncDataReturnError(
+    ModelType type,
+    SyncDataList* data) const {
   DCHECK(backend_task_runner_.get());
   DCHECK(backend_task_runner_->BelongsToCurrentThread());
   AutoLock lock(monitor_lock_);
   if (disconnected_) {
-    syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                            "Change processor disconnected.", type_);
+    SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
+                    "Change processor disconnected.", type_);
     return error;
   }
   return generic_change_processor_->GetAllSyncDataReturnError(data);
 }
 
-syncer::SyncError SharedChangeProcessor::UpdateDataTypeContext(
-    syncer::ModelType type,
-    syncer::SyncChangeProcessor::ContextRefreshStatus refresh_status,
+SyncError SharedChangeProcessor::UpdateDataTypeContext(
+    ModelType type,
+    SyncChangeProcessor::ContextRefreshStatus refresh_status,
     const std::string& context) {
   DCHECK(backend_task_runner_.get());
   DCHECK(backend_task_runner_->BelongsToCurrentThread());
   AutoLock lock(monitor_lock_);
   if (disconnected_) {
-    syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                            "Change processor disconnected.", type_);
+    SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
+                    "Change processor disconnected.", type_);
     return error;
   }
   return generic_change_processor_->UpdateDataTypeContext(type, refresh_status,
@@ -258,7 +253,7 @@ syncer::SyncError SharedChangeProcessor::UpdateDataTypeContext(
 }
 
 void SharedChangeProcessor::AddLocalChangeObserver(
-    syncer::LocalChangeObserver* observer) {
+    LocalChangeObserver* observer) {
   DCHECK(backend_task_runner_.get());
   DCHECK(backend_task_runner_->BelongsToCurrentThread());
 
@@ -266,7 +261,7 @@ void SharedChangeProcessor::AddLocalChangeObserver(
 }
 
 void SharedChangeProcessor::RemoveLocalChangeObserver(
-    syncer::LocalChangeObserver* observer) {
+    LocalChangeObserver* observer) {
   DCHECK(backend_task_runner_.get());
   DCHECK(backend_task_runner_->BelongsToCurrentThread());
 
@@ -306,15 +301,14 @@ bool SharedChangeProcessor::GetDataTypeContext(std::string* context) const {
   return generic_change_processor_->GetDataTypeContext(context);
 }
 
-syncer::SyncError SharedChangeProcessor::CreateAndUploadError(
+SyncError SharedChangeProcessor::CreateAndUploadError(
     const tracked_objects::Location& location,
     const std::string& message) {
   AutoLock lock(monitor_lock_);
   if (!disconnected_) {
     return error_handler_->CreateAndUploadError(location, message, type_);
   } else {
-    return syncer::SyncError(location, syncer::SyncError::DATATYPE_ERROR,
-                             message, type_);
+    return SyncError(location, SyncError::DATATYPE_ERROR, message, type_);
   }
 }
 
@@ -331,4 +325,4 @@ void SharedChangeProcessor::StopLocalService() {
   local_service_.reset();
 }
 
-}  // namespace sync_driver
+}  // namespace syncer