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

components/sync/device_info/device_info_service_unittest.cc

 // Copyright 2015 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/device_info/device_info_service.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync/api/data_batch.h"
 #include "components/sync/api/data_type_error_handler_mock.h"
 #include "components/sync/api/entity_data.h"
 #include "components/sync/api/fake_model_type_change_processor.h"
 #include "components/sync/api/metadata_batch.h"
 #include "components/sync/api/model_type_store.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/test/model_type_store_test_util.h"
 #include "components/sync/device_info/local_device_info_provider_mock.h"
 #include "components/sync/protocol/data_type_state.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncer {
+namespace sync_driver_v2 {
 
 using base::Time;
 using base::TimeDelta;
+using syncer::SyncError;
+using syncer_v2::DataBatch;
+using syncer_v2::EntityChange;
+using syncer_v2::EntityChangeList;
+using syncer_v2::EntityData;
+using syncer_v2::EntityDataMap;
+using syncer_v2::EntityDataPtr;
+using syncer_v2::MetadataBatch;
+using syncer_v2::MetadataChangeList;
+using syncer_v2::ModelTypeChangeProcessor;
+using syncer_v2::ModelTypeService;
+using syncer_v2::ModelTypeStore;
+using syncer_v2::ModelTypeStoreTestUtil;
+using syncer_v2::KeyAndData;
+using sync_driver::DeviceInfo;
+using sync_driver::DeviceInfoTracker;
+using sync_driver::LocalDeviceInfoProviderMock;
 using sync_pb::DataTypeState;
 using sync_pb::DeviceInfoSpecifics;
 using sync_pb::EntitySpecifics;
 
 using DeviceInfoList = std::vector<std::unique_ptr<DeviceInfo>>;
 using StorageKeyList = ModelTypeService::StorageKeyList;
 using RecordList = ModelTypeStore::RecordList;
 using Result = ModelTypeStore::Result;
 using StartCallback = ModelTypeChangeProcessor::StartCallback;
 using WriteBatch = ModelTypeStore::WriteBatch;
@@ skipping 72 matching lines @@
                                     EntityChangeList* changes) {
   EntityDataPtr ptr = SpecificsToEntity(specifics);
   changes->push_back(EntityChange::CreateAdd(specifics.cache_guid(), ptr));
   return specifics.cache_guid();
 }
 
 // Instead of actually processing anything, simply accumulates all instructions
 // in members that can then be accessed. TODO(skym): If this ends up being
 // useful for other model type unittests it should be moved out to a shared
 // location.
-class RecordingModelTypeChangeProcessor : public FakeModelTypeChangeProcessor {
+class RecordingModelTypeChangeProcessor
+    : public syncer_v2::FakeModelTypeChangeProcessor {
  public:
   RecordingModelTypeChangeProcessor() {}
   ~RecordingModelTypeChangeProcessor() override {}
 
   void Put(const std::string& storage_key,
            std::unique_ptr<EntityData> entity_data,
            MetadataChangeList* metadata_changes) override {
     put_map_.insert(std::make_pair(storage_key, std::move(entity_data)));
   }
 
   void Delete(const std::string& storage_key,
               MetadataChangeList* metadata_changes) override {
     delete_set_.insert(storage_key);
   }
 
-  void OnMetadataLoaded(SyncError error,
+  void OnMetadataLoaded(syncer::SyncError error,
                         std::unique_ptr<MetadataBatch> batch) override {
     std::swap(metadata_, batch);
   }
 
   const std::map<std::string, std::unique_ptr<EntityData>>& put_map() const {
     return put_map_;
   }
   const std::set<std::string>& delete_set() const { return delete_set_; }
   const MetadataBatch* metadata() const { return metadata_.get(); }
 
@@ skipping 20 matching lines @@
     if (service_)
       service_->RemoveObserver(this);
 
     // Force all remaining (store) tasks to execute so we don't leak memory.
     base::RunLoop().RunUntilIdle();
   }
 
   void OnDeviceInfoChange() override { change_count_++; }
 
   std::unique_ptr<ModelTypeChangeProcessor> CreateModelTypeChangeProcessor(
-      ModelType type,
+      syncer::ModelType type,
       ModelTypeService* service) {
     processor_ = new RecordingModelTypeChangeProcessor();
     return base::WrapUnique(processor_);
   }
 
   // Initialized the service based on the current local device and store. Can
   // only be called once per run, as it passes |store_|.
   void InitializeService() {
     ASSERT_TRUE(store_);
     service_.reset(new DeviceInfoService(
         local_device_.get(),
         base::Bind(&ModelTypeStoreTestUtil::MoveStoreToCallback,
                    base::Passed(&store_)),
         base::Bind(&DeviceInfoServiceTest::CreateModelTypeChangeProcessor,
                    base::Unretained(this))));
     service_->AddObserver(this);
   }
 
   void OnSyncStarting() {
-    service()->OnSyncStarting(base::MakeUnique<DataTypeErrorHandlerMock>(),
-                              StartCallback());
+    service()->OnSyncStarting(
+        base::MakeUnique<syncer::DataTypeErrorHandlerMock>(), StartCallback());
   }
 
   // Creates the service and runs any outstanding tasks. This will typically
   // cause all initialization callbacks between the sevice and store to fire.
   void InitializeAndPump() {
     InitializeService();
     base::RunLoop().RunUntilIdle();
   }
 
   // Creates the service, runs any outstanding tasks, and then indicates to the
@@ skipping 366 matching lines @@
   DeviceInfoSpecifics specifics =
       GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
   EntityChangeList change_list;
   PushBackEntityChangeAdd(specifics, &change_list);
 
   // Should have a single change from reconciliation.
   EXPECT_TRUE(
       service()->GetDeviceInfo(local_device()->GetLocalDeviceInfo()->guid()));
   EXPECT_EQ(1, change_count());
   // Ensure |last_updated| is about now, plus or minus a little bit.
-  Time last_updated(ProtoTimeToTime(processor()
-                                        ->put_map()
-                                        .begin()
-                                        ->second->specifics.device_info()
-                                        .last_updated_timestamp()));
+  Time last_updated(
+      syncer::ProtoTimeToTime(processor()
+                                  ->put_map()
+                                  .begin()
+                                  ->second->specifics.device_info()
+                                  .last_updated_timestamp()));
   EXPECT_LT(Time::Now() - TimeDelta::FromMinutes(1), last_updated);
   EXPECT_GT(Time::Now() + TimeDelta::FromMinutes(1), last_updated);
 
   EXPECT_FALSE(
       service()
           ->ApplySyncChanges(service()->CreateMetadataChangeList(), change_list)
           .IsSet());
   EXPECT_EQ(1, change_count());
 
   change_list.clear();
@@ skipping 82 matching lines @@
 
   RestartService();
   ASSERT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeLocalGuid) {
   const DeviceInfo* local_device_info = local_device()->GetLocalDeviceInfo();
   std::unique_ptr<DeviceInfoSpecifics> specifics(
       CopyToSpecifics(*local_device_info));
-  specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
+  specifics->set_last_updated_timestamp(syncer::TimeToProtoTime(Time::Now()));
   const std::string guid = local_device_info->guid();
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   store()->WriteData(batch.get(), guid, specifics->SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPumpAndStart();
 
   EntityDataMap remote_input;
   remote_input[guid] = SpecificsToEntity(*specifics);
 
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(1u, service()->GetAllDeviceInfo().size());
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_TRUE(processor()->put_map().empty());
 }
 
 TEST_F(DeviceInfoServiceTest, GetLastUpdateTime) {
   Time time1(Time() + TimeDelta::FromDays(1));
 
   DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
-  specifics2.set_last_updated_timestamp(TimeToProtoTime(time1));
+  specifics2.set_last_updated_timestamp(syncer::TimeToProtoTime(time1));
 
   EXPECT_EQ(Time(), GetLastUpdateTime(specifics1));
   EXPECT_EQ(time1, GetLastUpdateTime(specifics2));
 }
 
 TEST_F(DeviceInfoServiceTest, CountActiveDevices) {
   InitializeAndPump();
   EXPECT_EQ(0, service()->CountActiveDevices());
 
   DeviceInfoSpecifics specifics =
       GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
   EntityChangeList change_list;
   PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                               change_list);
   EXPECT_EQ(0, service()->CountActiveDevices());
 
   change_list.clear();
-  specifics.set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
+  specifics.set_last_updated_timestamp(syncer::TimeToProtoTime(Time::Now()));
   PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                               change_list);
   EXPECT_EQ(0, service()->CountActiveDevices());
 
   change_list.clear();
   specifics.set_cache_guid("non-local");
   PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                               change_list);
   EXPECT_EQ(1, service()->CountActiveDevices());
 }
 
 }  // namespace
 
-}  // namespace syncer
+}  // namespace sync_driver_v2