Remove raw base::DictionaryValue::SetWithoutPathExpansion in //chrome

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>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/sync/model/sync_change.h"
 #include "components/sync/model/sync_data.h"
 #include "components/sync/model/sync_error.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/sync_merge_result.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 const char kAcknowledged[] = "acknowledged";
 const char kValue[] = "value";
 
 DictionaryValue* FindOrCreateDictionary(DictionaryValue* parent,
                                         const std::string& key) {
   DictionaryValue* dict = nullptr;
   if (!parent->GetDictionaryWithoutPathExpansion(key, &dict)) {
-    dict = new DictionaryValue;
-    parent->SetWithoutPathExpansion(key, dict);
+    dict = parent->SetDictionaryWithoutPathExpansion(
+        key, base::MakeUnique<base::DictionaryValue>());
   }
   return dict;
 }
 
 class ScopedSupervisedUserSharedSettingsUpdate {
  public:
   ScopedSupervisedUserSharedSettingsUpdate(PrefService* prefs,
                                            const std::string& su_id)
       : update_(prefs, prefs::kSupervisedUserSharedSettings), su_id_(su_id) {
     DCHECK(!su_id.empty());
@@ skipping 44 matching lines @@
     const std::string& su_id,
     const std::string& key,
     const Value& value,
     bool acknowledged) {
   ScopedSupervisedUserSharedSettingsUpdate update(prefs_, su_id);
   DictionaryValue* update_dict = update.Get();
 
   DictionaryValue* dict = nullptr;
   bool has_key = update_dict->GetDictionaryWithoutPathExpansion(key, &dict);
   if (!has_key) {
-    dict = new DictionaryValue;
-    update_dict->SetWithoutPathExpansion(key, dict);
+    dict = update_dict->SetDictionaryWithoutPathExpansion(
+        key, base::MakeUnique<base::DictionaryValue>());
   }
-  dict->SetWithoutPathExpansion(kValue, value.DeepCopy());
+  dict->SetWithoutPathExpansion(kValue, base::MakeUnique<base::Value>(value));
   dict->SetBooleanWithoutPathExpansion(kAcknowledged, acknowledged);
 
   if (!sync_processor_)
     return;
 
   SyncData data = CreateSyncDataForSetting(su_id, key, value, acknowledged);
   SyncChange::SyncChangeType change_type =
       has_key ? SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD;
   SyncChangeList changes;
   changes.push_back(SyncChange(FROM_HERE, change_type, data));
@@ skipping 96 matching lines @@
     DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, sync_data.GetDataType());
     const ::sync_pb::ManagedUserSharedSettingSpecifics&
         supervised_user_shared_setting =
             sync_data.GetSpecifics().managed_user_shared_setting();
     std::unique_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());
+    dict->SetWithoutPathExpansion(kValue, std::move(value));
 
     // 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++;
@@ skipping 90 matching lines @@
         // flag set.
         DCHECK(supervised_user_shared_setting.acknowledged());
 
         if (has_key) {
           // If the supervised user already exists, it should be an update
           // action.
           DCHECK_EQ(SyncChange::ACTION_UPDATE, sync_change.change_type());
         } else {
           // Otherwise, it should be an add action.
           DCHECK_EQ(SyncChange::ACTION_ADD, sync_change.change_type());
-          dict = new DictionaryValue;
-          update_dict->SetWithoutPathExpansion(key, dict);
+          dict = update_dict->SetDictionaryWithoutPathExpansion(
+              key, base::MakeUnique<base::DictionaryValue>());
         }
         std::unique_ptr<Value> value =
             base::JSONReader::Read(supervised_user_shared_setting.value());
-        dict->SetWithoutPathExpansion(kValue, value.release());
+        dict->SetWithoutPathExpansion(kValue, std::move(value));
         dict->SetBooleanWithoutPathExpansion(
             kAcknowledged, supervised_user_shared_setting.acknowledged());
         break;
       }
       case SyncChange::ACTION_DELETE: {
         if (has_key)
           update_dict->RemoveWithoutPathExpansion(key, nullptr);
         else
           NOTREACHED() << "Trying to delete nonexistent key " << key;
         break;
       }
       case SyncChange::ACTION_INVALID: {
         NOTREACHED();
         break;
       }
     }
     callbacks_.Notify(su_id, key);
   }
 
   SyncError error;
   return error;
 }