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

components/sync/core/processor_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 "components/sync/core/processor_entity_tracker.h"
 
 #include "base/base64.h"
 #include "base/sha1.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/non_blocking_sync_common.h"
 #include "components/sync/syncable/syncable_util.h"
 
-namespace syncer_v2 {
+namespace syncer {
 
 namespace {
 
 void HashSpecifics(const sync_pb::EntitySpecifics& specifics,
                    std::string* hash) {
   DCHECK_GT(specifics.ByteSize(), 0);
   base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()), hash);
 }
 
 }  // namespace
 
 std::unique_ptr<ProcessorEntityTracker> ProcessorEntityTracker::CreateNew(
     const std::string& storage_key,
     const std::string& client_tag_hash,
     const std::string& id,
     base::Time creation_time) {
   // Initialize metadata
   sync_pb::EntityMetadata metadata;
   metadata.set_client_tag_hash(client_tag_hash);
   if (!id.empty())
     metadata.set_server_id(id);
   metadata.set_sequence_number(0);
   metadata.set_acked_sequence_number(0);
   metadata.set_server_version(kUncommittedVersion);
-  metadata.set_creation_time(syncer::TimeToProtoTime(creation_time));
+  metadata.set_creation_time(TimeToProtoTime(creation_time));
 
   return std::unique_ptr<ProcessorEntityTracker>(
       new ProcessorEntityTracker(storage_key, &metadata));
 }
 
 std::unique_ptr<ProcessorEntityTracker>
 ProcessorEntityTracker::CreateFromMetadata(const std::string& storage_key,
                                            sync_pb::EntityMetadata* metadata) {
   return std::unique_ptr<ProcessorEntityTracker>(
       new ProcessorEntityTracker(storage_key, metadata));
@@ skipping 74 matching lines @@
   // commit and this should follow, or the pending commit needs to be requeued.
   commit_requested_sequence_number_ = metadata_.acked_sequence_number();
 }
 
 void ProcessorEntityTracker::RecordAcceptedUpdate(
     const UpdateResponseData& update) {
   DCHECK(!IsUnsynced());
   RecordIgnoredUpdate(update);
   metadata_.set_is_deleted(update.entity->is_deleted());
   metadata_.set_modification_time(
-      syncer::TimeToProtoTime(update.entity->modification_time));
+      TimeToProtoTime(update.entity->modification_time));
   UpdateSpecificsHash(update.entity->specifics);
 }
 
 void ProcessorEntityTracker::RecordForcedUpdate(
     const UpdateResponseData& update) {
   DCHECK(IsUnsynced());
   // There was a conflict and the server just won it. Explicitly ack all
   // pending commits so they are never enqueued again.
   metadata_.set_acked_sequence_number(metadata_.sequence_number());
   commit_data_.reset();
   RecordAcceptedUpdate(update);
 }
 
 void ProcessorEntityTracker::MakeLocalChange(std::unique_ptr<EntityData> data) {
   DCHECK(!metadata_.client_tag_hash().empty());
   DCHECK_EQ(metadata_.client_tag_hash(), data->client_tag_hash);
 
   if (data->modification_time.is_null()) {
     data->modification_time = base::Time::Now();
   }
 
   IncrementSequenceNumber();
   UpdateSpecificsHash(data->specifics);
-  metadata_.set_modification_time(
-      syncer::TimeToProtoTime(data->modification_time));
+  metadata_.set_modification_time(TimeToProtoTime(data->modification_time));
   metadata_.set_is_deleted(false);
 
   data->id = metadata_.server_id();
-  data->creation_time = syncer::ProtoTimeToTime(metadata_.creation_time());
+  data->creation_time = ProtoTimeToTime(metadata_.creation_time());
   commit_data_.reset();
   CacheCommitData(data.get());
 }
 
 void ProcessorEntityTracker::Delete() {
   IncrementSequenceNumber();
-  metadata_.set_modification_time(syncer::TimeToProtoTime(base::Time::Now()));
+  metadata_.set_modification_time(TimeToProtoTime(base::Time::Now()));
   metadata_.set_is_deleted(true);
   metadata_.clear_specifics_hash();
   // Clear any cached pending commit data.
   commit_data_.reset();
 }
 
 void ProcessorEntityTracker::InitializeCommitRequestData(
     CommitRequestData* request) {
   if (!metadata_.is_deleted()) {
     DCHECK(HasCommitData());
     DCHECK_EQ(commit_data_->client_tag_hash, metadata_.client_tag_hash());
     request->entity = commit_data_;
   } else {
     // Make an EntityData with empty specifics to indicate deletion. This is
     // done lazily here to simplify loading a pending deletion on startup.
     EntityData data;
     data.client_tag_hash = metadata_.client_tag_hash();
     data.id = metadata_.server_id();
-    data.creation_time = syncer::ProtoTimeToTime(metadata_.creation_time());
-    data.modification_time =
-        syncer::ProtoTimeToTime(metadata_.modification_time());
+    data.creation_time = ProtoTimeToTime(metadata_.creation_time());
+    data.modification_time = ProtoTimeToTime(metadata_.modification_time());
     request->entity = data.PassToPtr();
   }
 
   request->sequence_number = metadata_.sequence_number();
   request->base_version = metadata_.server_version();
   request->specifics_hash = metadata_.specifics_hash();
   commit_requested_sequence_number_ = metadata_.sequence_number();
 }
 
 void ProcessorEntityTracker::ReceiveCommitResponse(
@@ skipping 41 matching lines @@
 
 void ProcessorEntityTracker::UpdateSpecificsHash(
     const sync_pb::EntitySpecifics& specifics) {
   if (specifics.ByteSize() > 0) {
     HashSpecifics(specifics, metadata_.mutable_specifics_hash());
   } else {
     metadata_.clear_specifics_hash();
   }
 }
 
-}  // namespace syncer_v2
+}  // namespace syncer