Remove SetWithoutPathExpansion

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 181 matching lines @@
     extension_id_(extension_id) {}
 
   ~ScopedExtensionPrefUpdate() override {}
 
   // DictionaryPrefUpdate overrides:
   base::DictionaryValue* Get() override {
     base::DictionaryValue* dict = DictionaryPrefUpdate::Get();
     base::DictionaryValue* extension = NULL;
     if (!dict->GetDictionary(extension_id_, &extension)) {
       // Extension pref does not exist, create it.
-      extension = new base::DictionaryValue();
-      dict->SetWithoutPathExpansion(extension_id_, base::WrapUnique(extension));
+      dict->SetWithoutPathExpansion(extension_id_,
+                                    base::MakeUnique<base::DictionaryValue>());
+      dict->GetDictionaryWithoutPathExpansion(extension_id_, &extension);
     }
     return extension;
   }
 
  private:
   const std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionPrefUpdate);
 };
 
@@ skipping 77 matching lines @@
   return key_value->GetType() == type_enum_value ?
       static_cast<T*>(key_value) :
       NULL;
 }
 
 template <typename T, base::Value::Type type_enum_value>
 T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Create() {
   base::DictionaryValue* dict = update_.Get();
   base::DictionaryValue* extension = nullptr;
   base::Value* key_value = nullptr;
-  T* value_as_t = nullptr;
   if (!dict->GetDictionary(extension_id_, &extension)) {
-    extension = new base::DictionaryValue;
-    dict->SetWithoutPathExpansion(extension_id_, base::WrapUnique(extension));
+    dict->SetWithoutPathExpansion(extension_id_,
+                                  base::MakeUnique<base::DictionaryValue>());
+    dict->GetDictionaryWithoutPathExpansion(extension_id_, &extension);
   }
   if (!extension->Get(key_, &key_value)) {
-    value_as_t = new T;
-    extension->SetWithoutPathExpansion(key_, base::WrapUnique(value_as_t));
+    extension->SetWithoutPathExpansion(key_, base::MakeUnique<T>());
+    extension->GetWithoutPathExpansion(key_, &key_value);
   } else {
     // It would be nice to CHECK that this doesn't happen, but since prefs can
     // get into a mangled state, we can't really do that. Instead, handle it
     // gracefully (by overwriting whatever was previously there).
     // TODO(devlin): It's unclear if there's anything we'll ever be able to do
     // here (corrupted prefs are sometimes a fact of life), but the debug info
     // might be useful. Remove the dumps after we analyze them.
     if (key_value->GetType() != type_enum_value) {
       NOTREACHED();
-      value_as_t = new T();
-      extension->SetWithoutPathExpansion(key_, base::WrapUnique(value_as_t));
-    } else {
-      value_as_t = static_cast<T*>(key_value);
+      extension->SetWithoutPathExpansion(key_, base::MakeUnique<T>());
+      extension->GetWithoutPathExpansion(key_, &key_value);
     }
   }
-  return value_as_t;
+  return static_cast<T*>(key_value);
 }
 
 // Explicit instantiations for Dictionary and List value types.
 template class ExtensionPrefs::ScopedUpdate<base::DictionaryValue,
                                             base::Value::Type::DICTIONARY>;
 template class ExtensionPrefs::ScopedUpdate<base::ListValue,
                                             base::Value::Type::LIST>;
 
 //
 // ExtensionPrefs
@@ skipping 1625 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