Add Statistics for SupervisedUserSettingService during merging and syncing data.

chrome/browser/supervised_user/legacy/supervised_user_shared_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/legacy/supervised_user_shared_settings_service.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 183 matching lines @@
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, type);
   sync_processor_ = std::move(sync_processor);
   error_handler_ = std::move(error_handler);
 
   // We keep a map from MU ID to the set of keys that we have seen in the
   // initial sync data.
   std::map<std::string, std::set<std::string> > seen_keys;
+  SyncMergeResult result(SUPERVISED_USER_SHARED_SETTINGS);
+  int num_added = 0;
+  int num_modified = 0;
+
+  DictionaryPrefUpdate update_prefs(prefs_,

[Bernhard Bauer, 2016/01/06 16:41:50]

If you don't need to modify anything, you can just use prefs_->GetDictionary().

[Deepak, 2016/01/07 09:52:31]

Done.

+                                    prefs::kSupervisedUserSharedSettings);
+  base::DictionaryValue* pref_dict = update_prefs.Get();
+  result.set_num_items_before_association(pref_dict->size());

[Bernhard Bauer, 2016/01/06 16:41:50]

Can you put this into a local variable like |num_added| and |num_modified|, then
construct the result below like you did previously?

Also, isn't this a two-level dictionary, so we'd need to iterate over it and add
the sizes of its child dictionaries?

[Deepak, 2016/01/07 09:52:31]

Done.

 
   // Iterate over all initial sync data, and update it locally. This means that
   // the value from the server always wins over a local value.
   for (const SyncData& sync_data : initial_sync_data) {
     DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, sync_data.GetDataType());
     const ::sync_pb::ManagedUserSharedSettingSpecifics&
         supervised_user_shared_setting =
             sync_data.GetSpecifics().managed_user_shared_setting();
     scoped_ptr<Value> value =
         base::JSONReader::Read(supervised_user_shared_setting.value());
     const std::string& su_id = supervised_user_shared_setting.mu_id();
     ScopedSupervisedUserSharedSettingsUpdate update(prefs_, su_id);
     const std::string& key = supervised_user_shared_setting.key();
     DictionaryValue* dict = FindOrCreateDictionary(update.Get(), key);
     dict->SetWithoutPathExpansion(kValue, value.release());
 
     // Every setting we get from the server should have the acknowledged flag
     // set.
     DCHECK(supervised_user_shared_setting.acknowledged());
     dict->SetBooleanWithoutPathExpansion(
         kAcknowledged, supervised_user_shared_setting.acknowledged());
     callbacks_.Notify(su_id, key);
 
+    if (seen_keys.find(su_id) == seen_keys.end())
+      num_added++;
+    else
+      num_modified++;
     seen_keys[su_id].insert(key);
   }
 
   // Iterate over all settings that we have locally, which includes settings
   // that were just synced down. We filter those out using |seen_keys|.
   SyncChangeList change_list;
   const DictionaryValue* all_settings =
       prefs_->GetDictionary(prefs::kSupervisedUserSharedSettings);
   for (DictionaryValue::Iterator it(*all_settings); !it.IsAtEnd();
        it.Advance()) {
     const DictionaryValue* dict = NULL;
     bool success = it.value().GetAsDictionary(&dict);
     DCHECK(success);
 
     const std::set<std::string>& seen = seen_keys[it.key()];
     for (DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd(); jt.Advance()) {
       // We only need to upload settings that we haven't seen in the initial
       // sync data (which means they were added locally).
       if (seen.count(jt.key()) > 0)
         continue;
 
       SyncData data = CreateSyncDataForValue(it.key(), jt.key(), jt.value());
       DCHECK(data.IsValid());
       change_list.push_back(
           SyncChange(FROM_HERE, SyncChange::ACTION_ADD, data));
     }
   }
 
-  SyncMergeResult result(SUPERVISED_USER_SHARED_SETTINGS);
   // Process all the accumulated changes.
   if (change_list.size() > 0) {
     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(0);

[Bernhard Bauer, 2016/01/06 16:41:50]

It's fine not to set this value (0 is the default anyway), I just wanted you to
verify it.

[Deepak, 2016/01/07 09:52:31]

Done.

+  result.set_num_items_after_association(pref_dict->size());
   return result;
 }
 
 void SupervisedUserSharedSettingsService::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, type);
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 syncer::SyncDataList SupervisedUserSharedSettingsService::GetAllSyncData(
@@ skipping 64 matching lines @@
         NOTREACHED();
         break;
       }
     }
     callbacks_.Notify(su_id, key);
   }
 
   SyncError error;
   return error;
 }