Add network_handler_callbacks.cc

This does some cleanup to allow NetworkStateHandler to use the same error callback infrastructure as NetworkConfigurationHandler.
It also adds event logging for errors.

BUG=none

Review URL: https://codereview.chromium.org/11416149

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@169475 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 37 insertions, 65 deletions

diff --git a/chromeos/network/network_configuration_handler.cc b/chromeos/network/network_configuration_handler.cc
index 8fb6832..56ee934 100644
--- a/chromeos/network/network_configuration_handler.cc
+++ b/chromeos/network/network_configuration_handler.cc
@@ -22,6 +22,8 @@ namespace chromeos {
 
 namespace {
 
+const char kLogModule[] = "NetworkConfigurationHandler";
+
 // None of these error messages are user-facing: they should only appear in
 // logs.
 const char kErrorsListTag[] = "errors";
@@ -30,31 +32,11 @@ const char kClearPropertiesFailedErrorMessage[] = "Clear properties failed";
 const char kDBusFailedError[] = "Error.DBusFailed";
 const char kDBusFailedErrorMessage[] = "DBus call failed.";
 
-// These are names of fields in the error data returned through the error
-// callbacks.
-const char kErrorName[] = "errorName";
-const char kErrorMessage[] = "errorMessage";
-const char kServicePath[] = "servicePath";
-
-base::DictionaryValue* CreateErrorData(const std::string& service_path,
-                                       const std::string& error_name,
-                                       const std::string& error_message) {
-  scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
-  error_data->SetString(kErrorName, error_name);
-  error_data->SetString(kErrorMessage, error_message);
-  if (!service_path.empty())
-    error_data->SetString(kServicePath, service_path);
-  LOG(ERROR) << "NetworkConfigurationHandler Received an error("
-             << error_name << ") for service path '" << service_path << "':"
-             << error_message;
-  return error_data.release();
-}
-
 void ClearPropertiesCallback(
     const std::vector<std::string>& names,
     const std::string& service_path,
     const base::Closure& callback,
-    const NetworkHandlerErrorCallback& error_callback,
+    const network_handler::ErrorCallback& error_callback,
     const base::ListValue& result) {
   bool some_failed = false;
   for (size_t i = 0; i < result.GetSize(); ++i) {
@@ -73,9 +55,11 @@ void ClearPropertiesCallback(
     DCHECK(names.size() == result.GetSize())
         << "Result wrong size from ClearProperties.";
     scoped_ptr<base::DictionaryValue> error_data(
-        CreateErrorData(service_path,
-                        kClearPropertiesFailedError,
-                        kClearPropertiesFailedErrorMessage));
+        network_handler::CreateErrorData(service_path,
+                                         kClearPropertiesFailedError,
+                                         kClearPropertiesFailedErrorMessage));
+    LOG(ERROR) << "ClearPropertiesCallback Failed for service path: "
+               << service_path;
     error_data->Set("errors", result.DeepCopy());
     scoped_ptr<base::ListValue> name_list(new base::ListValue);
     name_list->AppendStrings(names);
@@ -86,47 +70,29 @@ void ClearPropertiesCallback(
   }
 }
 
-void ClearPropertiesErrorCallback(
-    const std::string& service_path,
-    const NetworkHandlerErrorCallback& error_callback,
-    const std::string& error_name,
-    const std::string& error_message) {
-  // Add a new error.
-  scoped_ptr<base::DictionaryValue> error_data(
-      CreateErrorData(service_path, error_name, error_message));
-  error_callback.Run(kClearPropertiesFailedError, error_data.Pass());
-}
-
 // Used to translate the dbus dictionary callback into one that calls
 // the error callback if we have a failure.
 void RunCallbackWithDictionaryValue(
-    const NetworkHandlerDictionaryResultCallback& callback,
-    const NetworkHandlerErrorCallback& error_callback,
+    const network_handler::DictionaryResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& value) {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
     scoped_ptr<base::DictionaryValue> error_data(
-        CreateErrorData(service_path,
-                        kDBusFailedError,
-                        kDBusFailedErrorMessage));
+        network_handler::CreateErrorData(service_path,
+                                         kDBusFailedError,
+                                         kDBusFailedErrorMessage));
+    LOG(ERROR) << "CallbackWithDictionaryValue Failed for service path: "
+               << service_path;
     error_callback.Run(kDBusFailedError, error_data.Pass());
   } else {
     callback.Run(service_path, value);
   }
 }
 
-void RunErrorCallback(const std::string& service_path,
-                      const NetworkHandlerErrorCallback& error_callback,
-                      const std::string& error_name,
-                      const std::string& error_message) {
-  scoped_ptr<base::DictionaryValue> error_dict(
-      CreateErrorData(service_path, error_name, error_message));
-  error_callback.Run(error_name, error_dict.Pass());
-}
-
 void RunCreateNetworkCallback(
-    const NetworkHandlerStringResultCallback& callback,
+    const network_handler::StringResultCallback& callback,
     const dbus::ObjectPath& service_path) {
   callback.Run(service_path.value());
 }
@@ -141,8 +107,8 @@ NetworkConfigurationHandler::~NetworkConfigurationHandler() {
 
 void NetworkConfigurationHandler::GetProperties(
     const std::string& service_path,
-    const NetworkHandlerDictionaryResultCallback& callback,
-    const NetworkHandlerErrorCallback& error_callback) const {
+    const network_handler::DictionaryResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback) const {
   DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
       dbus::ObjectPath(service_path),
       base::Bind(&RunCallbackWithDictionaryValue,
@@ -155,18 +121,19 @@ void NetworkConfigurationHandler::SetProperties(
     const std::string& service_path,
     const base::DictionaryValue& properties,
     const base::Closure& callback,
-    const NetworkHandlerErrorCallback& error_callback) const {
+    const network_handler::ErrorCallback& error_callback) const {
   DBusThreadManager::Get()->GetShillManagerClient()->ConfigureService(
       properties,
       callback,
-      base::Bind(&RunErrorCallback, service_path, error_callback));
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, service_path, error_callback));
 }
 
 void NetworkConfigurationHandler::ClearProperties(
     const std::string& service_path,
     const std::vector<std::string>& names,
     const base::Closure& callback,
-    const NetworkHandlerErrorCallback& error_callback) {
+    const network_handler::ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetShillServiceClient()->ClearProperties(
       dbus::ObjectPath(service_path),
       names,
@@ -175,47 +142,52 @@ void NetworkConfigurationHandler::ClearProperties(
                  service_path,
                  callback,
                  error_callback),
-      base::Bind(&ClearPropertiesErrorCallback, service_path, error_callback));
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, service_path, error_callback));
 }
 
 void NetworkConfigurationHandler::Connect(
     const std::string& service_path,
     const base::Closure& callback,
-    const NetworkHandlerErrorCallback& error_callback) const {
+    const network_handler::ErrorCallback& error_callback) const {
   DBusThreadManager::Get()->GetShillServiceClient()->Connect(
       dbus::ObjectPath(service_path),
       callback,
-      base::Bind(&RunErrorCallback, service_path, error_callback));
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, service_path, error_callback));
 }
 
 void NetworkConfigurationHandler::Disconnect(
     const std::string& service_path,
     const base::Closure& callback,
-    const NetworkHandlerErrorCallback& error_callback) const {
+    const network_handler::ErrorCallback& error_callback) const {
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path),
       callback,
-      base::Bind(&RunErrorCallback, service_path, error_callback));
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, service_path, error_callback));
 }
 
 void NetworkConfigurationHandler::CreateConfiguration(
     const base::DictionaryValue& properties,
-    const NetworkHandlerStringResultCallback& callback,
-    const NetworkHandlerErrorCallback& error_callback) const {
+    const network_handler::StringResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback) const {
   DBusThreadManager::Get()->GetShillManagerClient()->GetService(
       properties,
       base::Bind(&RunCreateNetworkCallback, callback),
-      base::Bind(&RunErrorCallback, "", error_callback));
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, "", error_callback));
 }
 
 void NetworkConfigurationHandler::RemoveConfiguration(
     const std::string& service_path,
     const base::Closure& callback,
-    const NetworkHandlerErrorCallback& error_callback) const {
+    const network_handler::ErrorCallback& error_callback) const {
   DBusThreadManager::Get()->GetShillServiceClient()->Remove(
       dbus::ObjectPath(service_path),
       callback,
-      base::Bind(&RunErrorCallback, service_path, error_callback));
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, service_path, error_callback));
 }
 
 }  // namespace chromeos