Re-factor network_event_log

chromeos/network/network_connection_handler.cc

 // Copyright (c) 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/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/cert_loader.h"
 #include "chromeos/network/certificate_pattern_matcher.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
 #include "dbus/object_path.h"
 #include "net/cert/x509_certificate.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
-const char kLogModule[] = "NetworkConnectionHandler";
-
 void InvokeErrorCallback(
     const std::string& service_path,
     const network_handler::ErrorCallback& error_callback,
     const std::string& error_name) {
   network_handler::ShillErrorCallbackFunction(
-      kLogModule, service_path, error_callback, error_name, "Connect Error");
+      service_path, error_callback, error_name, "Connect Error");
 }
 
 bool NetworkMayNeedCredentials(const NetworkState* network) {
   if (network->type() == flimflam::kTypeWifi &&
       (network->security() == flimflam::kSecurity8021x ||
        network->security() == flimflam::kSecurityWep /* For dynamic WEP*/))
     return true;
   if (network->type() == flimflam::kTypeVPN)
     return true;
   return false;
@@ skipping 164 matching lines @@
   CallShillDisconnect(service_path, success_callback, error_callback);
 }
 
 void NetworkConnectionHandler::CallShillConnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   // TODO(stevenjb): Remove SetConnectingNetwork and use this class to maintain
   // the connecting network(s) once NetworkLibrary path is eliminated.
   NetworkStateHandler::Get()->SetConnectingNetwork(service_path);
-  network_event_log::AddEntry(kLogModule, "Connect Request", service_path);
+  NET_LOG_EVENT("Connect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Connect(
       dbus::ObjectPath(service_path),
       base::Bind(&NetworkConnectionHandler::HandleShillSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&NetworkConnectionHandler::HandleShillFailure,
                  AsWeakPtr(), service_path, error_callback));
 }
 
 void NetworkConnectionHandler::CallShillDisconnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
-  network_event_log::AddEntry(kLogModule, "Disconnect Request", service_path);
+  NET_LOG_EVENT("Disconnect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path),
       base::Bind(&NetworkConnectionHandler::HandleShillSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&NetworkConnectionHandler::HandleShillFailure,
                  AsWeakPtr(), service_path, error_callback));
 }
 
 void NetworkConnectionHandler::VerifyConfiguredAndConnect(
     const base::Closure& success_callback,
@@ skipping 39 matching lines @@
 
 void NetworkConnectionHandler::HandleShillSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   // TODO(stevenjb): Currently, this only indicates that the connect request
   // succeeded. It might be preferable to wait for the actually connect
   // attempt to succeed or fail here and only call |success_callback| at that
   // point (or maybe call it twice, once indicating in-progress, then success
   // or failure).
   pending_requests_.erase(service_path);
-  network_event_log::AddEntry(kLogModule, "Connected", service_path);
+  NET_LOG_EVENT("Connected", service_path);
   success_callback.Run();
 }
 
 void NetworkConnectionHandler::HandleShillFailure(
     const std::string& service_path,
     const network_handler::ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   pending_requests_.erase(service_path);
   std::string error = "Connect Failure: " + error_name + ": " + error_message;
   network_handler::ShillErrorCallbackFunction(
-      kLogModule, service_path, error_callback, error_name, error_message);
+      service_path, error_callback, error_name, error_message);
 }
 
 }  // namespace chromeos