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

components/sync/core/shared_model_type_processor.cc

 // Copyright 2014 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/core/shared_model_type_processor.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/core/activation_context.h"
 #include "components/sync/core/processor_entity_tracker.h"
 #include "components/sync/engine/commit_queue.h"
 #include "components/sync/protocol/proto_value_conversions.h"
 #include "components/sync/syncable/syncable_util.h"
 
-namespace syncer_v2 {
+namespace syncer {
 
 namespace {
 
 class ModelTypeProcessorProxy : public ModelTypeProcessor {
  public:
   ModelTypeProcessorProxy(
       const base::WeakPtr<ModelTypeProcessor>& processor,
       const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
   ~ModelTypeProcessorProxy() override;
 
@@ skipping 38 matching lines @@
 void ModelTypeProcessorProxy::OnUpdateReceived(
     const sync_pb::DataTypeState& type_state,
     const UpdateResponseDataList& updates) {
   processor_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ModelTypeProcessor::OnUpdateReceived, processor_,
                             type_state, updates));
 }
 
 }  // namespace
 
-SharedModelTypeProcessor::SharedModelTypeProcessor(syncer::ModelType type,
+SharedModelTypeProcessor::SharedModelTypeProcessor(ModelType type,
                                                    ModelTypeService* service)
     : type_(type),
       is_metadata_loaded_(false),
       is_initial_pending_data_loaded_(false),
       service_(service),
       error_handler_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(service);
 }
 
 SharedModelTypeProcessor::~SharedModelTypeProcessor() {}
 
 // static
 std::unique_ptr<ModelTypeChangeProcessor>
-SharedModelTypeProcessor::CreateAsChangeProcessor(syncer::ModelType type,
+SharedModelTypeProcessor::CreateAsChangeProcessor(ModelType type,
                                                   ModelTypeService* service) {
   return std::unique_ptr<ModelTypeChangeProcessor>(
       new SharedModelTypeProcessor(type, service));
 }
 
 void SharedModelTypeProcessor::OnSyncStarting(
-    std::unique_ptr<syncer::DataTypeErrorHandler> error_handler,
+    std::unique_ptr<DataTypeErrorHandler> error_handler,
     const StartCallback& start_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(start_callback_.is_null());
   DCHECK(!IsConnected());
   DCHECK(error_handler);
   DVLOG(1) << "Sync is starting for " << ModelTypeToString(type_);
 
   error_handler_ = std::move(error_handler);
   start_callback_ = start_callback;
   ConnectIfReady();
 }
 
 void SharedModelTypeProcessor::OnMetadataLoaded(
-    syncer::SyncError error,
+    SyncError error,
     std::unique_ptr<MetadataBatch> batch) {
   DCHECK(CalledOnValidThread());
   DCHECK(entities_.empty());
   DCHECK(!is_metadata_loaded_);
   DCHECK(!IsConnected());
 
   is_metadata_loaded_ = true;
   // Flip this flag here to cover all cases where we don't need to load data.
   is_initial_pending_data_loaded_ = true;
 
@@ skipping 60 matching lines @@
   return is_metadata_loaded_;
 }
 
 bool SharedModelTypeProcessor::IsConnected() const {
   DCHECK(CalledOnValidThread());
   return !!worker_;
 }
 
 void SharedModelTypeProcessor::GetAllNodes(
     const scoped_refptr<base::TaskRunner>& task_runner,
-    const base::Callback<void(const syncer::ModelType,
+    const base::Callback<void(const ModelType,
                               std::unique_ptr<base::ListValue>)>& callback) {
   DCHECK(service_);
   service_->GetAllData(
       base::Bind(&SharedModelTypeProcessor::MergeDataWithMetadata,
                  base::Unretained(this), task_runner, callback));
 }
 
 void SharedModelTypeProcessor::DisableSync() {
   DCHECK(CalledOnValidThread());
   std::unique_ptr<MetadataChangeList> change_list =
       service_->CreateMetadataChangeList();
   for (auto it = entities_.begin(); it != entities_.end(); ++it) {
     change_list->ClearMetadata(it->second->storage_key());
   }
   change_list->ClearDataTypeState();
   // Nothing to do if this fails, so just ignore the error it might return.
   service_->ApplySyncChanges(std::move(change_list), EntityChangeList());
 }
 
-syncer::SyncError SharedModelTypeProcessor::CreateAndUploadError(
+SyncError SharedModelTypeProcessor::CreateAndUploadError(
     const tracked_objects::Location& location,
     const std::string& message) {
   if (error_handler_) {
     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_);
   }
 }
 
 void SharedModelTypeProcessor::ConnectSync(
     std::unique_ptr<CommitQueue> worker) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "Successfully connected " << ModelTypeToString(type_);
 
   worker_ = std::move(worker);
 
@@ skipping 13 matching lines @@
   }
 }
 
 void SharedModelTypeProcessor::Put(const std::string& storage_key,
                                    std::unique_ptr<EntityData> data,
                                    MetadataChangeList* metadata_change_list) {
   DCHECK(IsAllowingChanges());
   DCHECK(data.get());
   DCHECK(!data->is_deleted());
   DCHECK(!data->non_unique_name.empty());
-  DCHECK_EQ(type_, syncer::GetModelTypeFromSpecifics(data->specifics));
+  DCHECK_EQ(type_, GetModelTypeFromSpecifics(data->specifics));
 
   if (!data_type_state_.initial_sync_done()) {
     // Ignore changes before the initial sync is done.
     return;
   }
 
   // Fill in some data.
   data->client_tag_hash = GetClientTagHash(storage_key, *data);
   if (data->modification_time.is_null()) {
     data->modification_time = base::Time::Now();
@@ skipping 89 matching lines @@
     entity->ReceiveCommitResponse(data);
 
     if (entity->CanClearMetadata()) {
       change_list->ClearMetadata(entity->storage_key());
       entities_.erase(entity->metadata().client_tag_hash());
     } else {
       change_list->UpdateMetadata(entity->storage_key(), entity->metadata());
     }
   }
 
-  syncer::SyncError error =
+  SyncError error =
       service_->ApplySyncChanges(std::move(change_list), EntityChangeList());
   if (error.IsSet()) {
     error_handler_->OnUnrecoverableError(error);
   }
 }
 
 void SharedModelTypeProcessor::OnUpdateReceived(
     const sync_pb::DataTypeState& data_type_state,
     const UpdateResponseDataList& updates) {
   if (!data_type_state_.initial_sync_done()) {
@@ skipping 35 matching lines @@
     if (got_new_encryption_requirements) {
       already_updated.insert(entity->storage_key());
     }
   }
 
   if (got_new_encryption_requirements) {
     RecommitAllForEncryption(already_updated, metadata_changes.get());
   }
 
   // Inform the service of the new or updated data.
-  syncer::SyncError error =
+  SyncError error =
       service_->ApplySyncChanges(std::move(metadata_changes), entity_changes);
 
   if (error.IsSet()) {
     error_handler_->OnUnrecoverableError(error);
   } else {
     // There may be new reasons to commit by the time this function is done.
     FlushPendingCommitRequests();
   }
 }
 
@@ skipping 172 matching lines @@
 
   for (const UpdateResponseData& update : updates) {
     ProcessorEntityTracker* entity = CreateEntity(update.entity.value());
     const std::string& storage_key = entity->storage_key();
     entity->RecordAcceptedUpdate(update);
     metadata_changes->UpdateMetadata(storage_key, entity->metadata());
     data_map[storage_key] = update.entity;
   }
 
   // Let the service handle associating and merging the data.
-  syncer::SyncError error =
+  SyncError error =
       service_->MergeSyncData(std::move(metadata_changes), data_map);
 
   if (error.IsSet()) {
     error_handler_->OnUnrecoverableError(error);
   } else {
     // We may have new reasons to commit by the time this function is done.
     FlushPendingCommitRequests();
   }
 }
 
 void SharedModelTypeProcessor::OnInitialPendingDataLoaded(
-    syncer::SyncError error,
+    SyncError error,
     std::unique_ptr<DataBatch> data_batch) {
   DCHECK(!is_initial_pending_data_loaded_);
 
   if (error.IsSet()) {
     start_error_ = error;
   } else {
     ConsumeDataBatch(std::move(data_batch));
   }
 
   is_initial_pending_data_loaded_ = true;
   ConnectIfReady();
 }
 
 void SharedModelTypeProcessor::OnDataLoadedForReEncryption(
-    syncer::SyncError error,
+    SyncError error,
     std::unique_ptr<DataBatch> data_batch) {
   DCHECK(is_initial_pending_data_loaded_);
 
   if (error.IsSet()) {
     error_handler_->OnUnrecoverableError(error);
     return;
   }
 
   ConsumeDataBatch(std::move(data_batch));
   FlushPendingCommitRequests();
 }
 
 void SharedModelTypeProcessor::ConsumeDataBatch(
     std::unique_ptr<DataBatch> data_batch) {
   while (data_batch->HasNext()) {
     KeyAndData data = data_batch->Next();
     ProcessorEntityTracker* entity = GetEntityForStorageKey(data.first);
     // If the entity wasn't deleted or updated with new commit.
     if (entity != nullptr && entity->RequiresCommitData()) {
       entity->CacheCommitData(data.second.get());
     }
   }
 }
 
 std::string SharedModelTypeProcessor::GetHashForTag(const std::string& tag) {
-  return syncer::syncable::GenerateSyncableHash(type_, tag);
+  return syncable::GenerateSyncableHash(type_, tag);
 }
 
 std::string SharedModelTypeProcessor::GetClientTagHash(
     const std::string& storage_key,
     const EntityData& data) {
   auto iter = storage_key_to_tag_hash_.find(storage_key);
   return iter == storage_key_to_tag_hash_.end()
              ? GetHashForTag(service_->GetClientTag(data))
              : iter->second;
 }
@@ skipping 29 matching lines @@
 
 ProcessorEntityTracker* SharedModelTypeProcessor::CreateEntity(
     const EntityData& data) {
   // Verify the tag hash matches, may be relaxed in the future.
   DCHECK_EQ(data.client_tag_hash, GetHashForTag(service_->GetClientTag(data)));
   return CreateEntity(service_->GetStorageKey(data), data);
 }
 
 void SharedModelTypeProcessor::MergeDataWithMetadata(
     const scoped_refptr<base::TaskRunner>& task_runner,
-    const base::Callback<void(const syncer::ModelType,
+    const base::Callback<void(const ModelType,
                               std::unique_ptr<base::ListValue>)>& callback,
-    syncer::SyncError error,
+    SyncError error,
     std::unique_ptr<DataBatch> batch) {
   std::unique_ptr<base::ListValue> all_nodes =
       base::MakeUnique<base::ListValue>();
   std::string type_string = ModelTypeToString(type_);
 
   while (batch->HasNext()) {
     KeyAndData data = batch->Next();
     std::unique_ptr<base::DictionaryValue> node =
         data.second->ToDictionaryValue();
     ProcessorEntityTracker* entity = GetEntityForStorageKey(data.first);
     // Entity could be null if there are some unapplied changes.
     if (entity != nullptr) {
-      node->Set("metadata", syncer::EntityMetadataToValue(entity->metadata()));
+      node->Set("metadata", EntityMetadataToValue(entity->metadata()));
     }
     node->SetString("modelType", type_string);
     all_nodes->Append(std::move(node));
   }
 
   // Create a permanent folder for this data type. Since sync server no longer
   // create root folders, and USS won't migrate root folders from directory, we
   // create root folders for each data type here.
   std::unique_ptr<base::DictionaryValue> rootnode =
       base::MakeUnique<base::DictionaryValue>();
   // Function isTypeRootNode in sync_node_browser.js use PARENT_ID and
   // UNIQUE_SERVER_TAG to check if the node is root node. isChildOf in
   // sync_node_browser.js uses modelType to check if root node is parent of real
   // data node. NON_UNIQUE_NAME will be the name of node to display.
   rootnode->SetString("PARENT_ID", "r");
   rootnode->SetString("UNIQUE_SERVER_TAG", type_string);
   rootnode->SetBoolean("IS_DIR", true);
   rootnode->SetString("modelType", type_string);
   rootnode->SetString("NON_UNIQUE_NAME", type_string);
   all_nodes->Append(std::move(rootnode));
 
   task_runner->PostTask(FROM_HERE,
                         base::Bind(callback, type_, base::Passed(&all_nodes)));
 }
 
-}  // namespace syncer_v2
+}  // namespace syncer