Remove raw base::DictionaryValue::Set in //extensions

extensions/browser/extension_prefs.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 "extensions/browser/extension_prefs.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <iterator>
@@ skipping 596 matching lines @@
 // ]
 template <typename T>
 static std::unique_ptr<base::ListValue> CreatePermissionList(
     const T& permissions) {
   auto values = base::MakeUnique<base::ListValue>();
   for (typename T::const_iterator i = permissions.begin();
       i != permissions.end(); ++i) {
     std::unique_ptr<base::Value> detail(i->ToValue());
     if (detail) {
       auto tmp(base::MakeUnique<base::DictionaryValue>());
-      tmp->Set(i->name(), detail.release());
+      tmp->Set(i->name(), std::move(detail));
       values->Append(std::move(tmp));
     } else {
       values->AppendString(i->name());
     }
   }
   return values;
 }
 
 void ExtensionPrefs::SetExtensionPrefPermissionSet(
     const std::string& extension_id,
@@ skipping 716 matching lines @@
   pending_install_dict->Remove(kDelayedInstallReason, NULL);
 
   const base::Time install_time = time_provider_->GetCurrentTime();
   pending_install_dict->SetString(
       kPrefInstallTime, base::Int64ToString(install_time.ToInternalValue()));
 
   // Commit the delayed install data.
   for (base::DictionaryValue::Iterator it(
            *pending_install_dict->AsConstDictionary());
        !it.IsAtEnd(); it.Advance()) {
-    extension_dict->Set(it.key(), it.value().CreateDeepCopy());
+    extension_dict->Set(it.key(), base::MakeUnique<base::Value>(it.value()));
   }
   FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                            suggested_page_ordinal, extension_dict.get());
   return true;
 }
 
 std::unique_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs =
       GetExtensionPref(extension_id);
@@ skipping 469 matching lines @@
 
   base::FilePath::StringType path = MakePathRelative(install_directory_,
                                                      extension->path());
   extension_dict->SetString(kPrefPath, path);
   if (!install_parameter.empty()) {
     extension_dict->SetString(kPrefInstallParam, install_parameter);
   }
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
-    extension_dict->Set(kPrefManifest,
-                        extension->manifest()->value()->CreateDeepCopy());
+    extension_dict->Set(kPrefManifest, base::MakeUnique<base::Value>(
+                                           *extension->manifest()->value()));
   }
 
   // Only writes kPrefDoNotSync when it is not the default.
   if (install_flags & kInstallFlagDoNotSync)
     extension_dict->SetBoolean(kPrefDoNotSync, true);
   else
     extension_dict->Remove(kPrefDoNotSync, NULL);
 }
 
 void ExtensionPrefs::InitExtensionControlledPrefs(
@@ skipping 87 matching lines @@
   bool is_incognito_enabled = IsIncognitoEnabled(extension_id);
 
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   for (auto& observer : observer_list_)
     observer.OnExtensionRegistered(extension_id, install_time, is_enabled);
 }
 
 }  // namespace extensions