Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

components/sync/engine_impl/model_type_worker.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/engine_impl/model_type_worker.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/model_type_processor.h"
 #include "components/sync/engine_impl/commit_contribution.h"
 #include "components/sync/engine_impl/non_blocking_type_commit_contribution.h"
 #include "components/sync/engine_impl/worker_entity_tracker.h"
 #include "components/sync/syncable/syncable_util.h"
 
-namespace syncer {
+namespace syncer_v2 {
+
+using syncer::CommitContribution;
+using syncer::Cryptographer;
+using syncer::ModelType;
+using syncer::NudgeHandler;
+using syncer::SyncerError;
 
 ModelTypeWorker::ModelTypeWorker(
     ModelType type,
     const sync_pb::DataTypeState& initial_state,
     std::unique_ptr<Cryptographer> cryptographer,
     NudgeHandler* nudge_handler,
     std::unique_ptr<ModelTypeProcessor> model_type_processor)
     : type_(type),
       data_type_state_(initial_state),
       model_type_processor_(std::move(model_type_processor)),
@@ skipping 46 matching lines @@
 void ModelTypeWorker::GetDataTypeContext(
     sync_pb::DataTypeContext* context) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   context->CopyFrom(data_type_state_.type_context());
 }
 
 SyncerError ModelTypeWorker::ProcessGetUpdatesResponse(
     const sync_pb::DataTypeProgressMarker& progress_marker,
     const sync_pb::DataTypeContext& mutated_context,
     const SyncEntityList& applicable_updates,
-    StatusController* status) {
+    syncer::StatusController* status) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(rlarocque): Handle data type context conflicts.
   *data_type_state_.mutable_type_context() = mutated_context;
   *data_type_state_.mutable_progress_marker() = progress_marker;
 
   for (const sync_pb::SyncEntity* update_entity : applicable_updates) {
     // Skip updates for permanent folders.
     // TODO(crbug.com/516866): might need to handle this for hierarchical types.
     if (!update_entity->server_defined_unique_tag().empty())
       continue;
 
     // Normal updates are handled here.
     const std::string& client_tag_hash =
         update_entity->client_defined_unique_tag();
 
     // TODO(crbug.com/516866): this wouldn't be true for bookmarks.
     DCHECK(!client_tag_hash.empty());
 
     // Prepare the message for the model thread.
     EntityData data;
     data.id = update_entity->id_string();
     data.client_tag_hash = client_tag_hash;
-    data.creation_time = ProtoTimeToTime(update_entity->ctime());
-    data.modification_time = ProtoTimeToTime(update_entity->mtime());
+    data.creation_time = syncer::ProtoTimeToTime(update_entity->ctime());
+    data.modification_time = syncer::ProtoTimeToTime(update_entity->mtime());
     data.non_unique_name = update_entity->name();
 
     UpdateResponseData response_data;
     response_data.response_version = update_entity->version();
 
     WorkerEntityTracker* entity = GetOrCreateEntityTracker(data);
 
     // Deleted entities must use the default instance of EntitySpecifics in
     // order for EntityData to correctly reflect that they are deleted.
     const sync_pb::EntitySpecifics& specifics =
@@ skipping 17 matching lines @@
         pending_updates_.push_back(response_data);
       }
     } else {
       // Can't decrypt right now. Ask the entity tracker to handle it.
       data.specifics = specifics;
       response_data.entity = data.PassToPtr();
       entity->ReceiveEncryptedUpdate(response_data);
     }
   }
 
-  return SYNCER_OK;
+  return syncer::SYNCER_OK;
 }
 
-void ModelTypeWorker::ApplyUpdates(StatusController* status) {
+void ModelTypeWorker::ApplyUpdates(syncer::StatusController* status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // This should only ever be called after one PassiveApplyUpdates.
   DCHECK(data_type_state_.initial_sync_done());
   // Download cycle is done, pass all updates to the processor.
   ApplyPendingUpdates();
 }
 
-void ModelTypeWorker::PassiveApplyUpdates(StatusController* status) {
+void ModelTypeWorker::PassiveApplyUpdates(syncer::StatusController* status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // This should only be called at the end of the very first download cycle.
   DCHECK(!data_type_state_.initial_sync_done());
   // Indicate to the processor that the initial download is done. The initial
   // sync technically isn't done yet but by the time this value is persisted to
   // disk on the model thread it will be.
   data_type_state_.set_initial_sync_done(true);
   ApplyPendingUpdates();
 }
 
 void ModelTypeWorker::ApplyPendingUpdates() {
   DVLOG(1) << ModelTypeToString(type_) << ": "
            << base::StringPrintf("Delivering %" PRIuS " applicable updates.",
                                  pending_updates_.size());
   model_type_processor_->OnUpdateReceived(data_type_state_, pending_updates_);
   pending_updates_.clear();
 }
 
 void ModelTypeWorker::EnqueueForCommit(const CommitRequestDataList& list) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsTypeInitialized())
       << "Asked to commit items before type was initialized. "
       << "ModelType is: " << ModelTypeToString(type_);
 
   for (const CommitRequestData& commit : list) {
     const EntityData& data = commit.entity.value();
     if (!data.is_deleted()) {
-      DCHECK_EQ(type_, GetModelTypeFromSpecifics(data.specifics));
+      DCHECK_EQ(type_, syncer::GetModelTypeFromSpecifics(data.specifics));
     }
     GetOrCreateEntityTracker(data)->RequestCommit(commit);
   }
 
   if (CanCommitItems())
     nudge_handler_->NudgeForCommit(type_);
 }
 
 // CommitContributor implementation.
 std::unique_ptr<CommitContribution> ModelTypeWorker::GetContribution(
@@ skipping 200 matching lines @@
   entities_[data.client_tag_hash] = std::move(entity);
   return entity_ptr;
 }
 
 WorkerEntityTracker* ModelTypeWorker::GetOrCreateEntityTracker(
     const EntityData& data) {
   WorkerEntityTracker* entity = GetEntityTracker(data.client_tag_hash);
   return entity ? entity : CreateEntityTracker(data);
 }
 
-}  // namespace syncer
+}  // namespace syncer_v2