Re-factor network_event_log

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/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
-const char kLogModule[] = "NetworkState";
-
 bool ConvertListValueToStringVector(const base::ListValue& string_list,
                                     std::vector<std::string>* result) {
   for (size_t i = 0; i < string_list.GetSize(); ++i) {
     std::string str;
     if (!string_list.GetString(i, &str))
       return false;
     result->push_back(str);
   }
   return true;
 }
@@ skipping 158 matching lines @@
 bool NetworkState::IsConnectingState() const {
   return StateIsConnecting(connection_state_);
 }
 
 void NetworkState::UpdateName() {
   if (hex_ssid_.empty()) {
     // Validate name for UTF8.
     std::string valid_ssid = ValidateUTF8(name());
     if (valid_ssid != name()) {
       set_name(valid_ssid);
-      network_event_log::AddEntry(
-          kLogModule, "UpdateName",
-          base::StringPrintf("%s: UTF8: %s", path().c_str(), name().c_str()));
+      NET_LOG_DEBUG("UpdateName", base::StringPrintf(
+          "%s: UTF8: %s", path().c_str(), name().c_str()));
     }
     return;
   }
 
   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());
   } else {
     std::string desc = base::StringPrintf("%s: Error processing: %s",
                                           path().c_str(), hex_ssid_.c_str());
-    network_event_log::AddEntry(kLogModule, "UpdateName", desc);
+    NET_LOG_DEBUG("UpdateName", desc);
     LOG(ERROR) << desc;
     ssid = name();
   }
 
   if (IsStringUTF8(ssid)) {
     if (ssid != name()) {
       set_name(ssid);
-      network_event_log::AddEntry(
-          kLogModule, "UpdateName",
-          base::StringPrintf("%s: UTF8: %s", path().c_str(), name().c_str()));
+      NET_LOG_DEBUG("UpdateName", base::StringPrintf(
+          "%s: UTF8: %s", path().c_str(), name().c_str()));
     }
     return;
   }
 
   // Detect encoding and convert to UTF-8.
   std::string encoding;
   if (!base::DetectEncoding(ssid, &encoding)) {
     // TODO(stevenjb): Test this. See comment in PropertyChanged() under
     // flimflam::kCountryProperty.
     encoding = country_code_;
   }
   if (!encoding.empty()) {
     std::string utf8_ssid;
     if (base::ConvertToUtf8AndNormalize(ssid, encoding, &utf8_ssid)) {
       set_name(utf8_ssid);
-      network_event_log::AddEntry(
-          kLogModule, "UpdateName",
-          base::StringPrintf("%s: Encoding=%s: %s", path().c_str(),
-                             encoding.c_str(), name().c_str()));
+      NET_LOG_DEBUG("UpdateName", base::StringPrintf(
+          "%s: Encoding=%s: %s", path().c_str(),
+          encoding.c_str(), name().c_str()));
       return;
     }
   }
 
   // Unrecognized encoding. Only use raw bytes if name_ is empty.
   if (name().empty())
     set_name(ssid);
-  network_event_log::AddEntry(
-      kLogModule, "UpdateName",
-      base::StringPrintf("%s: Unrecognized Encoding=%s: %s", path().c_str(),
-                         encoding.c_str(), name().c_str()));
+  NET_LOG_DEBUG("UpdateName", base::StringPrintf(
+      "%s: Unrecognized Encoding=%s: %s", path().c_str(),
+      encoding.c_str(), name().c_str()));
 }
 
 // static
 bool NetworkState::StateIsConnected(const std::string& connection_state) {
   return (connection_state == flimflam::kStateReady ||
           connection_state == flimflam::kStateOnline ||
           connection_state == flimflam::kStatePortal);
 }
 
 // static
 bool NetworkState::StateIsConnecting(const std::string& connection_state) {
   return (connection_state == flimflam::kStateAssociation ||
           connection_state == flimflam::kStateConfiguration ||
           connection_state == flimflam::kStateCarrier);
 }
 
 // static
 std::string NetworkState::IPConfigProperty(const char* key) {
   return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key);
 }
 
 }  // namespace chromeos