Sending local data avoid derefing null if the local provider no longer has data.

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 110 matching lines @@
 // useful for other model type unittests it should be moved out to a shared
 // location.
 class RecordingModelTypeChangeProcessor : public 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)));
+    put_multimap_.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,
                         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::multimap<std::string, std::unique_ptr<EntityData>>& put_multimap()
+      const {
+    return put_multimap_;
   }
   const std::set<std::string>& delete_set() const { return delete_set_; }
   const MetadataBatch* metadata() const { return metadata_.get(); }
 
  private:
-  std::map<std::string, std::unique_ptr<EntityData>> put_map_;
+  std::multimap<std::string, std::unique_ptr<EntityData>> put_multimap_;
   std::set<std::string> delete_set_;
   std::unique_ptr<MetadataBatch> metadata_;
 };
 
 }  // namespace
 
 class DeviceInfoServiceTest : public testing::Test,
                               public DeviceInfoTracker::Observer {
  protected:
   DeviceInfoServiceTest()
@@ skipping 108 matching lines @@
     std::swap(store_, service_->store_);
     service_->RemoveObserver(this);
     service_.reset();
   }
 
   void RestartService() {
     PumpAndShutdown();
     InitializeAndPump();
   }
 
+  void ForcePulse() { service()->SendLocalData(); }
+
   Time GetLastUpdateTime(const DeviceInfoSpecifics& specifics) {
     return DeviceInfoService::GetLastUpdateTime(specifics);
   }
 
  private:
   int change_count_;
 
   // In memory model type store needs a MessageLoop.
   base::MessageLoop message_loop_;
 
@@ skipping 101 matching lines @@
   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 devices = service()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
-  EXPECT_EQ(1u, processor()->put_map().size());
+  EXPECT_EQ(1u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalDataAndMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   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());
@@ skipping 146 matching lines @@
       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()
+                                        ->put_multimap()
                                         .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());
@@ skipping 19 matching lines @@
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeEmpty) {
   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());
+  // TODO(skym): Stop sending local twice. The first of the two puts will
+  // probably happen before the processor is tracking metadata yet, and so there
+  // should not be much overhead.
+  EXPECT_EQ(2u, processor()->put_multimap().size());
+  EXPECT_EQ(2u, processor()->put_multimap().count(
+                    local_device()->GetLocalDeviceInfo()->guid()));
   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 =
@@ skipping 31 matching lines @@
   // The remote should beat the local in conflict.
   EXPECT_EQ(4u, service()->GetAllDeviceInfo().size());
   AssertEqual(unique_local,
               *service()->GetDeviceInfo(unique_local.cache_guid()).get());
   AssertEqual(unique_remote,
               *service()->GetDeviceInfo(unique_remote.cache_guid()).get());
   AssertEqual(conflict_remote, *service()->GetDeviceInfo(conflict_guid).get());
 
   // Service should have told the processor about the existance of unique_local.
   EXPECT_TRUE(processor()->delete_set().empty());
-  EXPECT_EQ(2u, processor()->put_map().size());
-  const auto& it = processor()->put_map().find(unique_local.cache_guid());
-  ASSERT_NE(processor()->put_map().end(), it);
+  EXPECT_EQ(3u, processor()->put_multimap().size());
+  EXPECT_EQ(1u, processor()->put_multimap().count(unique_local.cache_guid()));
+  const auto& it = processor()->put_multimap().find(unique_local.cache_guid());
+  ASSERT_NE(processor()->put_multimap().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 =
@@ skipping 10 matching lines @@
 
   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());
+  EXPECT_TRUE(processor()->put_multimap().empty());
 }
 
 TEST_F(DeviceInfoServiceTest, GetLastUpdateTime) {
   Time time1(Time() + TimeDelta::FromDays(1));
 
   DeviceInfoSpecifics specifics1 = GenerateTestSpecifics();
   DeviceInfoSpecifics specifics2 = GenerateTestSpecifics();
   specifics2.set_last_updated_timestamp(TimeToProtoTime(time1));
 
   EXPECT_EQ(Time(), GetLastUpdateTime(specifics1));
@@ skipping 38 matching lines @@
   const MetadataBatch* metadata = processor()->metadata();
   EXPECT_NE(nullptr, metadata);
 
   // Pointer address of metadata should remain constant because the processor
   // should not have been given new metadata.
   local_device()->Initialize(CreateDeviceInfo());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(metadata, processor()->metadata());
 }
 
+TEST_F(DeviceInfoServiceTest, SendLocalData) {
+  InitializeAndPump();
+  EXPECT_EQ(1, service()->CountActiveDevices());
+  EXPECT_EQ(1, change_count());
+  EXPECT_EQ(1u, processor()->put_multimap().size());
+
+  ForcePulse();
+  EXPECT_EQ(1, service()->CountActiveDevices());
+  EXPECT_EQ(2, change_count());
+  EXPECT_EQ(2u, processor()->put_multimap().size());
+
+  local_device()->Clear();
+  ForcePulse();
+  EXPECT_EQ(1, service()->CountActiveDevices());
+  EXPECT_EQ(2, change_count());
+  EXPECT_EQ(2u, processor()->put_multimap().size());
+}
+
 }  // namespace
 
 }  // namespace syncer