Cleanup onc_utils.cc to current style.

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 "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/onc/onc_mapper.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/onc/onc_validator.h"
+#include "components/device_event_log/device_event_log.h"
 #include "crypto/encryptor.h"
 #include "crypto/hmac.h"
 #include "crypto/symmetric_key.h"
 #include "net/cert/pem_tokenizer.h"
 #include "net/cert/x509_certificate.h"
 
-#define ONC_LOG_WARNING(message) NET_LOG_WARNING("ONC", message)
-#define ONC_LOG_ERROR(message) NET_LOG_ERROR("ONC", message)
-
 using namespace ::onc;
 
 namespace chromeos {
 namespace onc {
 
 namespace {
 
 const char kUnableToDecrypt[] = "Unable to decrypt encrypted ONC";
 const char kUnableToDecode[] = "Unable to decode encrypted ONC";
 
 }  // namespace
 
 const char kEmptyUnencryptedConfiguration[] =
     "{\"Type\":\"UnencryptedConfiguration\",\"NetworkConfigurations\":[],"
     "\"Certificates\":[]}";
 
 scoped_ptr<base::DictionaryValue> ReadDictionaryFromJson(
     const std::string& json) {
   std::string error;
   base::Value* root = base::JSONReader::ReadAndReturnError(
-      json, base::JSON_ALLOW_TRAILING_COMMAS, NULL, &error);
+      json, base::JSON_ALLOW_TRAILING_COMMAS, nullptr, &error);
 
-  base::DictionaryValue* dict_ptr = NULL;
+  base::DictionaryValue* dict_ptr = nullptr;
   if (!root || !root->GetAsDictionary(&dict_ptr)) {
-    ONC_LOG_ERROR("Invalid JSON Dictionary: " + error);
+    NET_LOG(ERROR) << "Invalid JSON Dictionary: " << error;
     delete root;
   }
 
   return make_scoped_ptr(dict_ptr);
 }
 
 scoped_ptr<base::DictionaryValue> Decrypt(const std::string& passphrase,
                                           const base::DictionaryValue& root) {
   const int kKeySizeInBits = 256;
   const int kMaxIterationCount = 500000;
@@ skipping 10 matching lines @@
   if (!root.GetString(encrypted::kCiphertext, &ciphertext) ||
       !root.GetString(encrypted::kCipher, &cipher) ||
       !root.GetString(encrypted::kHMAC, &hmac) ||
       !root.GetString(encrypted::kHMACMethod, &hmac_method) ||
       !root.GetString(encrypted::kIV, &initial_vector) ||
       !root.GetInteger(encrypted::kIterations, &iterations) ||
       !root.GetString(encrypted::kSalt, &salt) ||
       !root.GetString(encrypted::kStretch, &stretch_method) ||
       !root.GetString(toplevel_config::kType, &onc_type) ||
       onc_type != toplevel_config::kEncryptedConfiguration) {
-
-    ONC_LOG_ERROR("Encrypted ONC malformed.");
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << "Encrypted ONC malformed.";
+    return nullptr;
   }
 
   if (hmac_method != encrypted::kSHA1 ||
       cipher != encrypted::kAES256 ||
       stretch_method != encrypted::kPBKDF2) {
-    ONC_LOG_ERROR("Encrypted ONC unsupported encryption scheme.");
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << "Encrypted ONC unsupported encryption scheme.";
+    return nullptr;
   }
 
   // Make sure iterations != 0, since that's not valid.
   if (iterations == 0) {
-    ONC_LOG_ERROR(kUnableToDecrypt);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecrypt;
+    return nullptr;
   }
 
   // Simply a sanity check to make sure we can't lock up the machine
   // for too long with a huge number (or a negative number).
   if (iterations < 0 || iterations > kMaxIterationCount) {
-    ONC_LOG_ERROR("Too many iterations in encrypted ONC");
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << "Too many iterations in encrypted ONC";
+    return nullptr;
   }
 
   if (!base::Base64Decode(salt, &salt)) {
-    ONC_LOG_ERROR(kUnableToDecode);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecode;
+    return nullptr;
   }
 
   scoped_ptr<crypto::SymmetricKey> key(
       crypto::SymmetricKey::DeriveKeyFromPassword(crypto::SymmetricKey::AES,
                                                   passphrase,
                                                   salt,
                                                   iterations,
                                                   kKeySizeInBits));
 
   if (!base::Base64Decode(initial_vector, &initial_vector)) {
-    ONC_LOG_ERROR(kUnableToDecode);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecode;
+    return nullptr;
   }
   if (!base::Base64Decode(ciphertext, &ciphertext)) {
-    ONC_LOG_ERROR(kUnableToDecode);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecode;
+    return nullptr;
   }
   if (!base::Base64Decode(hmac, &hmac)) {
-    ONC_LOG_ERROR(kUnableToDecode);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecode;
+    return nullptr;
   }
 
   crypto::HMAC hmac_verifier(crypto::HMAC::SHA1);
   if (!hmac_verifier.Init(key.get()) ||
       !hmac_verifier.Verify(ciphertext, hmac)) {
-    ONC_LOG_ERROR(kUnableToDecrypt);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecrypt;
+    return nullptr;
   }
 
   crypto::Encryptor decryptor;
   if (!decryptor.Init(key.get(), crypto::Encryptor::CBC, initial_vector))  {
-    ONC_LOG_ERROR(kUnableToDecrypt);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecrypt;
+    return nullptr;
   }
 
   std::string plaintext;
   if (!decryptor.Decrypt(ciphertext, &plaintext)) {
-    ONC_LOG_ERROR(kUnableToDecrypt);
-    return scoped_ptr<base::DictionaryValue>();
+    NET_LOG(ERROR) << kUnableToDecrypt;
+    return nullptr;
   }
 
   scoped_ptr<base::DictionaryValue> new_root =
       ReadDictionaryFromJson(plaintext);
-  if (new_root.get() == NULL) {
-    ONC_LOG_ERROR("Property dictionary malformed.");
-    return scoped_ptr<base::DictionaryValue>();
+  if (!new_root) {
+    NET_LOG(ERROR) << "Property dictionary malformed.";
+    return nullptr;
   }
 
   return new_root.Pass();
 }
 
 std::string GetSourceAsString(ONCSource source) {
   switch (source) {
     case ONC_SOURCE_UNKNOWN:
       return "unknown";
     case ONC_SOURCE_NONE:
@@ skipping 41 matching lines @@
     ExpandField(eap::kAnonymousIdentity, substitution, onc_object);
     ExpandField(eap::kIdentity, substitution, onc_object);
   } else if (&signature == &kL2TPSignature ||
              &signature == &kOpenVPNSignature) {
     ExpandField(vpn::kUsername, substitution, onc_object);
   }
 
   // Recurse into nested objects.
   for (base::DictionaryValue::Iterator it(*onc_object); !it.IsAtEnd();
        it.Advance()) {
-    base::DictionaryValue* inner_object = NULL;
+    base::DictionaryValue* inner_object = nullptr;
     if (!onc_object->GetDictionaryWithoutPathExpansion(it.key(), &inner_object))
       continue;
 
     const OncFieldSignature* field_signature =
         GetFieldSignature(signature, it.key());
     if (!field_signature)
       continue;
 
     ExpandStringsInOncObject(*field_signature->value_signature,
                              substitution, inner_object);
   }
 }
 
 void ExpandStringsInNetworks(const StringSubstitution& substitution,
                              base::ListValue* network_configs) {
-  for (base::ListValue::iterator it = network_configs->begin();
-       it != network_configs->end(); ++it) {
-    base::DictionaryValue* network = NULL;
-    (*it)->GetAsDictionary(&network);
+  for (base::Value* 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) {
   if (&signature == &kWiFiSignature)
     FillInHexSSIDField(onc_object);
@@ skipping 16 matching lines @@
 }
 
 void FillInHexSSIDField(base::DictionaryValue* wifi_fields) {
   std::string ssid_string;
   if (wifi_fields->HasKey(::onc::wifi::kHexSSID) ||
       !wifi_fields->GetStringWithoutPathExpansion(::onc::wifi::kSSID,
                                                   &ssid_string)) {
     return;
   }
   if (ssid_string.empty()) {
-    ONC_LOG_ERROR("Found empty SSID field.");
+    NET_LOG(ERROR) << "Found empty SSID field.";
     return;
   }
   wifi_fields->SetStringWithoutPathExpansion(
       ::onc::wifi::kHexSSID,
       base::HexEncode(ssid_string.c_str(), ssid_string.size()));
 }
 
 namespace {
 
 class OncMaskValues : public Mapper {
@@ skipping 63 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 (base::ListValue::const_iterator it = certificates.begin();
-      it != certificates.end(); ++it) {
-    base::DictionaryValue* cert = NULL;
-    (*it)->GetAsDictionary(&cert);
+  for (const base::Value* entry : certificates) {
+    const base::DictionaryValue* cert = nullptr;
+    entry->GetAsDictionary(&cert);
 
     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::ListValue::iterator it = network_configs->begin();
-       it != network_configs->end(); ++it) {
-    base::DictionaryValue* network = NULL;
-    (*it)->GetAsDictionary(&network);
+  for (base::Value* entry : *network_configs) {
+    base::DictionaryValue* network = nullptr;
+    entry->GetAsDictionary(&network);
     DCHECK(network);
     FillInHexSSIDFieldsInOncObject(kNetworkConfigurationSignature, network);
   }
 }
 
 }  // namespace
 
 bool ParseAndValidateOncForImport(const std::string& onc_blob,
                                   ONCSource onc_source,
                                   const std::string& passphrase,
                                   base::ListValue* network_configs,
                                   base::DictionaryValue* global_network_config,
                                   base::ListValue* certificates) {
   network_configs->Clear();
   global_network_config->Clear();
   certificates->Clear();
   if (onc_blob.empty())
     return true;
 
   scoped_ptr<base::DictionaryValue> toplevel_onc =
       ReadDictionaryFromJson(onc_blob);
-  if (toplevel_onc.get() == NULL) {
+  if (!toplevel_onc) {
     LOG(ERROR) << "ONC loaded from " << GetSourceAsString(onc_source)
                << " is not a valid JSON dictionary.";
     return false;
   }
 
   // Check and see if this is an encrypted ONC file. If so, decrypt it.
   std::string onc_type;
   toplevel_onc->GetStringWithoutPathExpansion(toplevel_config::kType,
                                               &onc_type);
   if (onc_type == toplevel_config::kEncryptedConfiguration) {
     toplevel_onc = Decrypt(passphrase, *toplevel_onc);
-    if (toplevel_onc.get() == NULL) {
+    if (!toplevel_onc) {
       LOG(ERROR) << "Couldn't decrypt the ONC from "
                  << GetSourceAsString(onc_source);
       return false;
     }
   }
 
   bool from_policy = (onc_source == ONC_SOURCE_USER_POLICY ||
                       onc_source == ONC_SOURCE_DEVICE_POLICY);
 
   // Validate the ONC dictionary. We are liberal and ignore unknown field
@@ skipping 13 matching lines @@
   if (from_policy) {
     UMA_HISTOGRAM_BOOLEAN("Enterprise.ONC.PolicyValidation",
                           validation_result == Validator::VALID);
   }
 
   bool success = true;
   if (validation_result == Validator::VALID_WITH_WARNINGS) {
     LOG(WARNING) << "ONC from " << GetSourceAsString(onc_source)
                  << " produced warnings.";
     success = false;
-  } else if (validation_result == Validator::INVALID || toplevel_onc == NULL) {
+  } else if (validation_result == Validator::INVALID || !toplevel_onc) {
     LOG(ERROR) << "ONC from " << GetSourceAsString(onc_source)
                << " is invalid and couldn't be repaired.";
     return false;
   }
 
-  base::ListValue* validated_certs = NULL;
+  base::ListValue* validated_certs = nullptr;
   if (toplevel_onc->GetListWithoutPathExpansion(toplevel_config::kCertificates,
                                                 &validated_certs)) {
     certificates->Swap(validated_certs);
   }
 
-  base::ListValue* validated_networks = NULL;
+  base::ListValue* validated_networks = nullptr;
   if (toplevel_onc->GetListWithoutPathExpansion(
           toplevel_config::kNetworkConfigurations, &validated_networks)) {
     FillInHexSSIDFieldsInNetworks(validated_networks);
 
     CertPEMsByGUIDMap server_and_ca_certs =
         GetServerAndCACertsByGUID(*certificates);
 
     if (!ResolveServerCertRefsInNetworks(server_and_ca_certs,
                                          validated_networks)) {
       LOG(ERROR) << "Some certificate references in the ONC policy for source "
                  << GetSourceAsString(onc_source) << " could not be resolved.";
       success = false;
     }
 
     network_configs->Swap(validated_networks);
   }
 
-  base::DictionaryValue* validated_global_config = NULL;
+  base::DictionaryValue* validated_global_config = nullptr;
   if (toplevel_onc->GetDictionaryWithoutPathExpansion(
           toplevel_config::kGlobalNetworkConfiguration,
           &validated_global_config)) {
     global_network_config->Swap(validated_global_config);
   }
 
   return success;
 }
 
 scoped_refptr<net::X509Certificate> DecodePEMCertificate(
@@ skipping 29 matching lines @@
                           const std::string& key_pem,
                           base::DictionaryValue* onc_object) {
   std::string guid_ref;
   if (!onc_object->GetStringWithoutPathExpansion(key_guid_ref, &guid_ref))
     return true;
 
   std::string pem_encoded;
   if (!GUIDRefToPEMEncoding(certs_by_guid, guid_ref, &pem_encoded))
     return false;
 
-  onc_object->RemoveWithoutPathExpansion(key_guid_ref, NULL);
+  onc_object->RemoveWithoutPathExpansion(key_guid_ref, nullptr);
   onc_object->SetStringWithoutPathExpansion(key_pem, pem_encoded);
   return true;
 }
 
 bool ResolveCertRefList(const CertPEMsByGUIDMap& certs_by_guid,
                         const std::string& key_guid_ref_list,
                         const std::string& key_pem_list,
                         base::DictionaryValue* onc_object) {
-  const base::ListValue* guid_ref_list = NULL;
+  const base::ListValue* guid_ref_list = nullptr;
   if (!onc_object->GetListWithoutPathExpansion(key_guid_ref_list,
                                                &guid_ref_list)) {
     return true;
   }
 
   scoped_ptr<base::ListValue> pem_list(new base::ListValue);
-  for (base::ListValue::const_iterator it = guid_ref_list->begin();
-       it != guid_ref_list->end(); ++it) {
+  for (const base::Value* entry : *guid_ref_list) {
     std::string guid_ref;
-    (*it)->GetAsString(&guid_ref);
+    entry->GetAsString(&guid_ref);
 
     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, NULL);
+  onc_object->RemoveWithoutPathExpansion(key_guid_ref_list, nullptr);
   onc_object->SetWithoutPathExpansion(key_pem_list, pem_list.release());
   return true;
 }
 
 bool ResolveSingleCertRefToList(const CertPEMsByGUIDMap& certs_by_guid,
                                 const std::string& key_guid_ref,
                                 const std::string& key_pem_list,
                                 base::DictionaryValue* onc_object) {
   std::string guid_ref;
   if (!onc_object->GetStringWithoutPathExpansion(key_guid_ref, &guid_ref))
     return true;
 
   std::string pem_encoded;
   if (!GUIDRefToPEMEncoding(certs_by_guid, guid_ref, &pem_encoded))
     return false;
 
   scoped_ptr<base::ListValue> pem_list(new base::ListValue);
   pem_list->AppendString(pem_encoded);
-  onc_object->RemoveWithoutPathExpansion(key_guid_ref, NULL);
+  onc_object->RemoveWithoutPathExpansion(key_guid_ref, nullptr);
   onc_object->SetWithoutPathExpansion(key_pem_list, pem_list.release());
   return true;
 }
 
 // Resolves the reference list at |key_guid_refs| if present and otherwise the
 // single reference at |key_guid_ref|. Returns whether the respective resolving
 // was successful.
 bool ResolveCertRefsOrRefToList(const CertPEMsByGUIDMap& certs_by_guid,
                                 const std::string& key_guid_refs,
                                 const std::string& key_guid_ref,
                                 const std::string& key_pem_list,
                                 base::DictionaryValue* onc_object) {
   if (onc_object->HasKey(key_guid_refs)) {
     if (onc_object->HasKey(key_guid_ref)) {
       LOG(ERROR) << "Found both " << key_guid_refs << " and " << key_guid_ref
                  << ". Ignoring and removing the latter.";
-      onc_object->RemoveWithoutPathExpansion(key_guid_ref, NULL);
+      onc_object->RemoveWithoutPathExpansion(key_guid_ref, nullptr);
     }
     return ResolveCertRefList(
         certs_by_guid, key_guid_refs, key_pem_list, onc_object);
   }
 
   // Only resolve |key_guid_ref| if |key_guid_refs| isn't present.
   return ResolveSingleCertRefToList(
       certs_by_guid, key_guid_ref, key_pem_list, onc_object);
 }
 
@@ skipping 34 matching lines @@
                                     openvpn::kServerCARef,
                                     openvpn::kServerCAPEMs,
                                     onc_object)) {
       return false;
     }
   }
 
   // Recurse into nested objects.
   for (base::DictionaryValue::Iterator it(*onc_object); !it.IsAtEnd();
        it.Advance()) {
-    base::DictionaryValue* inner_object = NULL;
+    base::DictionaryValue* inner_object = nullptr;
     if (!onc_object->GetDictionaryWithoutPathExpansion(it.key(), &inner_object))
       continue;
 
     const OncFieldSignature* field_signature =
         GetFieldSignature(signature, it.key());
     if (!field_signature)
       continue;
 
     if (!ResolveServerCertRefsInObject(certs_by_guid,
                                        *field_signature->value_signature,
                                        inner_object)) {
       return false;
     }
   }
   return true;
 }
 
 }  // 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 = NULL;
+    base::DictionaryValue* network = nullptr;
     (*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, NULL);
+      it = network_configs->Erase(it, nullptr);
       success = false;
       continue;
     }
     ++it;
   }
   return success;
 }
 
 bool ResolveServerCertRefsInNetwork(const CertPEMsByGUIDMap& certs_by_guid,
                                     base::DictionaryValue* network_config) {
@@ skipping 29 matching lines @@
     // 'WiFi.AutoConnect' -> 'AutoConnect', 'WiFi.Recommended'
     property_basename = property_key.substr(pos + 1);
     recommended_property_key =
         property_key.substr(0, pos + 1) + ::onc::kRecommended;
   } else {
     // 'Name' -> 'Name', 'Recommended'
     property_basename = property_key;
     recommended_property_key = ::onc::kRecommended;
   }
 
-  const base::ListValue* recommended_keys = NULL;
+  const base::ListValue* recommended_keys = nullptr;
   return (onc->GetList(recommended_property_key, &recommended_keys) &&
           recommended_keys->Find(base::StringValue(property_basename)) !=
           recommended_keys->end());
 }
 
 }  // namespace onc
 }  // namespace chromeos