Change base::Value::ListStorage to std::vector<base::Value>

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 <utility>
@@ skipping 48 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 (const auto& val : *list) {
+  for (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)) {
+    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)) {
+    } else if (val.GetAsString(&entry_name)) {
       new_dict->SetString(kEntry, entry_name);
       new_dict->SetBoolean(kActive, true);
     } else {
       NOTREACHED();
       continue;
     }
 
     if (seen_entries.count(entry_name) == 0) {
       seen_entries.insert(entry_name);
       migrated.Append(std::move(new_dict));
     }
   }
 
   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 (const auto& val : *list) {
+  for (auto& val : *list) {
     base::DictionaryValue* dict = nullptr;
     std::string entry;
-    if (!val->GetAsDictionary(&dict) || !dict->GetString(kEntry, &entry)) {
+    if (!val.GetAsDictionary(&dict) || !dict->GetString(kEntry, &entry)) {
       NOTREACHED();
       continue;
     }
     if (entry == override) {
       dict->SetBoolean(kActive, true);
       return;  // All done!
     }
   }
 
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString(kEntry, override);
   dict->SetBoolean(kActive, true);
   // Add the entry to the front of the list.
   list->Insert(0, std::move(dict));
 }
 
 // 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 (const auto& val : *list) {
+  for (auto& val : *list) {
     base::DictionaryValue* dict = nullptr;
     std::string entry;
-    if (!val->GetAsDictionary(&dict) || !dict->GetString(kEntry, &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);
     if (!override_url.is_valid())
       continue;
 
@@ skipping 29 matching lines @@
 enum UpdateBehavior {
   UPDATE_DEACTIVATE,  // Mark 'active' as false.
   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 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;
-                   });
+  base::ListValue::iterator iter = std::find_if(
+      overrides_list->begin(), overrides_list->end(),
+      [&override_url](const 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;
-        bool success = (*iter)->GetAsDictionary(&dict);
+        bool success = iter->GetAsDictionary(&dict);
         // See comment about CHECK(success) in ForEachOverrideList.
         if (success) {
           dict->SetBoolean(kActive, false);
           break;
         }
         // Else fall through and erase the broken pref.
       }
       case UPDATE_REMOVE:
         overrides_list->Erase(iter, nullptr);
         break;
@@ skipping 217 matching lines @@
   // chrome://bookmarks/#1 for display in the omnibox.
   for (base::DictionaryValue::Iterator dict_iter(*overrides);
        !dict_iter.IsAtEnd(); dict_iter.Advance()) {
     const base::ListValue* url_list = nullptr;
     if (!dict_iter.value().GetAsList(&url_list))
       continue;
 
     for (base::ListValue::const_iterator list_iter = url_list->begin();
          list_iter != url_list->end(); ++list_iter) {
       const base::DictionaryValue* dict = nullptr;
-      if (!(*list_iter)->GetAsDictionary(&dict))
+      if (!list_iter->GetAsDictionary(&dict))
         continue;
       std::string override;
       if (!dict->GetString(kEntry, &override))
         continue;
       if (base::StartsWith(url->spec(), override,
                            base::CompareCase::SENSITIVE)) {
         GURL original_url(content::kChromeUIScheme + std::string("://") +
                           dict_iter.key() +
                           url->spec().substr(override.length()));
         *url = original_url;
@@ skipping 85 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));
 }