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

components/sync/core/processor_entity_tracker_unittest.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 <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/non_blocking_sync_common.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncer {
+namespace syncer_v2 {
 
 namespace {
 
 const char kKey[] = "key";
 const char kHash[] = "hash";
 const char kId[] = "id";
 const char kName[] = "name";
 const char kValue1[] = "value1";
 const char kValue2[] = "value2";
 const char kValue3[] = "value3";
@@ skipping 96 matching lines @@
 TEST_F(ProcessorEntityTrackerTest, DefaultTracker) {
   std::unique_ptr<ProcessorEntityTracker> entity = CreateNew();
 
   EXPECT_EQ(kKey, entity->storage_key());
   EXPECT_EQ(kHash, entity->metadata().client_tag_hash());
   EXPECT_EQ("", entity->metadata().server_id());
   EXPECT_FALSE(entity->metadata().is_deleted());
   EXPECT_EQ(0, entity->metadata().sequence_number());
   EXPECT_EQ(0, entity->metadata().acked_sequence_number());
   EXPECT_EQ(kUncommittedVersion, entity->metadata().server_version());
-  EXPECT_EQ(TimeToProtoTime(ctime_), entity->metadata().creation_time());
+  EXPECT_EQ(syncer::TimeToProtoTime(ctime_),
+            entity->metadata().creation_time());
   EXPECT_EQ(0, entity->metadata().modification_time());
   EXPECT_TRUE(entity->metadata().specifics_hash().empty());
   EXPECT_TRUE(entity->metadata().base_specifics_hash().empty());
 
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_FALSE(entity->RequiresCommitRequest());
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_FALSE(entity->CanClearMetadata());
   EXPECT_FALSE(entity->UpdateIsReflection(1));
   EXPECT_FALSE(entity->HasCommitData());
@@ skipping 34 matching lines @@
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_FALSE(entity->CanClearMetadata());
   EXPECT_FALSE(entity->UpdateIsReflection(1));
   EXPECT_TRUE(entity->HasCommitData());
 
   const EntityData& data = request.entity.value();
   EXPECT_EQ("", data.id);
   EXPECT_EQ(kHash, data.client_tag_hash);
   EXPECT_EQ(kName, data.non_unique_name);
   EXPECT_EQ(kValue1, data.specifics.preference().value());
-  EXPECT_EQ(TimeToProtoTime(ctime_), TimeToProtoTime(data.creation_time));
+  EXPECT_EQ(syncer::TimeToProtoTime(ctime_),
+            syncer::TimeToProtoTime(data.creation_time));
   EXPECT_EQ(entity->metadata().modification_time(),
-            TimeToProtoTime(data.modification_time));
+            syncer::TimeToProtoTime(data.modification_time));
   EXPECT_FALSE(data.is_deleted());
   EXPECT_EQ(1, request.sequence_number);
   EXPECT_EQ(kUncommittedVersion, request.base_version);
   EXPECT_EQ(entity->metadata().specifics_hash(), request.specifics_hash);
 
   // Ack the commit.
   entity->ReceiveCommitResponse(GenerateAckData(request, kId, 1));
 
   EXPECT_EQ(kId, entity->metadata().server_id());
   EXPECT_FALSE(entity->metadata().is_deleted());
@@ skipping 20 matching lines @@
 
   const base::Time mtime = base::Time::Now();
   entity->RecordAcceptedUpdate(
       GenerateUpdate(*entity, kHash, kId, kName, kValue1, mtime, 10));
 
   EXPECT_EQ(kId, entity->metadata().server_id());
   EXPECT_FALSE(entity->metadata().is_deleted());
   EXPECT_EQ(0, entity->metadata().sequence_number());
   EXPECT_EQ(0, entity->metadata().acked_sequence_number());
   EXPECT_EQ(10, entity->metadata().server_version());
-  EXPECT_EQ(TimeToProtoTime(mtime), entity->metadata().modification_time());
+  EXPECT_EQ(syncer::TimeToProtoTime(mtime),
+            entity->metadata().modification_time());
   EXPECT_FALSE(entity->metadata().specifics_hash().empty());
   EXPECT_TRUE(entity->metadata().base_specifics_hash().empty());
 
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_FALSE(entity->RequiresCommitRequest());
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_FALSE(entity->CanClearMetadata());
   EXPECT_TRUE(entity->UpdateIsReflection(9));
   EXPECT_TRUE(entity->UpdateIsReflection(10));
   EXPECT_FALSE(entity->UpdateIsReflection(11));
   EXPECT_FALSE(entity->HasCommitData());
 }
 
 // Test state for a tombstone received for a previously unknown item.
 TEST_F(ProcessorEntityTrackerTest, NewServerTombstone) {
   std::unique_ptr<ProcessorEntityTracker> entity = CreateNew();
 
   const base::Time mtime = base::Time::Now();
   entity->RecordAcceptedUpdate(
       GenerateTombstone(*entity, kHash, kId, kName, mtime, 1));
 
   EXPECT_EQ(kId, entity->metadata().server_id());
   EXPECT_TRUE(entity->metadata().is_deleted());
   EXPECT_EQ(0, entity->metadata().sequence_number());
   EXPECT_EQ(0, entity->metadata().acked_sequence_number());
   EXPECT_EQ(1, entity->metadata().server_version());
-  EXPECT_EQ(TimeToProtoTime(mtime), entity->metadata().modification_time());
+  EXPECT_EQ(syncer::TimeToProtoTime(mtime),
+            entity->metadata().modification_time());
   EXPECT_TRUE(entity->metadata().specifics_hash().empty());
   EXPECT_TRUE(entity->metadata().base_specifics_hash().empty());
 
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_FALSE(entity->RequiresCommitRequest());
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_TRUE(entity->CanClearMetadata());
   EXPECT_TRUE(entity->UpdateIsReflection(1));
   EXPECT_FALSE(entity->UpdateIsReflection(2));
   EXPECT_FALSE(entity->HasCommitData());
 }
 
 // Apply a deletion update to a synced item.
 TEST_F(ProcessorEntityTrackerTest, ServerTombstone) {
   // Start with a non-deleted state with version 1.
   std::unique_ptr<ProcessorEntityTracker> entity = CreateSynced();
   // A deletion update one version later.
   const base::Time mtime = base::Time::Now();
   entity->RecordAcceptedUpdate(
       GenerateTombstone(*entity, kHash, kId, kName, mtime, 2));
 
   EXPECT_TRUE(entity->metadata().is_deleted());
   EXPECT_EQ(0, entity->metadata().sequence_number());
   EXPECT_EQ(0, entity->metadata().acked_sequence_number());
   EXPECT_EQ(2, entity->metadata().server_version());
-  EXPECT_EQ(TimeToProtoTime(mtime), entity->metadata().modification_time());
+  EXPECT_EQ(syncer::TimeToProtoTime(mtime),
+            entity->metadata().modification_time());
   EXPECT_TRUE(entity->metadata().specifics_hash().empty());
   EXPECT_TRUE(entity->metadata().base_specifics_hash().empty());
 
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_FALSE(entity->RequiresCommitRequest());
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_TRUE(entity->CanClearMetadata());
   EXPECT_TRUE(entity->UpdateIsReflection(2));
   EXPECT_FALSE(entity->UpdateIsReflection(3));
   EXPECT_FALSE(entity->HasCommitData());
@@ skipping 82 matching lines @@
   EXPECT_TRUE(entity->IsUnsynced());
   EXPECT_FALSE(entity->RequiresCommitRequest());
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_FALSE(entity->CanClearMetadata());
   EXPECT_FALSE(entity->HasCommitData());
 
   const EntityData& data = request.entity.value();
   EXPECT_EQ(kId, data.id);
   EXPECT_EQ(kHash, data.client_tag_hash);
   EXPECT_EQ("", data.non_unique_name);
-  EXPECT_EQ(TimeToProtoTime(ctime_), TimeToProtoTime(data.creation_time));
+  EXPECT_EQ(syncer::TimeToProtoTime(ctime_),
+            syncer::TimeToProtoTime(data.creation_time));
   EXPECT_EQ(entity->metadata().modification_time(),
-            TimeToProtoTime(data.modification_time));
+            syncer::TimeToProtoTime(data.modification_time));
   EXPECT_TRUE(data.is_deleted());
   EXPECT_EQ(1, request.sequence_number);
   EXPECT_EQ(1, request.base_version);
   EXPECT_EQ(entity->metadata().specifics_hash(), request.specifics_hash);
 
   // Ack the deletion.
   entity->ReceiveCommitResponse(GenerateAckData(request, kId, 2));
 
   EXPECT_TRUE(entity->metadata().is_deleted());
   EXPECT_EQ(1, entity->metadata().sequence_number());
@@ skipping 73 matching lines @@
   EXPECT_EQ(specifics_hash_v2, entity->metadata().specifics_hash());
   EXPECT_EQ("", entity->metadata().base_specifics_hash());
 
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_FALSE(entity->RequiresCommitRequest());
   EXPECT_FALSE(entity->RequiresCommitData());
   EXPECT_FALSE(entity->CanClearMetadata());
   EXPECT_FALSE(entity->HasCommitData());
 }
 
-}  // namespace syncer
+}  // namespace syncer_v2