move V2 classes in chrome/engine to syncer_v2 namespace

sync/engine/entity_tracker.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 "sync/engine/entity_tracker.h"
 
 #include "base/logging.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/time.h"
 
-namespace syncer {
+namespace syncer_v2 {
 
 scoped_ptr<EntityTracker> EntityTracker::FromServerUpdate(
     const std::string& id_string,
     const std::string& client_tag_hash,
     int64 received_version) {
   return make_scoped_ptr(
       new EntityTracker(id_string, client_tag_hash, 0, received_version));
 }
 
 scoped_ptr<EntityTracker> EntityTracker::FromCommitRequest(
@@ skipping 56 matching lines @@
 }
 
 bool EntityTracker::IsCommitPending() const {
   return is_commit_pending_;
 }
 
 void EntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
                                        int64* sequence_number) const {
   // Set ID if we have a server-assigned ID.  Otherwise, it will be up to
   // our caller to assign a client-unique initial ID.
-  if (base_version_ != syncer_v2::kUncommittedVersion) {
+  if (base_version_ != kUncommittedVersion) {
     commit_entity->set_id_string(id_);
   }
 
   commit_entity->set_client_defined_unique_tag(client_tag_hash_);
   commit_entity->set_version(base_version_);
   commit_entity->set_deleted(deleted_);
   commit_entity->set_folder(false);
   commit_entity->set_name(non_unique_name_);
   if (!deleted_) {
-    commit_entity->set_ctime(TimeToProtoTime(ctime_));
-    commit_entity->set_mtime(TimeToProtoTime(mtime_));
+    commit_entity->set_ctime(syncer::TimeToProtoTime(ctime_));
+    commit_entity->set_mtime(syncer::TimeToProtoTime(mtime_));
     commit_entity->mutable_specifics()->CopyFrom(specifics_);
   }
 
   *sequence_number = sequence_number_;
 }
 
 void EntityTracker::RequestCommit(const std::string& id,
                                   const std::string& client_tag_hash,
                                   int64 sequence_number,
                                   int64 base_version,
@@ skipping 82 matching lines @@
   // to discard the old pending update, if there was one.
   ClearPendingUpdate();
 
   if (IsInConflict()) {
     // Incoming update clobbers the pending commit on the sync thread.
     // The model thread can re-request this commit later if it wants to.
     ClearPendingCommit();
   }
 }
 
-bool EntityTracker::ReceivePendingUpdate(
-    const syncer_v2::UpdateResponseData& data) {
+bool EntityTracker::ReceivePendingUpdate(const UpdateResponseData& data) {
   if (data.response_version < highest_gu_response_version_)
     return false;
 
   highest_gu_response_version_ = data.response_version;
-  pending_update_.reset(new syncer_v2::UpdateResponseData(data));
+  pending_update_.reset(new UpdateResponseData(data));
   ClearPendingCommit();
   return true;
 }
 
 bool EntityTracker::HasPendingUpdate() const {
   return !!pending_update_;
 }
 
-syncer_v2::UpdateResponseData EntityTracker::GetPendingUpdate() const {
+UpdateResponseData EntityTracker::GetPendingUpdate() const {
   return *pending_update_;
 }
 
 void EntityTracker::ClearPendingUpdate() {
   pending_update_.reset();
 }
 
 bool EntityTracker::IsInConflict() const {
   if (!is_commit_pending_)
     return false;
@@ skipping 11 matching lines @@
     // commit request?
     if (base_version_ >= highest_gu_response_version_) {
       return false;  // Yes.
     } else {
       return true;  // No.
     }
   }
 }
 
 bool EntityTracker::IsServerKnown() const {
-  return base_version_ != syncer_v2::kUncommittedVersion;
+  return base_version_ != kUncommittedVersion;
 }
 
 void EntityTracker::ClearPendingCommit() {
   is_commit_pending_ = false;
 
   // Clearing the specifics might free up some memory.  It can't hurt to try.
   specifics_.Clear();
 }
 
 }  // namespace syncer