Improve debug logging for GetNameFromProperties

chromeos/network/network_state.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/network_state.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"
@@ skipping 188 matching lines @@
             flimflam::kPaymentPortalPostData, &post_data_)) {
       return false;
     }
     return true;
   }
   return false;
 }
 
 bool NetworkState::InitialPropertiesReceived(
     const base::DictionaryValue& properties) {
+  NET_LOG_DEBUG("InitialPropertiesReceived", path());
   bool changed = UpdateName(properties);
   bool had_ca_cert_nss = has_ca_cert_nss_;
   has_ca_cert_nss_ = IsCaCertNssSet(properties);
   changed |= had_ca_cert_nss != has_ca_cert_nss_;
   return changed;
 }
 
 void NetworkState::GetProperties(base::DictionaryValue* dictionary) const {
   // Keep care that these properties are the same as in |PropertyChanged|.
   dictionary->SetStringWithoutPathExpansion(flimflam::kNameProperty, name());
@@ skipping 96 matching lines @@
     result += dns_servers_[i];
   }
   return result;
 }
 
 std::string NetworkState::GetNetmask() const {
   return network_util::PrefixLengthToNetmask(prefix_length_);
 }
 
 bool NetworkState::UpdateName(const base::DictionaryValue& properties) {
-  std::string updated_name = GetNameFromProperties(properties);
+  std::string updated_name = GetNameFromProperties(path(), properties);
   if (updated_name != name()) {
     set_name(updated_name);
     return true;
   }
   return false;
 }
 
 // static
 std::string NetworkState::GetNameFromProperties(
+    const std::string& service_path,
     const base::DictionaryValue& properties) {
   std::string name;
   properties.GetStringWithoutPathExpansion(flimflam::kNameProperty, &name);
 
   std::string hex_ssid;
   properties.GetStringWithoutPathExpansion(flimflam::kWifiHexSsid, &hex_ssid);
 
   if (hex_ssid.empty()) {
     // Validate name for UTF8.
     std::string valid_ssid = ValidateUTF8(name);
     if (valid_ssid != name) {
       NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-          "%s: UTF8: %s", name.c_str(), valid_ssid.c_str()));
+          "%s: UTF8: %s", service_path.c_str(), valid_ssid.c_str()));
     }
     return valid_ssid;
   }
 
   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());
+    NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
+        "%s: %s, SSID: %s", service_path.c_str(),
+        hex_ssid.c_str(), ssid.c_str()));
   } else {
     NET_LOG_ERROR("GetNameFromProperties",
                   base::StringPrintf("%s: Error processing: %s",
-                                     name.c_str(), hex_ssid.c_str()));
+                                     service_path.c_str(), hex_ssid.c_str()));
     return name;
   }
 
   if (IsStringUTF8(ssid)) {
     if (ssid != name) {
       NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-          "%s: UTF8: %s", name.c_str(), ssid.c_str()));
+          "%s: UTF8: %s", service_path.c_str(), ssid.c_str()));
     }
     return ssid;
   }
 
   // Detect encoding and convert to UTF-8.
   std::string country_code;
   properties.GetStringWithoutPathExpansion(
       flimflam::kCountryProperty, &country_code);
   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.
     encoding = country_code;
   }
   if (!encoding.empty()) {
     std::string utf8_ssid;
     if (base::ConvertToUtf8AndNormalize(ssid, encoding, &utf8_ssid)) {
       if (utf8_ssid != name) {
         NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-            "%s: Encoding=%s: %s", name.c_str(),
+            "%s: Encoding=%s: %s", service_path.c_str(),
             encoding.c_str(), utf8_ssid.c_str()));
       }
       return utf8_ssid;
     }
   }
 
   // Unrecognized encoding. Only use raw bytes if name_ is empty.
   NET_LOG_DEBUG("GetNameFromProperties", base::StringPrintf(
-      "%s: Unrecognized Encoding=%s: %s", name.c_str(),
+      "%s: Unrecognized Encoding=%s: %s", service_path.c_str(),
       encoding.c_str(), ssid.c_str()));
   if (name.empty() && !ssid.empty())
     return ssid;
   return name;
 }
 
 // static
 bool NetworkState::StateIsConnected(const std::string& connection_state) {
   return (connection_state == flimflam::kStateReady ||
           connection_state == flimflam::kStateOnline ||
@@ skipping 24 matching lines @@
   }
   scoped_ptr<base::DictionaryValue> ui_data_dict(
       chromeos::onc::ReadDictionaryFromJson(ui_data_str));
   if (!ui_data_dict)
     return false;
   *out = NetworkUIData(*ui_data_dict);
   return true;
 }
 
 }  // namespace chromeos