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

chrome/browser/supervised_user/supervised_user_settings_service.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 <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 175 matching lines @@
 
 SyncMergeResult SupervisedUserSettingsService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
   DCHECK_EQ(SUPERVISED_USER_SETTINGS, type);
   sync_processor_ = std::move(sync_processor);
   error_handler_ = std::move(error_handler);
 
+  std::map<std::string, std::string> seen_keys;
+  int num_before_association = GetAtomicSettings()->size();
+  for (base::DictionaryValue::Iterator it(*GetAtomicSettings()); !it.IsAtEnd();
+       it.Advance()) {
+    std::string json_value;
+    base::JSONWriter::Write(it.value(), &json_value);
+    seen_keys[it.key()] = json_value;
+  }
+  for (base::DictionaryValue::Iterator it(*GetSplitSettings()); !it.IsAtEnd();
+       it.Advance()) {
+    const base::DictionaryValue* dict = nullptr;
+    it.value().GetAsDictionary(&dict);
+    num_before_association += dict->size();
+    for (base::DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd();
+         jt.Advance()) {
+      std::string json_value;
+      base::JSONWriter::Write(jt.value(), &json_value);

[Bernhard Bauer, 2016/01/08 16:04:46]

You serialize the values and then compare them below. What you could do instead
is to store the unserialized base::Value's and compare them to the deserialized
ones from Sync (which you already have), so you don't have to do any additional
serialization.

[Deepak, 2016/01/11 10:38:36]

Done.

+      seen_keys[MakeSplitSettingKey(it.key(), jt.key())] = json_value;
+    }
+  }
+
   // Clear all atomic and split settings, then recreate them from Sync data.
   Clear();
+  int num_added = 0;
+  int num_modified = 0;
   for (const SyncData& sync_data : initial_sync_data) {
     DCHECK_EQ(SUPERVISED_USER_SETTINGS, sync_data.GetDataType());
     const ::sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
         sync_data.GetSpecifics().managed_user_setting();
     scoped_ptr<base::Value> value =
         JSONReader::Read(supervised_user_setting.value());
     std::string name_suffix = supervised_user_setting.name();
+    std::string name_key = name_suffix;
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&name_suffix);
     dict->SetWithoutPathExpansion(name_suffix, value.release());
+
+    if (seen_keys.find(name_key) == seen_keys.end()) {
+      num_added++;
+    } else {
+      for (DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd(); jt.Advance()) {
+        std::string json_value;

[Bernhard Bauer, 2016/01/08 16:04:46]

This is identical to supervised_user_setting.value() anyway. (But see my comment
above for comparing the base::Value's.)

[Deepak, 2016/01/11 10:38:36]

Done.

+        base::JSONWriter::Write(jt.value(), &json_value);
+        if (seen_keys[name_key] != json_value)
+          num_modified++;
+      }
+    }
   }
+
   store_->ReportValueChanged(kAtomicSettings,
                              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   store_->ReportValueChanged(kSplitSettings,
                              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   InformSubscribers();
 
   // Upload all the queued up items (either with an ADD or an UPDATE action,
   // depending on whether they already exist) and move them to split settings.

[Bernhard Bauer, 2016/01/08 16:04:46]

As you mention in the CL message, you ignore queued items... but why? 😃

[Deepak, 2016/01/11 10:38:36]

I thought that we should consider that things that are processed via
|SyncDataList| passed in the function.
I have done changes now to accommodate the queued items also.

[Bernhard Bauer, 2016/01/18 17:56:56]

That is the data from Sync. The number of items before and after association is
coming from our local data though, and that includes queued items.  (Which you
still don't include in the number before.)

   SyncChangeList change_list;
   base::DictionaryValue* queued_items = GetQueuedItems();
   for (base::DictionaryValue::Iterator it(*queued_items); !it.IsAtEnd();
        it.Advance()) {
     std::string key_suffix = it.key();
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&key_suffix);
     SyncData data = CreateSyncDataForSetting(it.key(), it.value());
     SyncChange::SyncChangeType change_type =
         dict->HasKey(key_suffix) ? SyncChange::ACTION_UPDATE
                                  : SyncChange::ACTION_ADD;
     change_list.push_back(SyncChange(FROM_HERE, change_type, data));
     dict->SetWithoutPathExpansion(key_suffix, it.value().DeepCopy());
   }
   queued_items->Clear();
 
   SyncMergeResult result(SUPERVISED_USER_SETTINGS);
   // Process all the accumulated changes from the queued items.
   if (change_list.size() > 0) {
     store_->ReportValueChanged(kQueuedItems,
                                WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     result.set_error(
         sync_processor_->ProcessSyncChanges(FROM_HERE, change_list));
   }
 
-  // TODO(bauerb): Statistics?
+  result.set_num_items_added(num_added);
+  result.set_num_items_modified(num_modified);
+  result.set_num_items_deleted(num_before_association - num_modified);
+  result.set_num_items_before_association(num_before_association);
+  result.set_num_items_after_association(GetAllSyncData(type).size());

[Bernhard Bauer, 2016/01/08 16:04:46]

This is clever, but I'm a bit wary that this does more work than necessary, as
it creates all theses Sync items that we don't really use (we just count them).
It might be easier to just count them directly.

[Deepak, 2016/01/11 10:38:36]

Done.

   return result;
 }
 
 void SupervisedUserSettingsService::StopSyncing(ModelType type) {
   DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 SyncDataList SupervisedUserSettingsService::GetAllSyncData(
@@ skipping 159 matching lines @@
   return settings;
 }
 
 void SupervisedUserSettingsService::InformSubscribers() {
   if (!IsReady())
     return;
 
   scoped_ptr<base::DictionaryValue> settings = GetSettings();
   callback_list_.Notify(settings.get());
 }