Re-factor network_event_log

chromeos/network/onc/onc_certificate_importer.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_certificate_importer.h"
 
 #include <cert.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/onc/onc_constants.h"
 #include "net/base/crypto_module.h"
 #include "net/base/net_errors.h"
 #include "net/cert/nss_cert_database.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)
+#define ONC_LOG_WARNING(message)                                \
+  NET_LOG_DEBUG("ONC Certificate Import Warning", message)
+#define ONC_LOG_ERROR(message)                                  \
+  NET_LOG_ERROR("ONC Certificate Import Error", message)
 
 namespace {
 
 // The PEM block header used for DER certificates
 const char kCertificateHeader[] = "CERTIFICATE";
 // This is an older PEM marker for DER certificates.
 const char kX509CertificateHeader[] = "X509 CERTIFICATE";
 
 }  // namespace
 
@@ skipping 256 matching lines @@
   net::NSSCertDatabase::TrustBits trust = import_with_ssl_trust ?
                                           net::NSSCertDatabase::TRUSTED_SSL :
                                           net::NSSCertDatabase::TRUST_DEFAULT;
   if (cert_type == certificate::kServer) {
     success = cert_database->ImportServerCert(cert_list, trust, &failures);
   } else {  // Authority cert
     success = cert_database->ImportCACerts(cert_list, trust, &failures);
   }
 
   if (!failures.empty()) {
-    ONC_LOG_ERROR("Error (" + net::ErrorToString(failures[0].net_error) +
-            ") importing " + cert_type + " certificate");
+    ONC_LOG_ERROR(base::StringPrintf("Error ( %s ) importing %s certificate",
+                                     net::ErrorToString(failures[0].net_error),
+                                     cert_type.c_str()));
     return false;
   }
   if (!success) {
     ONC_LOG_ERROR("Unknown error importing " + cert_type + " certificate.");
     return false;
   }
 
   if (web_trust_flag && onc_trusted_certificates)
     onc_trusted_certificates->push_back(x509_cert);
 
@@ skipping 19 matching lines @@
   }
 
   // Since this has a private key, always use the private module.
   net::NSSCertDatabase* cert_database = net::NSSCertDatabase::GetInstance();
   scoped_refptr<net::CryptoModule> module(cert_database->GetPrivateModule());
   net::CertificateList imported_certs;
 
   int import_result = cert_database->ImportFromPKCS12(
       module.get(), decoded_pkcs12, string16(), false, &imported_certs);
   if (import_result != net::OK) {
-    ONC_LOG_ERROR("Unable to import client certificate (error " +
-                  net::ErrorToString(import_result) + ").");
+    ONC_LOG_ERROR(
+        base::StringPrintf("Unable to import client certificate (error %s)",
+                           net::ErrorToString(import_result)));
     return false;
   }
 
   if (imported_certs.size() == 0) {
     ONC_LOG_WARNING("PKCS12 data contains no importable certificates.");
     return true;
   }
 
   if (imported_certs.size() != 1) {
     ONC_LOG_WARNING("ONC File: PKCS12 data contains more than one certificate. "
@@ skipping 12 matching lines @@
     PK11_SetPrivateKeyNickname(private_key, const_cast<char*>(guid.c_str()));
     SECKEY_DestroyPrivateKey(private_key);
   } else {
     ONC_LOG_WARNING("Unable to find private key for certificate.");
   }
   return true;
 }
 
 }  // namespace onc
 }  // namespace chromeos