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

components/sync/device_info/device_info_sync_service_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/device_info/device_info_sync_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "components/sync/api/sync_change.h"
 #include "components/sync/api/sync_change_processor.h"
 #include "components/sync/api/sync_change_processor_wrapper_for_test.h"
 #include "components/sync/api/sync_error_factory_mock.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/attachments/attachment_service_proxy_for_test.h"
 #include "components/sync/device_info/device_info_util.h"
 #include "components/sync/device_info/local_device_info_provider_mock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
-using syncer::AttachmentIdList;
-using syncer::AttachmentServiceProxyForTest;
-using syncer::ModelType;
-using syncer::SyncChange;
-using syncer::SyncChangeList;
-using syncer::SyncChangeProcessor;
-using syncer::SyncChangeProcessorWrapperForTest;
-using syncer::SyncData;
-using syncer::SyncDataList;
-using syncer::SyncError;
-using syncer::SyncErrorFactory;
-using syncer::SyncErrorFactoryMock;
-using syncer::SyncMergeResult;
 using sync_pb::EntitySpecifics;
 
-namespace sync_driver {
+namespace syncer {
 
 namespace {
 
 class TestChangeProcessor : public SyncChangeProcessor {
  public:
   TestChangeProcessor() {}
   ~TestChangeProcessor() override {}
 
   // SyncChangeProcessor implementation.
   // Store a copy of all the changes passed in so we can examine them later.
@@ skipping 78 matching lines @@
     return entity;
   }
 
   // Default |last_updated_timestamp| to now to avoid pulse update on merge.
   SyncData CreateRemoteData(const std::string& client_id,
                             const std::string& client_name,
                             Time last_updated_timestamp = Time::Now()) {
     sync_pb::EntitySpecifics entity(
         CreateEntitySpecifics(client_id, client_name));
     entity.mutable_device_info()->set_last_updated_timestamp(
-        syncer::TimeToProtoTime(last_updated_timestamp));
+        TimeToProtoTime(last_updated_timestamp));
     return SyncData::CreateRemoteData(1, entity, Time(), AttachmentIdList(),
                                       AttachmentServiceProxyForTest::Create());
   }
 
   void AddInitialData(SyncDataList* sync_data_list,
                       const std::string& client_id,
                       const std::string& client_name) {
     SyncData sync_data = CreateRemoteData(client_id, client_name);
     sync_data_list->push_back(sync_data);
   }
 
   void AddChange(SyncChangeList* change_list,
                  SyncChange::SyncChangeType change_type,
                  const std::string& client_id,
                  const std::string& client_name) {
     SyncData sync_data = CreateRemoteData(client_id, client_name);
     SyncChange sync_change(FROM_HERE, change_type, sync_data);
     change_list->push_back(sync_change);
   }
 
  protected:
   // Private method wrappers through friend class.
-  Time GetLastUpdateTime(const syncer::SyncData& data) {
+  Time GetLastUpdateTime(const SyncData& data) {
     return sync_service_->GetLastUpdateTime(data);
   }
   int CountActiveDevices(const Time now) {
     return sync_service_->CountActiveDevices(now);
   }
-  void StoreSyncData(const std::string& client_id,
-                     const syncer::SyncData& sync_data) {
+  void StoreSyncData(const std::string& client_id, const SyncData& sync_data) {
     sync_service_->StoreSyncData(client_id, sync_data);
   }
   bool IsPulseTimerRunning() { return sync_service_->pulse_timer_.IsRunning(); }
 
   // Needs to be created for OneShotTimer to grab the current task runner.
   base::MessageLoop message_loop_;
 
   int num_device_info_changed_callbacks_;
   std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
   std::unique_ptr<DeviceInfoSyncService> sync_service_;
   std::unique_ptr<TestChangeProcessor> sync_processor_;
 };
 
 namespace {
 
 // Sync with empty initial data.
 TEST_F(DeviceInfoSyncServiceTest, StartSyncEmptyInitialData) {
   EXPECT_FALSE(sync_service_->IsSyncing());
 
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, SyncDataList(), PassProcessor(),
+      DEVICE_INFO, SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   EXPECT_TRUE(sync_service_->IsSyncing());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(1, merge_result.num_items_before_association());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   EXPECT_EQ(SyncChange::ACTION_ADD, sync_processor_->change_type_at(0));
 
   EXPECT_EQ(1U, sync_processor_->change_list_size());
   EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
 
   // Should have one device info corresponding to local device info.
-  EXPECT_EQ(1U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size());
+  EXPECT_EQ(1U, sync_service_->GetAllSyncData(DEVICE_INFO).size());
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1"));
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0"));
 }
 
 TEST_F(DeviceInfoSyncServiceTest, StopSyncing) {
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, SyncDataList(), PassProcessor(),
+      DEVICE_INFO, SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   EXPECT_TRUE(sync_service_->IsSyncing());
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
   EXPECT_TRUE(IsPulseTimerRunning());
-  sync_service_->StopSyncing(syncer::DEVICE_INFO);
+  sync_service_->StopSyncing(DEVICE_INFO);
   EXPECT_FALSE(sync_service_->IsSyncing());
   EXPECT_EQ(2, num_device_info_changed_callbacks_);
   EXPECT_FALSE(IsPulseTimerRunning());
 }
 
 // Sync with initial data matching the local device data.
 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingInitialData) {
   SyncDataList sync_data;
   AddInitialData(&sync_data, "guid_1", "client_1");
 
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, sync_data, PassProcessor(),
-      CreateAndPassSyncErrorFactory());
+      DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(1, merge_result.num_items_before_association());
   EXPECT_EQ(1, merge_result.num_items_after_association());
 
   // No changes expected because the device info matches.
   EXPECT_EQ(0U, sync_processor_->change_list_size());
 
-  EXPECT_EQ(1U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size());
+  EXPECT_EQ(1U, sync_service_->GetAllSyncData(DEVICE_INFO).size());
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1"));
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0"));
 }
 
 // Sync with misc initial data.
 TEST_F(DeviceInfoSyncServiceTest, StartSync) {
   SyncDataList sync_data;
   AddInitialData(&sync_data, "guid_2", "foo");
   AddInitialData(&sync_data, "guid_3", "bar");
   // This guid matches the local device but the client name is different.
   AddInitialData(&sync_data, "guid_1", "baz");
 
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, sync_data, PassProcessor(),
-      CreateAndPassSyncErrorFactory());
+      DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(2, merge_result.num_items_added());
   EXPECT_EQ(1, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(1, merge_result.num_items_before_association());
   EXPECT_EQ(3, merge_result.num_items_after_association());
 
   EXPECT_EQ(1U, sync_processor_->change_list_size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0));
   EXPECT_EQ("client_1", sync_processor_->client_name_at(0));
 
-  EXPECT_EQ(3U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size());
+  EXPECT_EQ(3U, sync_service_->GetAllSyncData(DEVICE_INFO).size());
   EXPECT_EQ(3U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1"));
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2"));
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_3"));
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0"));
 }
 
 // Process sync change with ACTION_ADD.
 // Verify callback.
 TEST_F(DeviceInfoSyncServiceTest, ProcessAddChange) {
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
 
   // Start with an empty initial data.
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, SyncDataList(), PassProcessor(),
+      DEVICE_INFO, SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   // There should be only one item corresponding to the local device
   EXPECT_EQ(1, merge_result.num_items_after_association());
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
 
   // Add a new device info with a non-matching guid.
   SyncChangeList change_list;
   AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, num_device_info_changed_callbacks_);
 
   EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size());
 
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1"));
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2"));
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0"));
 }
 
 // Process multiple sync change with ACTION_UPDATE and ACTION_ADD.
 // Verify that callback is called multiple times.
 TEST_F(DeviceInfoSyncServiceTest, ProcessMultipleChanges) {
   SyncDataList sync_data;
   AddInitialData(&sync_data, "guid_2", "foo");
   AddInitialData(&sync_data, "guid_3", "bar");
 
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, sync_data, PassProcessor(),
-      CreateAndPassSyncErrorFactory());
+      DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory());
   EXPECT_EQ(3, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
   AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_2", "foo_2");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(2, num_device_info_changed_callbacks_);
   EXPECT_EQ(4U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_EQ("bar_3", sync_service_->GetDeviceInfo("guid_3")->client_name());
   EXPECT_EQ("baz_4", sync_service_->GetDeviceInfo("guid_4")->client_name());
 }
 
 // Process update to the local device info and verify that it is ignored.
 TEST_F(DeviceInfoSyncServiceTest, ProcessUpdateChangeMatchingLocalDevice) {
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, SyncDataList(), PassProcessor(),
+      DEVICE_INFO, SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
   AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_1", "foo_1");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
   // Callback shouldn't be sent in this case.
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
   // Should still have the old local device Info.
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_EQ("client_1", sync_service_->GetDeviceInfo("guid_1")->client_name());
 }
 
 // Process sync change with ACTION_DELETE.
 TEST_F(DeviceInfoSyncServiceTest, ProcessDeleteChange) {
   SyncDataList sync_data;
   AddInitialData(&sync_data, "guid_2", "foo");
   AddInitialData(&sync_data, "guid_3", "bar");
 
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, sync_data, PassProcessor(),
-      CreateAndPassSyncErrorFactory());
+      DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory());
   EXPECT_EQ(3, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
   AddChange(&change_list, SyncChange::ACTION_DELETE, "guid_2", "foo_2");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
   EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_2"));
 }
 
 // Process sync change with unexpected action.
 TEST_F(DeviceInfoSyncServiceTest, ProcessInvalidChange) {
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, SyncDataList(), PassProcessor(),
+      DEVICE_INFO, SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
   AddChange(&change_list, (SyncChange::SyncChangeType)100, "guid_2", "foo_2");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_TRUE(error.IsSet());
 
   // The number of callback should still be zero.
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
 }
 
 // Process sync change after unsubscribing from notifications.
 TEST_F(DeviceInfoSyncServiceTest, ProcessChangesAfterUnsubscribing) {
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, SyncDataList(), PassProcessor(),
+      DEVICE_INFO, SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
   AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo_2");
 
   // Unsubscribe observer before processing changes.
   sync_service_->RemoveObserver(this);
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   // The number of callback should still be zero.
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
 }
 
 // While the initial data will match the current device, the last modified time
 // should be greater than the threshold and cause an update anyways.
 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingButStale) {
   SyncDataList sync_data;
   sync_data.push_back(CreateRemoteData("guid_1", "foo_1", Time()));
   SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
-      syncer::DEVICE_INFO, sync_data, PassProcessor(),
-      CreateAndPassSyncErrorFactory());
+      DEVICE_INFO, sync_data, PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(1U, sync_processor_->change_list_size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0));
   EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
   EXPECT_EQ("client_1", sync_processor_->client_name_at(0));
 }
 
 TEST_F(DeviceInfoSyncServiceTest, GetLastUpdateTime) {
   Time time1(Time() + TimeDelta::FromDays(1));
   Time time2(Time() + TimeDelta::FromDays(2));
 
   SyncData localA(
       SyncData::CreateLocalData("a", "a", CreateEntitySpecifics("a", "a")));
 
   EntitySpecifics entityB(CreateEntitySpecifics("b", "b"));
   entityB.mutable_device_info()->set_last_updated_timestamp(
-      syncer::TimeToProtoTime(time1));
+      TimeToProtoTime(time1));
   SyncData localB(SyncData::CreateLocalData("b", "b", entityB));
 
   SyncData remoteC(SyncData::CreateRemoteData(
       1, CreateEntitySpecifics("c", "c"), time2, AttachmentIdList(),
       AttachmentServiceProxyForTest::Create()));
 
   EntitySpecifics entityD(CreateEntitySpecifics("d", "d"));
   entityD.mutable_device_info()->set_last_updated_timestamp(
-      syncer::TimeToProtoTime(time1));
+      TimeToProtoTime(time1));
   SyncData remoteD(
       SyncData::CreateRemoteData(1, entityD, time2, AttachmentIdList(),
                                  AttachmentServiceProxyForTest::Create()));
 
   EXPECT_EQ(Time(), GetLastUpdateTime(localA));
   EXPECT_EQ(time1, GetLastUpdateTime(localB));
   EXPECT_EQ(time2, GetLastUpdateTime(remoteC));
   EXPECT_EQ(time1, GetLastUpdateTime(remoteD));
 }
 
@@ skipping 98 matching lines @@
 TEST_F(DeviceInfoSyncServiceTest, CountActiveDevicesLocalStale) {
   sync_pb::EntitySpecifics entity;
   sync_pb::DeviceInfoSpecifics& specifics = *entity.mutable_device_info();
   specifics.set_cache_guid("stale");
   StoreSyncData("stale", SyncData::CreateLocalData("stale", "stale", entity));
   EXPECT_EQ(0, CountActiveDevices(Time() + DeviceInfoUtil::kActiveThreshold));
 }
 
 }  // namespace
 
-}  // namespace sync_driver
+}  // namespace syncer