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

chromeos/network/onc/onc_utils.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 "chromeos/network/onc/onc_utils.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/base64.h"
@@ skipping 263 matching lines @@
     if (!field_signature)
       continue;
 
     ExpandStringsInOncObject(*field_signature->value_signature,
                              substitution, inner_object);
   }
 }
 
 void ExpandStringsInNetworks(const StringSubstitution& substitution,
                              base::ListValue* network_configs) {
-  for (auto& entry : *network_configs) {
+  for (const auto& entry : *network_configs) {
     base::DictionaryValue* network = nullptr;
-    entry.GetAsDictionary(&network);
+    entry->GetAsDictionary(&network);
     DCHECK(network);
     ExpandStringsInOncObject(
         kNetworkConfigurationSignature, substitution, network);
   }
 }
 
 void FillInHexSSIDFieldsInOncObject(const OncValueSignature& signature,
                                     base::DictionaryValue* onc_object) {
   if (&signature == &kWiFiSignature)
     FillInHexSSIDField(onc_object);
@@ skipping 103 matching lines @@
     }
   }
   return decoded;
 }
 
 CertPEMsByGUIDMap GetServerAndCACertsByGUID(
     const base::ListValue& certificates) {
   CertPEMsByGUIDMap certs_by_guid;
   for (const auto& entry : certificates) {
     const base::DictionaryValue* cert = nullptr;
-    bool entry_is_dictionary = entry.GetAsDictionary(&cert);
+    bool entry_is_dictionary = entry->GetAsDictionary(&cert);
     DCHECK(entry_is_dictionary);
 
     std::string guid;
     cert->GetStringWithoutPathExpansion(certificate::kGUID, &guid);
     std::string cert_type;
     cert->GetStringWithoutPathExpansion(certificate::kType, &cert_type);
     if (cert_type != certificate::kServer &&
         cert_type != certificate::kAuthority) {
       continue;
     }
     std::string x509_data;
     cert->GetStringWithoutPathExpansion(certificate::kX509, &x509_data);
 
     std::string der = DecodePEM(x509_data);
     std::string pem;
     if (der.empty() || !net::X509Certificate::GetPEMEncodedFromDER(der, &pem)) {
       LOG(ERROR) << "Certificate with GUID " << guid
                  << " is not in PEM encoding.";
       continue;
     }
     certs_by_guid[guid] = pem;
   }
 
   return certs_by_guid;
 }
 
 void FillInHexSSIDFieldsInNetworks(base::ListValue* network_configs) {
-  for (auto& entry : *network_configs) {
+  for (const auto& entry : *network_configs) {
     base::DictionaryValue* network = nullptr;
-    entry.GetAsDictionary(&network);
+    entry->GetAsDictionary(&network);
     DCHECK(network);
     FillInHexSSIDFieldsInOncObject(kNetworkConfigurationSignature, network);
   }
 }
 
 }  // namespace
 
 bool ParseAndValidateOncForImport(const std::string& onc_blob,
                                   ONCSource onc_source,
                                   const std::string& passphrase,
@@ skipping 145 matching lines @@
                         base::DictionaryValue* onc_object) {
   const base::ListValue* guid_ref_list = nullptr;
   if (!onc_object->GetListWithoutPathExpansion(key_guid_ref_list,
                                                &guid_ref_list)) {
     return true;
   }
 
   std::unique_ptr<base::ListValue> pem_list(new base::ListValue);
   for (const auto& entry : *guid_ref_list) {
     std::string guid_ref;
-    bool entry_is_string = entry.GetAsString(&guid_ref);
+    bool entry_is_string = entry->GetAsString(&guid_ref);
     DCHECK(entry_is_string);
 
     std::string pem_encoded;
     if (!GUIDRefToPEMEncoding(certs_by_guid, guid_ref, &pem_encoded))
       return false;
 
     pem_list->AppendString(pem_encoded);
   }
 
   onc_object->RemoveWithoutPathExpansion(key_guid_ref_list, nullptr);
@@ skipping 106 matching lines @@
 }
 
 }  // namespace
 
 bool ResolveServerCertRefsInNetworks(const CertPEMsByGUIDMap& certs_by_guid,
                                      base::ListValue* network_configs) {
   bool success = true;
   for (base::ListValue::iterator it = network_configs->begin();
        it != network_configs->end(); ) {
     base::DictionaryValue* network = nullptr;
-    it->GetAsDictionary(&network);
+    (*it)->GetAsDictionary(&network);
     if (!ResolveServerCertRefsInNetwork(certs_by_guid, network)) {
       std::string guid;
       network->GetStringWithoutPathExpansion(network_config::kGUID, &guid);
       // This might happen even with correct validation, if the referenced
       // certificate couldn't be imported.
       LOG(ERROR) << "Couldn't resolve some certificate reference of network "
                  << guid;
       it = network_configs->Erase(it, nullptr);
       success = false;
       continue;
@@ skipping 106 matching lines @@
   ProxyConfigDictionary::EncodeAndAppendProxyServer(url_scheme, proxy_server,
                                                     spec);
 }
 
 net::ProxyBypassRules ConvertOncExcludeDomainsToBypassRules(
     const base::ListValue& onc_exclude_domains) {
   net::ProxyBypassRules rules;
   for (base::ListValue::const_iterator it = onc_exclude_domains.begin();
        it != onc_exclude_domains.end(); ++it) {
     std::string rule;
-    it->GetAsString(&rule);
+    (*it)->GetAsString(&rule);
     rules.AddRuleFromString(rule);
   }
   return rules;
 }
 
 std::string SchemeToString(net::ProxyServer::Scheme scheme) {
   switch (scheme) {
     case net::ProxyServer::SCHEME_DIRECT:
       return kDirectScheme;
     case net::ProxyServer::SCHEME_HTTP:
@@ skipping 165 matching lines @@
 }
 
 namespace {
 
 const base::DictionaryValue* GetNetworkConfigByGUID(
     const base::ListValue& network_configs,
     const std::string& guid) {
   for (base::ListValue::const_iterator it = network_configs.begin();
        it != network_configs.end(); ++it) {
     const base::DictionaryValue* network = NULL;
-    it->GetAsDictionary(&network);
+    (*it)->GetAsDictionary(&network);
     DCHECK(network);
 
     std::string current_guid;
     network->GetStringWithoutPathExpansion(::onc::network_config::kGUID,
                                            &current_guid);
     if (current_guid == guid)
       return network;
   }
   return NULL;
 }
 
 const base::DictionaryValue* GetNetworkConfigForEthernetWithoutEAP(
     const base::ListValue& network_configs) {
   VLOG(2) << "Search for ethernet policy without EAP.";
   for (base::ListValue::const_iterator it = network_configs.begin();
        it != network_configs.end(); ++it) {
     const base::DictionaryValue* network = NULL;
-    it->GetAsDictionary(&network);
+    (*it)->GetAsDictionary(&network);
     DCHECK(network);
 
     std::string type;
     network->GetStringWithoutPathExpansion(::onc::network_config::kType, &type);
     if (type != ::onc::network_type::kEthernet)
       continue;
 
     const base::DictionaryValue* ethernet = NULL;
     network->GetDictionaryWithoutPathExpansion(::onc::network_config::kEthernet,
                                                &ethernet);
@@ skipping 105 matching lines @@
           user->username_hash());
   if (!profile) {
     *error = "User profile doesn't exist.";
     return;
   }
 
   bool ethernet_not_found = false;
   for (base::ListValue::const_iterator it = expanded_networks->begin();
        it != expanded_networks->end(); ++it) {
     const base::DictionaryValue* network = NULL;
-    it->GetAsDictionary(&network);
+    (*it)->GetAsDictionary(&network);
     DCHECK(network);
 
     // Remove irrelevant fields.
     onc::Normalizer normalizer(true /* remove recommended fields */);
     std::unique_ptr<base::DictionaryValue> normalized_network =
         normalizer.NormalizeObject(&onc::kNetworkConfigurationSignature,
                                    *network);
 
     // TODO(pneubeck): Use ONC and ManagedNetworkConfigurationHandler instead.
     // crbug.com/457936
@@ skipping 118 matching lines @@
                          const PrefService* local_state_prefs,
                          const NetworkState& network) {
   ::onc::ONCSource ignored_onc_source;
   const base::DictionaryValue* policy = onc::GetPolicyForNetwork(
       profile_prefs, local_state_prefs, network, &ignored_onc_source);
   return policy != NULL;
 }
 
 }  // namespace onc
 }  // namespace chromeos