[NOT FOR REVIEW] only for running build bots only Testing

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 60 matching lines @@
   PersistentPrefStore* store = new JsonPrefStore(
       path, sequenced_task_runner, scoped_ptr<PrefFilter>());
   Init(store);
   if (load_synchronously) {
     store_->ReadPrefs();
     // TODO(bauerb): Temporary CHECK while investigating
     // https://crbug.com/425785. Remove (or change to DCHECK) once the bug
     // is fixed.
     CHECK(store_->IsInitializationComplete());
   } else {
-    store_->ReadPrefsAsync(NULL);
+    store_->ReadPrefsAsync(nullptr);
   }
 }
 
 void SupervisedUserSettingsService::Init(
     scoped_refptr<PersistentPrefStore> store) {
   DCHECK(!store_.get());
   store_ = store;
   store_->AddObserver(this);
 }
 
@@ skipping 35 matching lines @@
     const std::string& prefix,
     const std::string& key) {
   return prefix + kSplitSettingKeySeparator + key;
 }
 
 void SupervisedUserSettingsService::UploadItem(const std::string& key,
                                                scoped_ptr<base::Value> value) {
   DCHECK(!SettingShouldApplyToPrefs(key));
 
   std::string key_suffix = key;
-  base::DictionaryValue* dict = NULL;
+  base::DictionaryValue* dict = nullptr;
   if (sync_processor_) {
     content::RecordAction(UserMetricsAction("ManagedUsers_UploadItem_Syncing"));
     dict = GetDictionaryAndSplitKey(&key_suffix);
     DCHECK(GetQueuedItems()->empty());
     SyncChangeList change_list;
     SyncData data = CreateSyncDataForSetting(key, *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));
     SyncError error =
         sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
     DCHECK(!error.IsSet()) << error.ToString();
   } else {
     // Queue the item up to be uploaded when we start syncing
     // (in MergeDataAndStartSyncing()).
     content::RecordAction(UserMetricsAction("ManagedUsers_UploadItem_Queued"));
     dict = GetQueuedItems();
   }
   dict->SetWithoutPathExpansion(key_suffix, value.release());
 }
 
 void SupervisedUserSettingsService::SetLocalSetting(
     const std::string& key,
     scoped_ptr<base::Value> value) {
   if (value)
     local_settings_->SetWithoutPathExpansion(key, value.release());
   else
-    local_settings_->RemoveWithoutPathExpansion(key, NULL);
+    local_settings_->RemoveWithoutPathExpansion(key, nullptr);
 
   InformSubscribers();
 }
 
 // static
 SyncData SupervisedUserSettingsService::CreateSyncDataForSetting(
     const std::string& name,
     const base::Value& value) {
   std::string json_value;
   base::JSONWriter::Write(value, &json_value);
   ::sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user_setting()->set_name(name);
   specifics.mutable_managed_user_setting()->set_value(json_value);
   return SyncData::CreateLocalData(name, name, specifics);
 }
 
 void SupervisedUserSettingsService::Shutdown() {
   store_->RemoveObserver(this);
 }
 
 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, const base::Value*> seen_keys;
+  int num_before_association = GetAtomicSettings()->size();
+  for (base::DictionaryValue::Iterator it(*GetAtomicSettings()); !it.IsAtEnd();
+       it.Advance()) {
+    seen_keys[it.key()] = &it.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()) {
+      seen_keys[MakeSplitSettingKey(it.key(), jt.key())] = &jt.value();
+    }
+  }
+
+  LOG(ERROR) << "Deepak num_before_association:" << num_before_association;
+  for (std::map<std::string, const base::Value*>::iterator it =
+           seen_keys.begin();
+       it != seen_keys.end(); it++) {
+    LOG(ERROR) << "Deepak key:" << it->first;
+    std::string json_value;
+    base::JSONWriter::Write(*(it->second), &json_value);
+    LOG(ERROR) << "Deepak " << 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;
+    LOG(ERROR) << "Deepak name_suffix:" << name_suffix;
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&name_suffix);
     dict->SetWithoutPathExpansion(name_suffix, value.release());
+    LOG(ERROR) << "Deepak " << supervised_user_setting.value();
+    std::map<std::string, const base::Value*>::iterator it =
+        seen_keys.find(name_key);
+    if (it == seen_keys.end()) {
+      LOG(ERROR) << "Deepak Item Added:" << name_suffix;
+      num_added++;
+    } else {
+      LOG(ERROR) << "Deepak for checking item modification";
+      if (it->second != value.get()) {
+        LOG(ERROR) << "Deepak modifying item";
+        num_modified++;
+      }
+      /*      for (DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd();
+         jt.Advance()) {
+              std::string json_value;
+              base::JSONWriter::Write(jt.value(), &json_value);
+              LOG(ERROR) << "Deepak " << json_value;
+              if (seen_keys[name_key] != &jt.value()) {
+                LOG(ERROR) << "Deepak Item modified:" << name_key;
+                num_modified++;
+              }
+            }
+      */
+    }
   }
+
+  LOG(ERROR) << "Deepak added:" << num_added << "modified:" << 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.
   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();
+    std::string name_key = key_suffix;
     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());
+    if (seen_keys.find(name_key) == seen_keys.end()) {
+      LOG(ERROR) << "Deepak adding";
+      num_added++;
+    } else {
+      for (DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd(); jt.Advance()) {
+        if (seen_keys[name_key] != &jt.value()) {
+          LOG(ERROR) << "Deepak modifying";
+          num_modified++;
+        }
+      }
+    }
   }
   queued_items->Clear();
+  LOG(ERROR) << "Deepak added:" << num_added << "modified:" << num_modified;
 
   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?
+  // Calculating number of items after association.
+  int num_after_association = GetAtomicSettings()->size();
+  for (base::DictionaryValue::Iterator it(*GetSplitSettings()); !it.IsAtEnd();
+       it.Advance()) {
+    const base::DictionaryValue* dict = nullptr;
+    it.value().GetAsDictionary(&dict);
+    num_after_association += dict->size();
+  }
+
+  LOG(ERROR) << "Deepak added:" << num_added;
+  LOG(ERROR) << "Deepak modified:" << num_modified;
+  LOG(ERROR) << "Deepak deleted:" << num_before_association - num_modified;
+  LOG(ERROR) << "Deepak beforeAssociation:" << num_before_association;
+  LOG(ERROR) << "Deepak afterAssociation:" << num_after_association;
+
+  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(num_after_association);
   return result;
 }
 
 void SupervisedUserSettingsService::StopSyncing(ModelType type) {
   DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 SyncDataList SupervisedUserSettingsService::GetAllSyncData(
     ModelType type) const {
   DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   SyncDataList data;
   for (base::DictionaryValue::Iterator it(*GetAtomicSettings()); !it.IsAtEnd();
        it.Advance()) {
     data.push_back(CreateSyncDataForSetting(it.key(), it.value()));
   }
   for (base::DictionaryValue::Iterator it(*GetSplitSettings()); !it.IsAtEnd();
        it.Advance()) {
-    const base::DictionaryValue* dict = NULL;
+    const base::DictionaryValue* dict = nullptr;
     it.value().GetAsDictionary(&dict);
     for (base::DictionaryValue::Iterator jt(*dict);
          !jt.IsAtEnd(); jt.Advance()) {
       data.push_back(CreateSyncDataForSetting(
           MakeSplitSettingKey(it.key(), jt.key()), jt.value()));
     }
   }
   DCHECK_EQ(0u, GetQueuedItems()->size());
   return data;
 }
@@ skipping 20 matching lines @@
         } else {
           DLOG_IF(WARNING, change_type == SyncChange::ACTION_UPDATE)
               << "Value for key " << key << " doesn't exist yet";
         }
         dict->SetWithoutPathExpansion(key, value.release());
         break;
       }
       case SyncChange::ACTION_DELETE: {
         DLOG_IF(WARNING, !dict->HasKey(key)) << "Trying to delete nonexistent "
                                              << "key " << key;
-        dict->RemoveWithoutPathExpansion(key, NULL);
+        dict->RemoveWithoutPathExpansion(key, nullptr);
         break;
       }
       case SyncChange::ACTION_INVALID: {
         NOTREACHED();
         break;
       }
     }
   }
   store_->ReportValueChanged(kAtomicSettings,
                              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
@@ skipping 18 matching lines @@
   }
 
   // TODO(bauerb): Temporary CHECK while investigating https://crbug.com/425785.
   // Remove (or change back to DCHECK) once the bug is fixed.
   CHECK(IsReady());
   InformSubscribers();
 }
 
 base::DictionaryValue* SupervisedUserSettingsService::GetOrCreateDictionary(
     const std::string& key) const {
-  base::Value* value = NULL;
-  base::DictionaryValue* dict = NULL;
+  base::Value* value = nullptr;
+  base::DictionaryValue* dict = nullptr;
   if (store_->GetMutableValue(key, &value)) {
     bool success = value->GetAsDictionary(&dict);
     DCHECK(success);
   } else {
     dict = new base::DictionaryValue;
     store_->SetValue(key, make_scoped_ptr(dict),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 
   return dict;
@@ skipping 13 matching lines @@
 }
 
 base::DictionaryValue* SupervisedUserSettingsService::GetDictionaryAndSplitKey(
     std::string* key) const {
   size_t pos = key->find_first_of(kSplitSettingKeySeparator);
   if (pos == std::string::npos)
     return GetAtomicSettings();
 
   base::DictionaryValue* split_settings = GetSplitSettings();
   std::string prefix = key->substr(0, pos);
-  base::DictionaryValue* dict = NULL;
+  base::DictionaryValue* dict = nullptr;
   if (!split_settings->GetDictionary(prefix, &dict)) {
     dict = new base::DictionaryValue;
     DCHECK(!split_settings->HasKey(prefix));
     split_settings->Set(prefix, dict);
   }
   key->erase(0, pos + 1);
   return dict;
 }
 
 scoped_ptr<base::DictionaryValue> SupervisedUserSettingsService::GetSettings() {
@@ skipping 24 matching lines @@
   return settings;
 }
 
 void SupervisedUserSettingsService::InformSubscribers() {
   if (!IsReady())
     return;
 
   scoped_ptr<base::DictionaryValue> settings = GetSettings();
   callback_list_.Notify(settings.get());
 }