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 180 matching lines @@
 syncer::SyncMergeResult
 SupervisedUserSharedSettingsService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     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);
 
+  int num_added = 0;
+  int num_modified = 0;
+  int num_before_association = 0;
+  std::map<std::string, std::set<std::string> > pref_seen_keys;
+  const DictionaryValue* pref_dict =
+      prefs_->GetDictionary(prefs::kSupervisedUserSharedSettings);
+  for (DictionaryValue::Iterator it(*pref_dict); !it.IsAtEnd(); it.Advance()) {
+    const DictionaryValue* dict = NULL;

[Bernhard Bauer, 2016/01/07 10:04:29]

Use nullptr instead of NULL.

[Deepak, 2016/01/07 10:40:07]

Done.

+    bool success = it.value().GetAsDictionary(&dict);
+    DCHECK(success);
+    num_before_association += dict->size();
+    for (DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd(); jt.Advance())
+      pref_seen_keys[it.key()].insert(jt.key());
+  }
+
   // 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;

[Bernhard Bauer, 2016/01/07 10:04:29]

Rename this to |sync_seen_keys| to distinguish it from |pref_seen_keys|?

[Deepak, 2016/01/07 10:40:07]

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 (pref_seen_keys.find(su_id) == pref_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;

[Bernhard Bauer, 2016/01/07 10:04:29]

Could you update this to nullptr as well? Thanks!

[Deepak, 2016/01/07 10:40:07]

Done.

     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_before_association(num_before_association);
+  result.set_num_items_after_association(num_before_association + num_added);

[Bernhard Bauer, 2016/01/07 10:04:29]

Let's not do this, please. If we have a bug in the code above, manually counting
the number of items afterwards might expose it, whereas if we calculate it like
this, we don't get anything from verifying that num_after_association ==
num_before_association + num_added.

We already have a loop over the preferences after association (starting at line
255), so we can do the count there.

[Deepak, 2016/01/07 10:40:07]

I got your point. Thanks

   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;
 }