Use std::unique_ptr for base::DictionaryValue and base::ListValue's internal store.

chrome/browser/extensions/extension_web_ui.cc

 // Copyright (c) 2012 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/extensions/extension_web_ui.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 47 matching lines @@
 // Iterates over |list| and:
 // - Converts any entries of the form <entry> to
 //   { 'entry': <entry>, 'active': true }.
 // - Removes any duplicate entries.
 // We do the conversion because we previously stored these values as strings
 // rather than objects.
 // TODO(devlin): Remove the conversion once everyone's updated.
 void InitializeOverridesList(base::ListValue* list) {
   base::ListValue migrated;
   std::set<std::string> seen_entries;
-  for (base::Value* val : *list) {
+  for (const auto& val : *list) {
     std::unique_ptr<base::DictionaryValue> new_dict(
         new base::DictionaryValue());
     std::string entry_name;
     base::DictionaryValue* existing_dict = nullptr;
     if (val->GetAsDictionary(&existing_dict)) {
       bool success = existing_dict->GetString(kEntry, &entry_name);
       if (!success)  // See comment about CHECK(success) in ForEachOverrideList.
         continue;
       new_dict->Swap(existing_dict);
     } else if (val->GetAsString(&entry_name)) {
@@ skipping 10 matching lines @@
     }
   }
 
   list->Swap(&migrated);
 }
 
 // Adds |override| to |list|, or, if there's already an entry for the override,
 // marks it as active.
 void AddOverridesToList(base::ListValue* list,
                         const std::string& override) {
-  for (base::Value* val : *list) {
+  for (const auto& val : *list) {
     base::DictionaryValue* dict = nullptr;
     std::string entry;
     if (!val->GetAsDictionary(&dict) || !dict->GetString(kEntry, &entry)) {
       NOTREACHED();
       continue;
     }
     if (entry == override) {
       dict->SetBoolean(kActive, true);
       return;  // All done!
     }
   }
 
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString(kEntry, override);
   dict->SetBoolean(kActive, true);
   // Add the entry to the front of the list.
   list->Insert(0, dict.release());
 }
 
 // Validates that each entry in |list| contains a valid url and points to an
 // extension contained in |all_extensions| (and, if not, removes it).
 void ValidateOverridesList(const extensions::ExtensionSet* all_extensions,
                            base::ListValue* list) {
   base::ListValue migrated;
-  for (base::Value* val : *list) {
+  for (const auto& val : *list) {
     base::DictionaryValue* dict = nullptr;
     std::string entry;
     if (!val->GetAsDictionary(&dict) || !dict->GetString(kEntry, &entry)) {
       NOTREACHED();
       continue;
     }
     std::unique_ptr<base::DictionaryValue> new_dict(
         new base::DictionaryValue());
     new_dict->Swap(dict);
     GURL override_url(entry);
@@ skipping 34 matching lines @@
   UPDATE_REMOVE,      // Remove the entry from the list.
 };
 
 // Updates the entry (if any) for |override_url| in |overrides_list| according
 // to |behavior|. Returns true if anything changed.
 bool UpdateOverridesList(base::ListValue* overrides_list,
                          const std::string& override_url,
                          UpdateBehavior behavior) {
   base::ListValue::iterator iter =
       std::find_if(overrides_list->begin(), overrides_list->end(),
-                   [&override_url](const base::Value* value) {
+                   [&override_url](const std::unique_ptr<base::Value>& value) {
                      std::string entry;
                      const base::DictionaryValue* dict = nullptr;
                      return value->GetAsDictionary(&dict) &&
                             dict->GetString(kEntry, &entry) &&
                             entry == override_url;
                    });
   if (iter != overrides_list->end()) {
     switch (behavior) {
       case UPDATE_DEACTIVATE: {
         base::DictionaryValue* dict = nullptr;
@@ skipping 368 matching lines @@
         extensions::ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
         gfx::Size(pixel_size, pixel_size),
         resource_scale_factor));
   }
 
   // LoadImagesAsync actually can run callback synchronously. We want to force
   // async.
   extensions::ImageLoader::Get(profile)->LoadImagesAsync(
       extension, info_list, base::Bind(&RunFaviconCallbackAsync, callback));
 }