Elim device log spam when translating ONC

chromeos/network/shill_property_util.cc

 // Copyright 2013 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/shill_property_util.h"
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/values.h"
-#include "chromeos/network/network_event_log.h"
+#include "chromeos/device_event_log.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace shill_property_util {
 
 namespace {
 
@@ skipping 32 matching lines @@
 }
 
 }  // namespace
 
 void SetSSID(const std::string ssid, base::DictionaryValue* properties) {
   std::string hex_ssid = base::HexEncode(ssid.c_str(), ssid.size());
   properties->SetStringWithoutPathExpansion(shill::kWifiHexSsid, hex_ssid);
 }
 
 std::string GetSSIDFromProperties(const base::DictionaryValue& properties,
+                                  bool verbose_logging,
                                   bool* unknown_encoding) {
-  bool verbose_logging = false;
-  if (unknown_encoding) {
+  if (unknown_encoding)
     *unknown_encoding = false;
-    verbose_logging = true;
-  }
 
   // Get name for debugging.
   std::string name;
   properties.GetStringWithoutPathExpansion(shill::kNameProperty, &name);
 
   std::string hex_ssid;
   properties.GetStringWithoutPathExpansion(shill::kWifiHexSsid, &hex_ssid);
 
   if (hex_ssid.empty()) {
+    // Note: use VLOG here to avoid spamming the event log.
     if (verbose_logging)
-      NET_LOG_DEBUG("GetSSIDFromProperties: No HexSSID set.", name);
+      NET_LOG(DEBUG) << "GetSSIDFromProperties: No HexSSID set: " << name;
     return std::string();
   }
 
   std::string ssid;
   std::vector<uint8> raw_ssid_bytes;
   if (base::HexStringToBytes(hex_ssid, &raw_ssid_bytes)) {
     ssid = std::string(raw_ssid_bytes.begin(), raw_ssid_bytes.end());
     if (verbose_logging) {
-      NET_LOG_DEBUG(base::StringPrintf("GetSSIDFromProperties: %s, SSID: %s",
-                                       hex_ssid.c_str(), ssid.c_str()), name);
+      NET_LOG(DEBUG) << "GetSSIDFromProperties: " << name
+                     << " HexSsid=" << hex_ssid << " SSID=" << ssid;
     }
   } else {
-    NET_LOG_ERROR(
-        base::StringPrintf("GetSSIDFromProperties: Error processing: %s",
-                           hex_ssid.c_str()), name);
+    NET_LOG(ERROR) << "GetSSIDFromProperties: " << name
+                   << " Error processing HexSsid: " << hex_ssid;
     return std::string();
   }
 
   if (base::IsStringUTF8(ssid))
     return ssid;
 
   // Detect encoding and convert to UTF-8.
   std::string encoding;
   if (!base::DetectEncoding(ssid, &encoding)) {
     // TODO(stevenjb): This is currently experimental. If we find a case where
     // base::DetectEncoding() fails, we need to figure out whether we can use
     // country_code with ConvertToUtf8(). crbug.com/233267.
     properties.GetStringWithoutPathExpansion(shill::kCountryProperty,
                                              &encoding);
   }
   std::string utf8_ssid;
   if (!encoding.empty() &&
       base::ConvertToUtf8AndNormalize(ssid, encoding, &utf8_ssid)) {
     if (utf8_ssid != ssid) {
       if (verbose_logging) {
-        NET_LOG_DEBUG(
-            base::StringPrintf("GetSSIDFromProperties: Encoding=%s: %s",
-                               encoding.c_str(), utf8_ssid.c_str()), name);
+        NET_LOG(DEBUG) << "GetSSIDFromProperties: " << name
+                       << " Encoding=" << encoding << " SSID=" << ssid
+                       << " UTF8 SSID=" << utf8_ssid;
       }
     }
     return utf8_ssid;
   }
 
   if (unknown_encoding)
     *unknown_encoding = true;
   if (verbose_logging) {
-    NET_LOG_DEBUG(
-        base::StringPrintf("GetSSIDFromProperties: Unrecognized Encoding=%s",
-                           encoding.c_str()), name);
+    NET_LOG(DEBUG) << "GetSSIDFromProperties: " << name
+                   << " Unrecognized Encoding=" << encoding;
   }
   return ssid;
 }
 
 std::string GetNetworkIdFromProperties(
     const base::DictionaryValue& properties) {
   if (properties.empty())
     return "EmptyProperties";
   std::string result;
   if (properties.GetStringWithoutPathExpansion(shill::kGuidProperty, &result))
     return result;
   if (properties.GetStringWithoutPathExpansion(shill::kSSIDProperty, &result))
     return result;
   if (properties.GetStringWithoutPathExpansion(shill::kNameProperty, &result))
     return result;
   std::string type = "UnknownType";
   properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type);
   return "Unidentified " + type;
 }
 
 std::string GetNameFromProperties(const std::string& service_path,
                                   const base::DictionaryValue& properties) {
   std::string name;
   properties.GetStringWithoutPathExpansion(shill::kNameProperty, &name);
 
   std::string validated_name = ValidateUTF8(name);
   if (validated_name != name) {
-    NET_LOG_DEBUG("GetNameFromProperties",
-                  base::StringPrintf("Validated name %s: UTF8: %s",
-                                     service_path.c_str(),
-                                     validated_name.c_str()));
+    NET_LOG(DEBUG) << "GetNameFromProperties: " << service_path
+                   << " Validated name=" << validated_name << " name=" << name;
   }
 
   std::string type;
   properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type);
   if (type.empty()) {
-    NET_LOG_ERROR("GetNameFromProperties: No type", service_path);
+    NET_LOG(ERROR) << "GetNameFromProperties: " << service_path << " No type.";
     return validated_name;
   }
   if (!NetworkTypePattern::WiFi().MatchesType(type))
     return validated_name;
 
   bool unknown_ssid_encoding = false;
-  std::string ssid = GetSSIDFromProperties(properties, &unknown_ssid_encoding);
-  if (ssid.empty())
-    NET_LOG_ERROR("GetNameFromProperties", "No SSID set: " + service_path);
+  std::string ssid = GetSSIDFromProperties(
+      properties, true /* verbose_logging */, &unknown_ssid_encoding);
+  if (ssid.empty()) {
+    NET_LOG(ERROR) << "GetNameFromProperties: " << service_path
+                   << " No SSID set";
+  }
 
   // Use |validated_name| if |ssid| is empty.
   // And if the encoding of the SSID is unknown, use |ssid|, which contains raw
   // bytes in that case, only if |validated_name| is empty.
   if (ssid.empty() || (unknown_ssid_encoding && !validated_name.empty()))
     return validated_name;
 
   if (ssid != validated_name) {
-    NET_LOG_DEBUG("GetNameFromProperties",
-                  base::StringPrintf("%s: SSID: %s, Name: %s",
-                                     service_path.c_str(),
-                                     ssid.c_str(),
-                                     validated_name.c_str()));
+    NET_LOG(DEBUG) << "GetNameFromProperties: " << service_path
+                   << " SSID=" << ssid << " Validated name=" << validated_name;
   }
   return ssid;
 }
 
 scoped_ptr<NetworkUIData> GetUIDataFromValue(const base::Value& ui_data_value) {
   std::string ui_data_str;
   if (!ui_data_value.GetAsString(&ui_data_str))
     return scoped_ptr<NetworkUIData>();
   if (ui_data_str.empty())
     return make_scoped_ptr(new NetworkUIData());
@@ skipping 55 matching lines @@
 
     // VPN Provider values are read from the "Provider" dictionary, but written
     // with the keys "Provider.Type" and "Provider.Host".
     // TODO(pneubeck): Simplify this once http://crbug.com/381135 is fixed.
     std::string vpn_provider_type;
     std::string vpn_provider_host;
     if (properties_read_from_shill) {
       const base::DictionaryValue* provider_properties = NULL;
       if (!service_properties.GetDictionaryWithoutPathExpansion(
               shill::kProviderProperty, &provider_properties)) {
-        NET_LOG_ERROR("Missing VPN provider dict",
-                      GetNetworkIdFromProperties(service_properties));
+        NET_LOG(ERROR) << "Missing VPN provider dict: "
+                       << GetNetworkIdFromProperties(service_properties);
       }
       provider_properties->GetStringWithoutPathExpansion(shill::kTypeProperty,
                                                          &vpn_provider_type);
       provider_properties->GetStringWithoutPathExpansion(shill::kHostProperty,
                                                          &vpn_provider_host);
     } else {
       service_properties.GetStringWithoutPathExpansion(
           shill::kProviderTypeProperty, &vpn_provider_type);
       service_properties.GetStringWithoutPathExpansion(
           shill::kProviderHostProperty, &vpn_provider_host);
     }
     success &= !vpn_provider_type.empty();
     dest->SetStringWithoutPathExpansion(shill::kProviderTypeProperty,
                                         vpn_provider_type);
 
     success &= !vpn_provider_host.empty();
     dest->SetStringWithoutPathExpansion(shill::kProviderHostProperty,
                                         vpn_provider_host);
   } else if (type == shill::kTypeEthernet || type == shill::kTypeEthernetEap) {
     // Ethernet and EthernetEAP don't have any additional identifying
     // properties.
   } else {
     NOTREACHED() << "Unsupported network type " << type;
     success = false;
   }
   if (!success) {
-    NET_LOG_ERROR("Missing required properties",
-                  GetNetworkIdFromProperties(service_properties));
+    NET_LOG(ERROR) << "Missing required properties: "
+                   << GetNetworkIdFromProperties(service_properties);
   }
   return success;
 }
 
 bool DoIdentifyingPropertiesMatch(const base::DictionaryValue& new_properties,
                                   const base::DictionaryValue& old_properties) {
   base::DictionaryValue new_identifying;
   if (!CopyIdentifyingProperties(
           new_properties,
           false /* properties were not read from Shill */,
@@ skipping 47 matching lines @@
     LOG(WARNING)
         << "Provider name and country not defined, using code instead: "
         << *home_provider_id;
   }
   return true;
 }
 
 }  // namespace shill_property_util
 
 }  // namespace chromeos