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;
-
+  int num_added = 0;
+  int num_modified = 0;
   // 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()) {
@@ skipping 15 matching lines @@
     }
   }
 
   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);

[Bernhard Bauer, 2016/01/05 14:10:54]

Add the number of items before and after association as well?

(And I would actually not do anything clever like inferring the number of items
afterwards from the number of items beforehand plus the number of added items,
because the correctness of that is what we want to verify.)

[Deepak, 2016/01/06 05:26:30]

Done.

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