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

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 220 matching lines @@
     if (!field_signature)
       continue;
 
     ExpandStringsInOncObject(*field_signature->value_signature,
                              substitution, inner_object);
   }
 }
 
 void ExpandStringsInNetworks(const StringSubstitution& substitution,
                              base::ListValue* network_configs) {
-  for (base::Value* entry : *network_configs) {
+  for (const auto& entry : *network_configs) {
     base::DictionaryValue* network = nullptr;
     entry->GetAsDictionary(&network);
     DCHECK(network);
     ExpandStringsInOncObject(
         kNetworkConfigurationSignature, substitution, network);
   }
 }
 
 void FillInHexSSIDFieldsInOncObject(const OncValueSignature& signature,
                                     base::DictionaryValue* onc_object) {
@@ skipping 103 matching lines @@
       LOG(ERROR) << "Unable to base64 decode X509 data: " << pem_encoded;
       return std::string();
     }
   }
   return decoded;
 }
 
 CertPEMsByGUIDMap GetServerAndCACertsByGUID(
     const base::ListValue& certificates) {
   CertPEMsByGUIDMap certs_by_guid;
-  for (const base::Value* entry : certificates) {
+  for (const auto& entry : certificates) {
     const base::DictionaryValue* cert = nullptr;
-    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 (base::Value* entry : *network_configs) {
+  for (const auto& entry : *network_configs) {
     base::DictionaryValue* network = nullptr;
     entry->GetAsDictionary(&network);
     DCHECK(network);
     FillInHexSSIDFieldsInOncObject(kNetworkConfigurationSignature, network);
   }
 }
 
 }  // namespace
 
 bool ParseAndValidateOncForImport(const std::string& onc_blob,
@@ skipping 145 matching lines @@
                         const std::string& key_guid_ref_list,
                         const std::string& key_pem_list,
                         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 base::Value* entry : *guid_ref_list) {
+  for (const auto& entry : *guid_ref_list) {
     std::string guid_ref;
-    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);
   onc_object->SetWithoutPathExpansion(key_pem_list, pem_list.release());
@@ skipping 412 matching lines @@
     default: {
       LOG(ERROR) << "Unexpected proxy mode in Shill config: " << mode;
       return nullptr;
     }
   }
   return proxy_settings;
 }
 
 }  // namespace onc
 }  // namespace chromeos