[Sync] Move //components/sync_driver to //components/sync/driver.

components/sync/driver/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_driver/device_info_sync_service.h"
+#include "components/sync/driver/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_driver/device_info_util.h"
-#include "components/sync_driver/local_device_info_provider_mock.h"
+#include "components/sync/driver/device_info_util.h"
+#include "components/sync/driver/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;
@@ skipping 55 matching lines @@
 }  // namespace
 
 class DeviceInfoSyncServiceTest : public testing::Test,
                                   public DeviceInfoTracker::Observer {
  public:
   DeviceInfoSyncServiceTest() : num_device_info_changed_callbacks_(0) {}
   ~DeviceInfoSyncServiceTest() override {}
 
   void SetUp() override {
     local_device_.reset(new LocalDeviceInfoProviderMock(
-        "guid_1",
-        "client_1",
-        "Chromium 10k",
-        "Chrome 10k",
-        sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-        "device_id"));
+        "guid_1", "client_1", "Chromium 10k", "Chrome 10k",
+        sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id"));
     sync_service_.reset(new DeviceInfoSyncService(local_device_.get()));
     sync_processor_.reset(new TestChangeProcessor());
     // Register observer
     sync_service_->AddObserver(this);
   }
 
   void TearDown() override { sync_service_->RemoveObserver(this); }
 
   void OnDeviceInfoChange() override { num_device_info_changed_callbacks_++; }
 
@@ skipping 71 matching lines @@
   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(),
-                                              CreateAndPassSyncErrorFactory());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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());
@@ skipping 17 matching lines @@
   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());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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_->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());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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_->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(),
-                                              CreateAndPassSyncErrorFactory());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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());
 
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
   EXPECT_EQ(3U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_EQ("foo_2", sync_service_->GetDeviceInfo("guid_2")->client_name());
 
   change_list.clear();
   AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_3", "bar_3");
   AddChange(&change_list, SyncChange::ACTION_ADD, "guid_4", "baz_4");
 
   error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   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(),
-                                              CreateAndPassSyncErrorFactory());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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(),
-                                              CreateAndPassSyncErrorFactory());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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(),
-                                              CreateAndPassSyncErrorFactory());
+  SyncMergeResult merge_result = sync_service_->MergeDataAndStartSyncing(
+      syncer::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);
 
@@ skipping 150 matching lines @@
   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