[Sync] Services can now always assume processor exists.

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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 161 matching lines @@
 
     // 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,
       ModelTypeService* service) {
-    processor_ = new RecordingModelTypeChangeProcessor();
-    return base::WrapUnique(processor_);
+    std::unique_ptr<RecordingModelTypeChangeProcessor> processor =

[maxbogue, 2016/10/12 23:40:35]

You can just do "auto processor". That's being encouraged across the codebase in
combination with MakeUnique, from what I've seen.

[skym, 2016/10/13 19:21:38]

Done.

+        base::MakeUnique<RecordingModelTypeChangeProcessor>();
+    processor_ = processor.get();
+    return 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());
-  }
-
   // 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
-  // service that sync wants to start and forces the processor to be created.
-  void InitializeAndPumpAndStart() {
-    InitializeAndPump();
-    OnSyncStarting();
-    ASSERT_TRUE(processor_);
-  }
-
   // Generates a specifics object with slightly differing values. Will generate
   // the same values on each run of a test because a simple counter is used to
   // vary field values.
   DeviceInfoSpecifics GenerateTestSpecifics() {
     int label = ++generated_count_;
     DeviceInfoSpecifics specifics;
     specifics.set_cache_guid(base::StringPrintf("cache guid %d", label));
     specifics.set_client_name(base::StringPrintf("client name %d", label));
     specifics.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
     specifics.set_sync_user_agent(
         base::StringPrintf("sync user agent %d", label));
     specifics.set_chrome_version(
         base::StringPrintf("chrome version %d", label));
     specifics.set_signin_scoped_device_id(
         base::StringPrintf("signin scoped device id %d", label));
     return specifics;
   }
 
   std::unique_ptr<DeviceInfoSpecifics> CopyToSpecifics(const DeviceInfo& info) {
     return DeviceInfoService::CopyToSpecifics(info);
   }
 
   // Override to allow specific cache guids.
   DeviceInfoSpecifics GenerateTestSpecifics(const std::string& guid) {
-    DeviceInfoSpecifics specifics(GenerateTestSpecifics());
+    DeviceInfoSpecifics specifics = GenerateTestSpecifics();
     specifics.set_cache_guid(guid);
     return specifics;
   }
 
   // Allows access to the store before that will ultimately be used to
   // initialize the service.
   ModelTypeStore* store() {
     EXPECT_TRUE(store_);
     return store_.get();
   }
@@ skipping 60 matching lines @@
 
   // A monotonically increasing label for generated specifics objects with data
   // that is slightly different from eachother.
   int generated_count_ = 0;
 };
 
 namespace {
 
 TEST_F(DeviceInfoServiceTest, EmptyDataReconciliation) {
   InitializeAndPump();
-  ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
-  OnSyncStarting();
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(1u, all_device_info.size());
-  ASSERT_TRUE(
-      local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
+  DeviceInfoList devices = service()->GetAllDeviceInfo();
+  ASSERT_EQ(1u, devices.size());
+  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 TEST_F(DeviceInfoServiceTest, EmptyDataReconciliationSlowLoad) {
   InitializeService();
-  OnSyncStarting();
   ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
   base::RunLoop().RunUntilIdle();
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(1u, all_device_info.size());
-  ASSERT_TRUE(
-      local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
+  DeviceInfoList devices = service()->GetAllDeviceInfo();
+  ASSERT_EQ(1u, devices.size());
+  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 TEST_F(DeviceInfoServiceTest, LocalProviderSubscription) {
   set_local_device(base::MakeUnique<LocalDeviceInfoProviderMock>());
-  InitializeAndPumpAndStart();
+  InitializeAndPump();
 
   ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateDeviceInfo());
   base::RunLoop().RunUntilIdle();
 
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(1u, all_device_info.size());
-  ASSERT_TRUE(
-      local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
+  DeviceInfoList devices = service()->GetAllDeviceInfo();
+  ASSERT_EQ(1u, devices.size());
+  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 // Metadata shouldn't be loaded before the provider is initialized.
 TEST_F(DeviceInfoServiceTest, LocalProviderInitRace) {
   set_local_device(base::WrapUnique(new LocalDeviceInfoProviderMock()));
   InitializeAndPump();
-  OnSyncStarting();
   EXPECT_FALSE(processor()->metadata());
 
   ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateDeviceInfo());
   base::RunLoop().RunUntilIdle();
 
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(1u, all_device_info.size());
-  ASSERT_TRUE(
-      local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
+  DeviceInfoList devices = service()->GetAllDeviceInfo();
+  ASSERT_EQ(1u, devices.size());
+  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 
   EXPECT_TRUE(processor()->metadata());
 }
 
 TEST_F(DeviceInfoServiceTest, GetClientTagNormal) {
   InitializeService();
   const std::string guid = "abc";
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info()->set_cache_guid(guid);
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(guid), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, GetClientTagEmpty) {
   InitializeService();
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info();
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(""), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics(GenerateTestSpecifics());
+  DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(1u, all_device_info.size());
-  AssertEqual(specifics, *all_device_info[0]);
+  ASSERT_EQ(2u, service()->GetAllDeviceInfo().size());
   AssertEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
   InitializeAndPump();
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(1u, all_device_info.size());
-  ASSERT_TRUE(
-      local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
+  DeviceInfoList devices = service()->GetAllDeviceInfo();
+  ASSERT_EQ(1u, devices.size());
+  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
   EXPECT_EQ(1u, processor()->put_map().size());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalDataAndMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics(GenerateTestSpecifics());
+  DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
-  DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
-  ASSERT_EQ(2u, all_device_info.size());
+  ASSERT_EQ(2u, service()->GetAllDeviceInfo().size());
   AssertEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
   ASSERT_TRUE(processor()->metadata());
   ASSERT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, GetData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
-  DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
-  DeviceInfoSpecifics specifics3(GenerateTestSpecifics());
+  DeviceInfoSpecifics specifics1 = GenerateTestSpecifics();
+  DeviceInfoSpecifics specifics2 = GenerateTestSpecifics();
+  DeviceInfoSpecifics specifics3 = GenerateTestSpecifics();
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
                      specifics2.SerializeAsString());
   store()->WriteData(batch.get(), specifics3.cache_guid(),
                      specifics3.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
@@ skipping 12 matching lines @@
   InitializeAndPump();
   std::map<std::string, DeviceInfoSpecifics> expected;
   StorageKeyList storage_keys;
   storage_keys.push_back("does_not_exist");
   service()->GetData(storage_keys,
                      base::Bind(&AssertExpectedFromDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, GetAllData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
-  DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
+  DeviceInfoSpecifics specifics1 = GenerateTestSpecifics();
+  DeviceInfoSpecifics specifics2 = GenerateTestSpecifics();
   const std::string& guid1 = specifics1.cache_guid();
   const std::string& guid2 = specifics2.cache_guid();
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
                      specifics2.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
   std::map<std::string, DeviceInfoSpecifics> expected;
   expected[guid1] = specifics1;
   expected[guid2] = specifics2;
   StorageKeyList storage_keys;
   storage_keys.push_back(guid1);
   storage_keys.push_back(guid2);
   service()->GetData(storage_keys,
                      base::Bind(&AssertExpectedFromDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesEmpty) {
   InitializeAndPump();
+  EXPECT_EQ(1, change_count());
   const SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), EntityChangeList());
   EXPECT_FALSE(error.IsSet());
-  EXPECT_EQ(0, change_count());
+  EXPECT_EQ(1, change_count());

[maxbogue, 2016/10/12 23:40:35]

I'm confused... why did this change?

[skym, 2016/10/13 19:21:38]

So what was happening originally was that the service wouldn't reconcile until
it had a proc, and it refused to drive the processor of creating a proc.
However, now that we always have a proc, it always performs reconcile after
loading metadata. There's a big fat comment in device_info_service.cc explaining
that we don't make sure the processor is tracking our changes yet, and we don't
care. Although it'd probably be ideal to change that, I didn't want to do it in
this CL. See
https://cs.chromium.org/chromium/src/components/sync/device_info/device_info_...

 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesInMemory) {
   InitializeAndPump();
+  EXPECT_EQ(1, change_count());
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList add_changes;
   PushBackEntityChangeAdd(specifics, &add_changes);
   SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), add_changes);
 
   EXPECT_FALSE(error.IsSet());
   std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
-  EXPECT_EQ(1, change_count());
+  EXPECT_EQ(2, change_count());
 
   EntityChangeList delete_changes;
   delete_changes.push_back(EntityChange::CreateDelete(specifics.cache_guid()));
   error = service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                                       delete_changes);
 
   EXPECT_FALSE(error.IsSet());
   EXPECT_FALSE(service()->GetDeviceInfo(specifics.cache_guid()));
-  EXPECT_EQ(2, change_count());
+  EXPECT_EQ(3, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesStore) {
   InitializeAndPump();
+  EXPECT_EQ(1, change_count());
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList data_changes;
   PushBackEntityChangeAdd(specifics, &data_changes);
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
-  std::unique_ptr<MetadataChangeList> metadata_changes(
-      service()->CreateMetadataChangeList());
+  std::unique_ptr<MetadataChangeList> metadata_changes =
+      service()->CreateMetadataChangeList();
   metadata_changes->UpdateModelTypeState(state);
 
   const SyncError error =
       service()->ApplySyncChanges(std::move(metadata_changes), data_changes);
   EXPECT_FALSE(error.IsSet());
-  EXPECT_EQ(1, change_count());
+  EXPECT_EQ(2, change_count());
 
   RestartService();
 
   std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
 
   EXPECT_TRUE(processor()->metadata());
   EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesWithLocalGuid) {
-  InitializeAndPumpAndStart();
+  InitializeAndPump();
 
   // The point of this test is to try to apply remote changes that have the same
   // cache guid as the local device. The service should ignore these changes
   // since only it should be performing writes on its data.
   DeviceInfoSpecifics specifics =
       GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
   EntityChangeList change_list;
   PushBackEntityChangeAdd(specifics, &change_list);
 
   // Should have a single change from reconciliation.
@@ skipping 18 matching lines @@
   change_list.clear();
   change_list.push_back(EntityChange::CreateDelete(specifics.cache_guid()));
   EXPECT_FALSE(
       service()
           ->ApplySyncChanges(service()->CreateMetadataChangeList(), change_list)
           .IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplyDeleteNonexistent) {
-  InitializeAndPumpAndStart();
+  InitializeAndPump();
   EXPECT_EQ(1, change_count());
   EntityChangeList delete_changes;
   delete_changes.push_back(EntityChange::CreateDelete("guid"));
   const SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), delete_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeEmpty) {
-  InitializeAndPumpAndStart();
+  InitializeAndPump();
   EXPECT_EQ(1, change_count());
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), EntityDataMap());
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
   EXPECT_EQ(1u, processor()->put_map().size());
   EXPECT_EQ(0u, processor()->delete_set().size());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeWithData) {
   const std::string conflict_guid = "conflict_guid";
-  const DeviceInfoSpecifics unique_local(
-      GenerateTestSpecifics("unique_local_guid"));
-  const DeviceInfoSpecifics conflict_local(
-      GenerateTestSpecifics(conflict_guid));
-  const DeviceInfoSpecifics conflict_remote(
-      GenerateTestSpecifics(conflict_guid));
-  const DeviceInfoSpecifics unique_remote(
-      GenerateTestSpecifics("unique_remote_guid"));
+  const DeviceInfoSpecifics unique_local =
+      GenerateTestSpecifics("unique_local_guid");
+  const DeviceInfoSpecifics conflict_local =
+      GenerateTestSpecifics(conflict_guid);
+  const DeviceInfoSpecifics conflict_remote =
+      GenerateTestSpecifics(conflict_guid);
+  const DeviceInfoSpecifics unique_remote =
+      GenerateTestSpecifics("unique_remote_guid");
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   store()->WriteData(batch.get(), unique_local.cache_guid(),
                      unique_local.SerializeAsString());
   store()->WriteData(batch.get(), conflict_local.cache_guid(),
                      conflict_local.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
-  InitializeAndPumpAndStart();
+  InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   EntityDataMap remote_input;
   remote_input[conflict_remote.cache_guid()] =
       SpecificsToEntity(conflict_remote);
   remote_input[unique_remote.cache_guid()] = SpecificsToEntity(unique_remote);
 
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes(
@@ skipping 20 matching lines @@
   ASSERT_NE(processor()->put_map().end(), it);
   AssertEqual(unique_local, it->second->specifics.device_info());
 
   RestartService();
   ASSERT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeLocalGuid) {
   const DeviceInfo* local_device_info = local_device()->GetLocalDeviceInfo();
-  std::unique_ptr<DeviceInfoSpecifics> specifics(
-      CopyToSpecifics(*local_device_info));
+  std::unique_ptr<DeviceInfoSpecifics> specifics =
+      CopyToSpecifics(*local_device_info);
   specifics->set_last_updated_timestamp(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();
+  InitializeAndPump();
 
   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());
+  DeviceInfoSpecifics specifics1 = GenerateTestSpecifics();
+  DeviceInfoSpecifics specifics2 = GenerateTestSpecifics();
   specifics2.set_last_updated_timestamp(TimeToProtoTime(time1));
 
   EXPECT_EQ(Time(), GetLastUpdateTime(specifics1));
   EXPECT_EQ(time1, GetLastUpdateTime(specifics2));
 }
 
 TEST_F(DeviceInfoServiceTest, CountActiveDevices) {
   InitializeAndPump();
-  EXPECT_EQ(0, service()->CountActiveDevices());
+  EXPECT_EQ(1, 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());
+  EXPECT_EQ(1, service()->CountActiveDevices());
 
   change_list.clear();
   specifics.set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
   PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                               change_list);
-  EXPECT_EQ(0, service()->CountActiveDevices());
+  EXPECT_EQ(1, 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());
+  EXPECT_EQ(2, service()->CountActiveDevices());
 }
 
 }  // namespace
 
 }  // namespace syncer