Re-factor network_event_log

chromeos/network/shill_property_handler.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/shill_property_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
-const char kLogModule[] = "ShillPropertyHandler";
-
 // Limit the number of services or devices we observe. Since they are listed in
 // priority order, it should be reasonable to ignore services past this.
 const size_t kMaxObserved = 100;
 
 const base::ListValue* GetListValue(const std::string& key,
                                     const base::Value& value) {
   const base::ListValue* vlist = NULL;
   if (!value.GetAsList(&vlist)) {
     LOG(ERROR) << "Error parsing key as list: " << key;
     return NULL;
@@ skipping 116 matching lines @@
         base::Bind(&ShillPropertyHandler::EnableTechnologyFailed,
                    AsWeakPtr(), technology, error_callback));
   } else {
     // Imediately clear locally from enabled and enabling lists.
     enabled_technologies_.erase(technology);
     enabling_technologies_.erase(technology);
     shill_manager_->DisableTechnology(
         technology,
         base::Bind(&base::DoNothing),
         base::Bind(&network_handler::ShillErrorCallbackFunction,
-                   kLogModule, technology, error_callback));
+                   technology, error_callback));
   }
 }
 
 void ShillPropertyHandler::RequestScan() const {
   shill_manager_->RequestScan(
       "",
       base::Bind(&base::DoNothing),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
-                 kLogModule, "", network_handler::ErrorCallback()));
+                 "", network_handler::ErrorCallback()));
 }
 
 void ShillPropertyHandler::ConnectToBestServices() const {
-  network_event_log::AddEntry(kLogModule, "ConnectToBestServices", "");
+  NET_LOG_EVENT("ConnectToBestServices", "");
   shill_manager_->ConnectToBestServices(
       base::Bind(&base::DoNothing),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
-                 kLogModule, "", network_handler::ErrorCallback()));
+                 "", network_handler::ErrorCallback()));
 }
 
 void ShillPropertyHandler::RequestProperties(ManagedState::ManagedType type,
                                              const std::string& path) {
   if (pending_updates_[type].find(path) != pending_updates_[type].end())
     return;  // Update already requested.
 
   pending_updates_[type].insert(path);
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
         dbus::ObjectPath(path),
         base::Bind(&ShillPropertyHandler::GetPropertiesCallback,
                    AsWeakPtr(), type, path));
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     DBusThreadManager::Get()->GetShillDeviceClient()->GetProperties(
         dbus::ObjectPath(path),
         base::Bind(&ShillPropertyHandler::GetPropertiesCallback,
                    AsWeakPtr(), type, path));
   } else {
     NOTREACHED();
   }
 }
 
 void ShillPropertyHandler::OnPropertyChanged(const std::string& key,
                                              const base::Value& value) {
-  if (ManagerPropertyChanged(key, value))
-    listener_->ManagerPropertyChanged();
+  if (ManagerPropertyChanged(key, value)) {
+    std::string detail = key;
+    std::string vstr = network_event_log::DBusValueAsString(value);
+    if (!vstr.empty())
+      detail += " = " + vstr;
+    NET_LOG_DEBUG("ManagerPropertyChanged", detail);
+    listener_->NotifyManagerPropertyChanged();
+  }
   // If the service watch or device list changed and there are no pending
   // updates, signal the state list changed callback.
   if ((key == flimflam::kServiceWatchListProperty) &&
       pending_updates_[ManagedState::MANAGED_TYPE_NETWORK].size() == 0) {
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_NETWORK);
   }
   if (key == flimflam::kDevicesProperty &&
       pending_updates_[ManagedState::MANAGED_TYPE_DEVICE].size() == 0) {
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_DEVICE);
   }
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
 void ShillPropertyHandler::ManagerPropertiesCallback(
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties) {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
-    LOG(ERROR) << "Failed to get Manager properties:" << call_status;
+    NET_LOG_ERROR("ManagerPropertiesCallback",
+                  base::StringPrintf("Failed: %d", call_status));
     return;
   }
+  NET_LOG_EVENT("ManagerPropertiesCallback", "Success");
   bool notify = false;
   bool update_service_list = false;
   for (base::DictionaryValue::Iterator iter(properties);
        !iter.IsAtEnd(); iter.Advance()) {
     // Defer updating Services until all other properties have been updated.
     if (iter.key() == flimflam::kServicesProperty)
       update_service_list = true;
     else
       notify |= ManagerPropertyChanged(iter.key(), iter.value());
   }
   // Now update the service list which can safely assume other properties have
   // been initially set.
   if (update_service_list) {
     const base::Value* value = NULL;
     if (properties.GetWithoutPathExpansion(flimflam::kServicesProperty, &value))
       notify |= ManagerPropertyChanged(flimflam::kServicesProperty, *value);
   }
   if (notify)
-    listener_->ManagerPropertyChanged();
+    listener_->NotifyManagerPropertyChanged();
   // If there are no pending updates, signal the state list changed callbacks.
   if (pending_updates_[ManagedState::MANAGED_TYPE_NETWORK].size() == 0)
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_NETWORK);
   if (pending_updates_[ManagedState::MANAGED_TYPE_DEVICE].size() == 0)
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_DEVICE);
 }
 
 bool ShillPropertyHandler::ManagerPropertyChanged(const std::string& key,
                                                   const base::Value& value) {
   bool notify_manager_changed = false;
@@ skipping 51 matching lines @@
     ShillPropertyObserverMap::iterator iter2 = observer_map.find(path);
     if (iter2 != observer_map.end()) {
       new_observed[path] = iter2->second;
     } else {
       // Request an update.
       RequestProperties(type, path);
       // Create an observer for future updates.
       new_observed[path] = new ShillPropertyObserver(
           type, path, base::Bind(
               &ShillPropertyHandler::PropertyChangedCallback, AsWeakPtr()));
-      network_event_log::AddEntry(kLogModule, "StartObserving", path);
+      NET_LOG_DEBUG("StartObserving", path);
     }
     observer_map.erase(path);
     // Limit the number of observed services.
     if (new_observed.size() >= kMaxObserved)
       break;
   }
   // Delete network service observers still in observer_map.
   for (ShillPropertyObserverMap::iterator iter =  observer_map.begin();
        iter != observer_map.end(); ++iter) {
-    network_event_log::AddEntry(kLogModule, "StopObserving", iter->first);
+    NET_LOG_DEBUG("StopObserving", iter->first);
     delete iter->second;
   }
   observer_map.swap(new_observed);
 }
 
 void ShillPropertyHandler::UpdateAvailableTechnologies(
     const base::ListValue& technologies) {
   available_technologies_.clear();
-  network_event_log::AddEntry(
-      kLogModule, "AvailableTechnologiesChanged",
-      base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
+  NET_LOG_EVENT("AvailableTechnologiesChanged",
+                base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     available_technologies_.insert(technology);
   }
 }
 
 void ShillPropertyHandler::UpdateEnabledTechnologies(
     const base::ListValue& technologies) {
   enabled_technologies_.clear();
-  network_event_log::AddEntry(
-      kLogModule, "EnabledTechnologiesChanged",
-      base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
+  NET_LOG_EVENT("EnabledTechnologiesChanged",
+                base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     enabled_technologies_.insert(technology);
     enabling_technologies_.erase(technology);
   }
 }
 
 void ShillPropertyHandler::UpdateUninitializedTechnologies(
     const base::ListValue& technologies) {
   uninitialized_technologies_.clear();
-  network_event_log::AddEntry(
-      kLogModule, "UninitializedTechnologiesChanged",
-      base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
+  NET_LOG_EVENT("UninitializedTechnologiesChanged",
+                base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     uninitialized_technologies_.insert(technology);
   }
 }
 
 void ShillPropertyHandler::EnableTechnologyFailed(
     const std::string& technology,
     const network_handler::ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   enabling_technologies_.erase(technology);
   network_handler::ShillErrorCallbackFunction(
-      kLogModule, technology, error_callback, error_name, error_message);
+      technology, error_callback, error_name, error_message);
 }
 
 void ShillPropertyHandler::GetPropertiesCallback(
     ManagedState::ManagedType type,
     const std::string& path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties) {
   VLOG(2) << "GetPropertiesCallback: " << type << " : " << path;
   pending_updates_[type].erase(path);
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
@@ skipping 85 matching lines @@
 
 void ShillPropertyHandler::NetworkDevicePropertyChangedCallback(
     const std::string& path,
     const std::string& key,
     const base::Value& value) {
   listener_->UpdateDeviceProperty(path, key, value);
 }
 
 }  // namespace internal
 }  // namespace chromeos