Add NetworkingPrivateDelegate class

chrome/browser/extensions/api/networking_private/networking_private_service_client.cc

Index: chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc b/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
index 0a5870561e515845dd6dc45ef54a576b93ade2b4..790002eac84fccfb50fd27c8fe99cdeef6b7c39c 100644
--- a/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
+++ b/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
@@ -11,6 +11,7 @@
 #include "base/strings/string_util.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
 #include "chrome/common/extensions/api/networking_private.h"
 #include "chrome/common/extensions/api/networking_private/networking_private_crypto.h"
@@ -29,7 +30,7 @@ const char kNetworkingPrivateSequenceTokenName[] = "NetworkingPrivate";
 // Implementation of Verify* methods using NetworkingPrivateCrypto.
 // TODO(mef): Move this into NetworkingPrivateCrypto class.
 class CryptoVerifyImpl : public NetworkingPrivateServiceClient::CryptoVerify {
-  bool VerifyDestination(const VerificationProperties& properties) {
+  bool VerifyCredentials(const VerificationProperties& properties) {
     std::vector<std::string> data_parts;
     data_parts.push_back(properties.device_ssid);
     data_parts.push_back(properties.device_serial);
@@ -47,27 +48,29 @@ class CryptoVerifyImpl : public NetworkingPrivateServiceClient::CryptoVerify {
                                     properties.device_bssid);
   }
 
-  virtual void VerifyDestination(scoped_ptr<base::ListValue> args,
+  // CryptoVerify
+  virtual void VerifyDestination(scoped_ptr<base::DictionaryValue> properties,
                                  bool* verified,
                                  std::string* error) OVERRIDE {
-    using api::networking_private::VerifyDestination::Params;
-    scoped_ptr<Params> params = Params::Create(*args);
-    *verified = VerifyDestination(params->properties);
+    scoped_ptr<VerificationProperties> property_struct =
+        VerificationProperties::FromValue(*properties);
+    *verified = VerifyCredentials(*property_struct);
   }
 
   virtual void VerifyAndEncryptCredentials(
-      scoped_ptr<base::ListValue> args,
+      const std::string& network_guid,
+      scoped_ptr<base::DictionaryValue> properties,
       const VerifyAndEncryptCredentialsCallback& callback) OVERRIDE {
-    using api::networking_private::VerifyAndEncryptCredentials::Params;
-    scoped_ptr<Params> params = Params::Create(*args);
-    std::string public_key;
+    scoped_ptr<VerificationProperties> property_struct =
+        VerificationProperties::FromValue(*properties);

[mef, 2014/07/10 15:09:11]

Are |properties| just |VerificationProperties|? If so, should they be called
|verification_properties|?

[stevenjb, 2014/07/10 18:04:20]

Yes. Done. (They are called 'verification_properties' in the callers).

 
-    if (!VerifyDestination(params->properties)) {
+    if (!VerifyCredentials(*property_struct)) {
       callback.Run("", "VerifyError");
       return;
     }
 
-    if (!base::Base64Decode(params->properties.public_key, &public_key)) {
+    std::string public_key;
+    if (!base::Base64Decode(property_struct->public_key, &public_key)) {
       callback.Run("", "DecodeError");
       return;
     }
@@ -78,22 +81,24 @@ class CryptoVerifyImpl : public NetworkingPrivateServiceClient::CryptoVerify {
     // Start getting credentials. On Windows |callback| will be called
     // asynchronously on a different thread after |credentials_getter|
     // is deleted.
-    credentials_getter->Start(params->network_guid, public_key, callback);
+    credentials_getter->Start(network_guid, public_key, callback);
   }
 
-  virtual void VerifyAndEncryptData(scoped_ptr<base::ListValue> args,
-                                    std::string* base64_encoded_ciphertext,
-                                    std::string* error) OVERRIDE {
-    using api::networking_private::VerifyAndEncryptData::Params;
-    scoped_ptr<Params> params = Params::Create(*args);
+  virtual void VerifyAndEncryptData(
+      scoped_ptr<base::DictionaryValue> properties,
+      const std::string& data,
+      std::string* base64_encoded_ciphertext,
+      std::string* error) OVERRIDE {
+    scoped_ptr<VerificationProperties> property_struct =
+        VerificationProperties::FromValue(*properties);
 
-    if (!VerifyDestination(params->properties)) {
+    if (!VerifyCredentials(*property_struct)) {
       *error = "VerifyError";
       return;
     }
 
     std::string public_key;
-    if (!base::Base64Decode(params->properties.public_key, &public_key)) {
+    if (!base::Base64Decode(property_struct->public_key, &public_key)) {
       *error = "DecodeError";
       return;
     }
@@ -101,7 +106,7 @@ class CryptoVerifyImpl : public NetworkingPrivateServiceClient::CryptoVerify {
     NetworkingPrivateCrypto crypto;
     std::vector<uint8> public_key_data(public_key.begin(), public_key.end());
     std::vector<uint8> ciphertext;
-    if (!crypto.EncryptByteString(public_key_data, params->data, &ciphertext)) {
+    if (!crypto.EncryptByteString(public_key_data, data, &ciphertext)) {
       *error = "EncryptError";
       return;
     }
@@ -225,130 +230,103 @@ void NetworkingPrivateServiceClient::RemoveServiceCallbacks(
   callbacks_map_.Remove(callback_id);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 void NetworkingPrivateServiceClient::GetProperties(
-    const std::string& network_guid,
-    const DictionaryResultCallback& callback,
-    const ErrorCallback& error_callback) {
+    const std::string& guid,
+    const DictionaryCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->get_properties_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->get_properties_callback = success_callback;
 
-  base::DictionaryValue* properties = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::string* error = new std::string;
 
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&WiFiService::GetProperties,
                  base::Unretained(wifi_service_.get()),
-                 network_guid,
-                 properties,
+                 guid,
+                 properties.get(),
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
                  weak_factory_.GetWeakPtr(),
                  service_callbacks->id,
-                 network_guid,
-                 base::Owned(properties),
+                 guid,
+                 base::Passed(&properties),
                  base::Owned(error)));
 }
 
 void NetworkingPrivateServiceClient::GetManagedProperties(
-    const std::string& network_guid,
-    const DictionaryResultCallback& callback,
-    const ErrorCallback& error_callback) {
+    const std::string& guid,
+    const DictionaryCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->get_properties_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->get_properties_callback = success_callback;
 
-  base::DictionaryValue* properties = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::string* error = new std::string;
 
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&WiFiService::GetManagedProperties,
                  base::Unretained(wifi_service_.get()),
-                 network_guid,
-                 properties,
+                 guid,
+                 properties.get(),
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
                  weak_factory_.GetWeakPtr(),
                  service_callbacks->id,
-                 network_guid,
-                 base::Owned(properties),
+                 guid,
+                 base::Passed(&properties),
                  base::Owned(error)));
 }
 
 void NetworkingPrivateServiceClient::GetState(
-    const std::string& network_guid,
-    const DictionaryResultCallback& callback,
-    const ErrorCallback& error_callback) {
+    const std::string& guid,
+    const DictionaryCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->get_properties_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->get_properties_callback = success_callback;
 
-  base::DictionaryValue* properties = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::string* error = new std::string;
 
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&WiFiService::GetState,
                  base::Unretained(wifi_service_.get()),
-                 network_guid,
-                 properties,
+                 guid,
+                 properties.get(),
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
                  weak_factory_.GetWeakPtr(),
                  service_callbacks->id,
-                 network_guid,
-                 base::Owned(properties),
+                 guid,
+                 base::Passed(&properties),
                  base::Owned(error)));
 }
 
-void NetworkingPrivateServiceClient::GetVisibleNetworks(
-    const std::string& network_type,
-    const ListResultCallback& callback) {
-  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->get_visible_networks_callback = callback;
-
-  base::ListValue* networks = new base::ListValue();
-
-  task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&WiFiService::GetVisibleNetworks,
-                 base::Unretained(wifi_service_.get()),
-                 network_type,
-                 networks,
-                 false),
-      base::Bind(&NetworkingPrivateServiceClient::AfterGetVisibleNetworks,
-                 weak_factory_.GetWeakPtr(),
-                 service_callbacks->id,
-                 base::Owned(networks)));
-}
-
-void NetworkingPrivateServiceClient::RequestNetworkScan() {
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&WiFiService::RequestNetworkScan,
-                 base::Unretained(wifi_service_.get())));
-}
-
 void NetworkingPrivateServiceClient::SetProperties(
-    const std::string& network_guid,
-    const base::DictionaryValue& properties,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    const std::string& guid,
+    scoped_ptr<base::DictionaryValue> properties,
+    const VoidCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->set_properties_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->set_properties_callback = success_callback;
 
-  scoped_ptr<base::DictionaryValue> properties_ptr(properties.DeepCopy());
   std::string* error = new std::string;
 
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&WiFiService::SetProperties,
                  base::Unretained(wifi_service_.get()),
-                 network_guid,
-                 base::Passed(&properties_ptr),
+                 guid,
+                 base::Passed(&properties),
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterSetProperties,
                  weak_factory_.GetWeakPtr(),
@@ -358,14 +336,13 @@ void NetworkingPrivateServiceClient::SetProperties(
 
 void NetworkingPrivateServiceClient::CreateNetwork(
     bool shared,
-    const base::DictionaryValue& properties,
-    const StringResultCallback& callback,
-    const ErrorCallback& error_callback) {
+    scoped_ptr<base::DictionaryValue> properties,
+    const StringCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->create_network_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->create_network_callback = success_callback;
 
-  scoped_ptr<base::DictionaryValue> properties_ptr(properties.DeepCopy());
   std::string* network_guid = new std::string;
   std::string* error = new std::string;
 
@@ -374,7 +351,7 @@ void NetworkingPrivateServiceClient::CreateNetwork(
       base::Bind(&WiFiService::CreateNetwork,
                  base::Unretained(wifi_service_.get()),
                  shared,
-                 base::Passed(&properties_ptr),
+                 base::Passed(&properties),
                  network_guid,
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterCreateNetwork,
@@ -384,13 +361,41 @@ void NetworkingPrivateServiceClient::CreateNetwork(
                  base::Owned(error)));
 }
 
+void NetworkingPrivateServiceClient::GetNetworks(
+    const std::string& network_type,
+    bool configured_only,
+    bool visible_only,
+    int limit,
+    const NetworkListCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->get_visible_networks_callback = success_callback;
+
+  scoped_ptr<base::ListValue> networks(new base::ListValue);
+
+  // TODO(stevenjb/mef): Apply filters (configured, visible, limit).
+
+  task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&WiFiService::GetVisibleNetworks,
+                 base::Unretained(wifi_service_.get()),
+                 network_type,
+                 networks.get(),
+                 false),
+      base::Bind(&NetworkingPrivateServiceClient::AfterGetVisibleNetworks,
+                 weak_factory_.GetWeakPtr(),
+                 service_callbacks->id,
+                 base::Passed(&networks)));
+}
+
 void NetworkingPrivateServiceClient::StartConnect(
-    const std::string& network_guid,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    const std::string& guid,
+    const VoidCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->start_connect_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->start_connect_callback = success_callback;
 
   std::string* error = new std::string;
 
@@ -398,7 +403,7 @@ void NetworkingPrivateServiceClient::StartConnect(
       FROM_HERE,
       base::Bind(&WiFiService::StartConnect,
                  base::Unretained(wifi_service_.get()),
-                 network_guid,
+                 guid,
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterStartConnect,
                  weak_factory_.GetWeakPtr(),
@@ -407,12 +412,12 @@ void NetworkingPrivateServiceClient::StartConnect(
 }
 
 void NetworkingPrivateServiceClient::StartDisconnect(
-    const std::string& network_guid,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    const std::string& guid,
+    const VoidCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->error_callback = error_callback;
-  service_callbacks->start_disconnect_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->start_disconnect_callback = success_callback;
 
   std::string* error = new std::string;
 
@@ -420,7 +425,7 @@ void NetworkingPrivateServiceClient::StartDisconnect(
       FROM_HERE,
       base::Bind(&WiFiService::StartDisconnect,
                  base::Unretained(wifi_service_.get()),
-                 network_guid,
+                 guid,
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterStartDisconnect,
                  weak_factory_.GetWeakPtr(),
@@ -429,12 +434,12 @@ void NetworkingPrivateServiceClient::StartDisconnect(
 }
 
 void NetworkingPrivateServiceClient::VerifyDestination(
-    scoped_ptr<base::ListValue> args,
-    const BoolResultCallback& callback,
-    const CryptoErrorCallback& error_callback) {
+    scoped_ptr<base::DictionaryValue> verification_properties,
+    const BoolCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->crypto_error_callback = error_callback;
-  service_callbacks->verify_destination_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->verify_destination_callback = success_callback;
 
   bool* result = new bool;
   std::string* error = new std::string;
@@ -443,7 +448,7 @@ void NetworkingPrivateServiceClient::VerifyDestination(
       FROM_HERE,
       base::Bind(&CryptoVerify::VerifyDestination,
                  base::Unretained(crypto_verify_.get()),
-                 base::Passed(&args),
+                 base::Passed(&verification_properties),
                  result,
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterVerifyDestination,
@@ -454,12 +459,13 @@ void NetworkingPrivateServiceClient::VerifyDestination(
 }
 
 void NetworkingPrivateServiceClient::VerifyAndEncryptCredentials(
-    scoped_ptr<base::ListValue> args,
-    const StringResultCallback& callback,
-    const CryptoErrorCallback& error_callback) {
+    const std::string& guid,
+    scoped_ptr<base::DictionaryValue> verification_properties,
+    const StringCallback& success_callback,
+    const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->crypto_error_callback = error_callback;
-  service_callbacks->verify_and_encrypt_credentials_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->verify_and_encrypt_credentials_callback = success_callback;
 
   CryptoVerify::VerifyAndEncryptCredentialsCallback callback_relay(base::Bind(
       &AfterVerifyAndEncryptCredentialsRelay,
@@ -472,17 +478,19 @@ void NetworkingPrivateServiceClient::VerifyAndEncryptCredentials(
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&CryptoVerify::VerifyAndEncryptCredentials,
                                     base::Unretained(crypto_verify_.get()),
-                                    base::Passed(&args),
+                                    guid,
+                                    base::Passed(&verification_properties),
                                     callback_relay));
 }
 
 void NetworkingPrivateServiceClient::VerifyAndEncryptData(
-    scoped_ptr<base::ListValue> args,
-    const StringResultCallback& callback,
-    const CryptoErrorCallback& error_callback) {
+      scoped_ptr<base::DictionaryValue> verification_properties,
+      const std::string& data,
+      const StringCallback& success_callback,
+      const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
-  service_callbacks->crypto_error_callback = error_callback;
-  service_callbacks->verify_and_encrypt_data_callback = callback;
+  service_callbacks->failure_callback = failure_callback;
+  service_callbacks->verify_and_encrypt_data_callback = success_callback;
 
   std::string* result = new std::string;
   std::string* error = new std::string;
@@ -491,7 +499,8 @@ void NetworkingPrivateServiceClient::VerifyAndEncryptData(
       FROM_HERE,
       base::Bind(&CryptoVerify::VerifyAndEncryptData,
                  base::Unretained(crypto_verify_.get()),
-                 base::Passed(&args),
+                 base::Passed(&verification_properties),
+                 data,
                  result,
                  error),
       base::Bind(&NetworkingPrivateServiceClient::AfterVerifyAndEncryptData,
@@ -501,31 +510,78 @@ void NetworkingPrivateServiceClient::VerifyAndEncryptData(
                  base::Owned(error)));
 }
 
+void NetworkingPrivateServiceClient::SetWifiTDLSEnabledState(
+    const std::string& ip_or_mac_address,
+    bool enabled,
+    const StringCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  failure_callback.Run(networking_private::kErrorNotSupported);
+}
+
+void NetworkingPrivateServiceClient::GetWifiTDLSStatus(
+    const std::string& ip_or_mac_address,
+    const StringCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  failure_callback.Run(networking_private::kErrorNotSupported);
+}
+
+void NetworkingPrivateServiceClient::GetCaptivePortalStatus(
+    const std::string& guid,
+    const StringCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  failure_callback.Run(networking_private::kErrorNotSupported);
+}
+
+scoped_ptr<base::ListValue>
+NetworkingPrivateServiceClient::GetEnabledNetworkTypes() {
+  scoped_ptr<base::ListValue> network_list(new base::ListValue);
+  return network_list.Pass();
+}
+
+bool NetworkingPrivateServiceClient::EnableNetworkType(
+    const std::string& type) {
+  return false;
+}
+
+bool NetworkingPrivateServiceClient::DisableNetworkType(
+    const std::string& type) {
+  return false;
+}
+
+bool NetworkingPrivateServiceClient::RequestScan() {
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&WiFiService::RequestNetworkScan,
+                 base::Unretained(wifi_service_.get())));
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 void NetworkingPrivateServiceClient::AfterGetProperties(
     ServiceCallbacksID callback_id,
     const std::string& network_guid,
-    const base::DictionaryValue* properties,
+    scoped_ptr<base::DictionaryValue> properties,
     const std::string* error) {
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->error_callback.is_null());
-    service_callbacks->error_callback.Run(*error,
-                                          scoped_ptr<base::DictionaryValue>());
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->get_properties_callback.is_null());
-    service_callbacks->get_properties_callback.Run(network_guid, *properties);
+    service_callbacks->get_properties_callback.Run(properties.Pass());
   }
   RemoveServiceCallbacks(callback_id);
 }
 
 void NetworkingPrivateServiceClient::AfterGetVisibleNetworks(
     ServiceCallbacksID callback_id,
-    const base::ListValue* networks) {
+    scoped_ptr<base::ListValue> networks) {
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   DCHECK(!service_callbacks->get_visible_networks_callback.is_null());
-  service_callbacks->get_visible_networks_callback.Run(*networks);
+  service_callbacks->get_visible_networks_callback.Run(networks.Pass());
   RemoveServiceCallbacks(callback_id);
 }
 
@@ -535,9 +591,8 @@ void NetworkingPrivateServiceClient::AfterSetProperties(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->error_callback.is_null());
-    service_callbacks->error_callback.Run(*error,
-                                          scoped_ptr<base::DictionaryValue>());
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->set_properties_callback.is_null());
     service_callbacks->set_properties_callback.Run();
@@ -552,9 +607,8 @@ void NetworkingPrivateServiceClient::AfterCreateNetwork(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->error_callback.is_null());
-    service_callbacks->error_callback.Run(*error,
-                                          scoped_ptr<base::DictionaryValue>());
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->create_network_callback.is_null());
     service_callbacks->create_network_callback.Run(*network_guid);
@@ -568,9 +622,8 @@ void NetworkingPrivateServiceClient::AfterStartConnect(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->error_callback.is_null());
-    service_callbacks->error_callback.Run(*error,
-                                          scoped_ptr<base::DictionaryValue>());
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->start_connect_callback.is_null());
     service_callbacks->start_connect_callback.Run();
@@ -584,9 +637,8 @@ void NetworkingPrivateServiceClient::AfterStartDisconnect(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->error_callback.is_null());
-    service_callbacks->error_callback.Run(*error,
-                                          scoped_ptr<base::DictionaryValue>());
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->start_disconnect_callback.is_null());
     service_callbacks->start_disconnect_callback.Run();
@@ -601,8 +653,8 @@ void NetworkingPrivateServiceClient::AfterVerifyDestination(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->crypto_error_callback.is_null());
-    service_callbacks->crypto_error_callback.Run(*error, *error);
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->verify_destination_callback.is_null());
     service_callbacks->verify_destination_callback.Run(*result);
@@ -618,8 +670,8 @@ void NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error.empty()) {
-    DCHECK(!service_callbacks->crypto_error_callback.is_null());
-    service_callbacks->crypto_error_callback.Run(error, error);
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(error);
   } else {
     DCHECK(
         !service_callbacks->verify_and_encrypt_credentials_callback.is_null());
@@ -636,8 +688,8 @@ void NetworkingPrivateServiceClient::AfterVerifyAndEncryptData(
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
-    DCHECK(!service_callbacks->crypto_error_callback.is_null());
-    service_callbacks->crypto_error_callback.Run(*error, *error);
+    DCHECK(!service_callbacks->failure_callback.is_null());
+    service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->verify_and_encrypt_data_callback.is_null());
     service_callbacks->verify_and_encrypt_data_callback.Run(*result);