[Part-2]Add Statistics for SupervisedUserSettingService during merging and syncing data.

chrome/browser/supervised_user/supervised_user_settings_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 "chrome/browser/supervised_user/supervised_user_settings_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 52 matching lines @@
  protected:
   SupervisedUserSettingsServiceTest() : settings_service_(nullptr) {}
   ~SupervisedUserSettingsServiceTest() override {}
 
   scoped_ptr<syncer::SyncChangeProcessor> CreateSyncProcessor() {
     sync_processor_.reset(new syncer::FakeSyncChangeProcessor);
     return scoped_ptr<syncer::SyncChangeProcessor>(
         new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   }
 
-  void StartSyncing(const syncer::SyncDataList& initial_sync_data) {
+  syncer::SyncMergeResult StartSyncing(
+      const syncer::SyncDataList& initial_sync_data) {
     scoped_ptr<syncer::SyncErrorFactory> error_handler(
         new MockSyncErrorFactory(syncer::SUPERVISED_USER_SETTINGS));
     syncer::SyncMergeResult result = settings_service_.MergeDataAndStartSyncing(
         syncer::SUPERVISED_USER_SETTINGS, initial_sync_data,
         CreateSyncProcessor(), std::move(error_handler));
     EXPECT_FALSE(result.error().IsSet());
+    return result;
   }
 
   void UploadSplitItem(const std::string& key, const std::string& value) {
     split_items_.SetStringWithoutPathExpansion(key, value);
     settings_service_.UploadItem(
-        SupervisedUserSettingsService::MakeSplitSettingKey(kSplitItemName,
-                                                           key),
+        SupervisedUserSettingsService::MakeSplitSettingKey(kSplitItemName, key),
         scoped_ptr<base::Value>(new base::StringValue(value)));
   }
 
   void UploadAtomicItem(const std::string& value) {
     atomic_setting_value_.reset(new base::StringValue(value));
     settings_service_.UploadItem(
         kAtomicItemName,
         scoped_ptr<base::Value>(new base::StringValue(value)));
   }
 
   void VerifySyncDataItem(syncer::SyncData sync_data) {
     const sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
         sync_data.GetSpecifics().managed_user_setting();
-    base::Value* expected_value = NULL;
+    base::Value* expected_value = nullptr;
     if (supervised_user_setting.name() == kAtomicItemName) {
       expected_value = atomic_setting_value_.get();
     } else {
       EXPECT_TRUE(base::StartsWith(supervised_user_setting.name(),
                                    std::string(kSplitItemName) + ':',
                                    base::CompareCase::SENSITIVE));
       std::string key =
           supervised_user_setting.name().substr(strlen(kSplitItemName) + 1);
       EXPECT_TRUE(split_items_.GetWithoutPathExpansion(key, &expected_value));
     }
@@ skipping 32 matching lines @@
   scoped_ptr<base::DictionaryValue> settings_;
   scoped_ptr<base::CallbackList<void(
       const base::DictionaryValue*)>::Subscription> user_settings_subscription_;
 
   scoped_ptr<syncer::FakeSyncChangeProcessor> sync_processor_;
 };
 
 TEST_F(SupervisedUserSettingsServiceTest, ProcessAtomicSetting) {
   StartSyncing(syncer::SyncDataList());
   ASSERT_TRUE(settings_);
-  const base::Value* value = NULL;
+  const base::Value* value = nullptr;
   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 
   settings_.reset();
   syncer::SyncData data =
       SupervisedUserSettingsService::CreateSyncDataForSetting(
           kSettingsName, base::StringValue(kSettingsValue));
   syncer::SyncChangeList change_list;
   change_list.push_back(
       syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_ADD, data));
   syncer::SyncError error =
       settings_service_.ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet()) << error.ToString();
   ASSERT_TRUE(settings_);
   ASSERT_TRUE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
   std::string string_value;
   EXPECT_TRUE(value->GetAsString(&string_value));
   EXPECT_EQ(kSettingsValue, string_value);
 }
 
 TEST_F(SupervisedUserSettingsServiceTest, ProcessSplitSetting) {
   StartSyncing(syncer::SyncDataList());
   ASSERT_TRUE(settings_);
-  const base::Value* value = NULL;
+  const base::Value* value = nullptr;
   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 
   base::DictionaryValue dict;
   dict.SetString("foo", "bar");
   dict.SetBoolean("awesomesauce", true);
   dict.SetInteger("eaudecologne", 4711);
 
   settings_.reset();
   syncer::SyncChangeList change_list;
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     syncer::SyncData data =
         SupervisedUserSettingsService::CreateSyncDataForSetting(
             SupervisedUserSettingsService::MakeSplitSettingKey(kSettingsName,
                                                                it.key()),
             it.value());
     change_list.push_back(
         syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_ADD, data));
   }
   syncer::SyncError error =
       settings_service_.ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet()) << error.ToString();
   ASSERT_TRUE(settings_);
   ASSERT_TRUE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
-  const base::DictionaryValue* dict_value = NULL;
+  const base::DictionaryValue* dict_value = nullptr;
   ASSERT_TRUE(value->GetAsDictionary(&dict_value));
   EXPECT_TRUE(dict_value->Equals(&dict));
 }
 
+TEST_F(SupervisedUserSettingsServiceTest, Merge) {
+  syncer::SyncMergeResult result = StartSyncing(syncer::SyncDataList());
+  EXPECT_EQ(0, result.num_items_added());
+  EXPECT_EQ(0, result.num_items_deleted());
+  EXPECT_EQ(0, result.num_items_modified());
+  EXPECT_EQ(0, result.num_items_before_association());
+  EXPECT_EQ(0, result.num_items_after_association());
+
+  ASSERT_TRUE(settings_);
+  const base::Value* value = nullptr;
+  EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
+
+  base::DictionaryValue dict;

[Bernhard Bauer, 2016/01/28 13:56:33]

Could you move this to right after line 227, so it's clear that the comment
refers to this dictionary?

Also, if you put the code from here until line 240 into a scope, and then a
second scope from line 246 on, you don't need to clear |sync_data| and |dict|,
you just declare them again in the second scope. That way, you can be sure that
the local variables don't accidentally propagate from the first scope to the
second.

[Deepak, 2016/01/29 07:00:29]

Done.

+  dict.SetString("foo", "bar");
+  dict.SetInteger("eaudecologne", 4711);
+
+  settings_.reset();
+  syncer::SyncDataList sync_data;
+  // Adding 1 Atomic entry.
+  sync_data.push_back(SupervisedUserSettingsService::CreateSyncDataForSetting(
+      kSettingsName, base::StringValue(kSettingsValue)));
+  // Adding 2 SplitSettings from dictionary.
+  for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
+    sync_data.push_back(SupervisedUserSettingsService::CreateSyncDataForSetting(
+        SupervisedUserSettingsService::MakeSplitSettingKey(kSplitItemName,
+                                                           it.key()),
+        it.value()));
+  }
+
+  result = StartSyncing(sync_data);
+  EXPECT_EQ(3, result.num_items_added());
+  EXPECT_EQ(0, result.num_items_deleted());
+  EXPECT_EQ(0, result.num_items_modified());
+  EXPECT_EQ(0, result.num_items_before_association());
+  EXPECT_EQ(3, result.num_items_after_association());
+
+  settings_service_.StopSyncing(syncer::SUPERVISED_USER_SETTINGS);
+  sync_data.clear();
+
+  // Adding 1 atomic Item in the queue.
+  UploadAtomicItem("hurdle");
+  // Adding 2 split Item in the queue.
+  UploadSplitItem("burp", "baz");
+  UploadSplitItem("item", "second");
+
+  dict.Clear();
+  dict.SetString("foo", "burp");
+  dict.SetString("item", "first");
+  // Adding 2 SplitSettings from dictionary.
+  for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
+    sync_data.push_back(SupervisedUserSettingsService::CreateSyncDataForSetting(
+        SupervisedUserSettingsService::MakeSplitSettingKey(kSplitItemName,
+                                                           it.key()),
+        it.value()));
+  }
+
+  result = StartSyncing(sync_data);
+  EXPECT_EQ(0, result.num_items_added());
+  EXPECT_EQ(2, result.num_items_deleted());
+  EXPECT_EQ(2, result.num_items_modified());
+  EXPECT_EQ(3, result.num_items_before_association());
+  EXPECT_EQ(4, result.num_items_after_association());
+}
+
 TEST_F(SupervisedUserSettingsServiceTest, SetLocalSetting) {
-  const base::Value* value = NULL;
+  const base::Value* value = nullptr;
   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 
   settings_.reset();
   settings_service_.SetLocalSetting(
       kSettingsName,
       scoped_ptr<base::Value>(new base::StringValue(kSettingsValue)));
   ASSERT_TRUE(settings_);
   ASSERT_TRUE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
   std::string string_value;
   EXPECT_TRUE(value->GetAsString(&string_value));
@@ skipping 60 matching lines @@
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   VerifySyncDataItem(change.sync_data());
 
   sync_data = settings_service_.GetAllSyncData(
       syncer::SUPERVISED_USER_SETTINGS);
   EXPECT_EQ(4u, sync_data.size());
   for (const syncer::SyncData& sync_data_item : sync_data)
     VerifySyncDataItem(sync_data_item);
 
   // The uploaded items should not show up as settings.
-  const base::Value* value = NULL;
+  const base::Value* value = nullptr;
   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kAtomicItemName, &value));
   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSplitItemName, &value));
 
   // Restarting sync should not create any new changes.
   settings_service_.StopSyncing(syncer::SUPERVISED_USER_SETTINGS);
   StartSyncing(sync_data);
   ASSERT_EQ(0u, sync_processor_->changes().size());
 }