#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_crypto.h"
+#include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
#include "chrome/common/extensions/api/networking_private.h"
#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/utility_process_host.h"
using content::BrowserThread;
-using extensions::api::networking_private::VerificationProperties;
namespace extensions {
namespace {
-const char kNetworkingPrivateServiceClient[] = "NetworkingPrivateServiceClient";
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) {
- std::vector<std::string> data_parts;
- data_parts.push_back(properties.device_ssid);
- data_parts.push_back(properties.device_serial);
- data_parts.push_back(properties.device_bssid);
- data_parts.push_back(properties.public_key);
- data_parts.push_back(properties.nonce);
- std::string unsigned_data = JoinString(data_parts, ",");
- std::string signed_data;
- if (!base::Base64Decode(properties.signed_data, &signed_data))
- return false;
- NetworkingPrivateCrypto crypto;
- return crypto.VerifyCredentials(properties.certificate,
- signed_data,
- unsigned_data,
- properties.device_bssid);
+bool GetVerificationCredentials(
+ const NetworkingPrivateDelegate::VerificationProperties& properties,
+ NetworkingPrivateServiceClient::CryptoVerify::Credentials* credentials) {
+ std::vector<std::string> data_parts;
+ data_parts.push_back(properties.device_ssid);
+ data_parts.push_back(properties.device_serial);
+ data_parts.push_back(properties.device_bssid);
+ data_parts.push_back(properties.public_key);
+ data_parts.push_back(properties.nonce);
+ credentials->unsigned_data = JoinString(data_parts, ",");
+ if (!base::Base64Decode(properties.signed_data, &credentials->signed_data)) {
+ LOG(ERROR) << "Failed to decode signed data: " << properties.signed_data;
+ return false;
}
-
- virtual void VerifyDestination(scoped_ptr<base::ListValue> args,
- bool* verified,
- std::string* error) OVERRIDE {
- using extensions::api::networking_private::VerifyDestination::Params;
- scoped_ptr<Params> params = Params::Create(*args);
- *verified = VerifyDestination(params->properties);
- }
-
- virtual void VerifyAndEncryptData(scoped_ptr<base::ListValue> args,
- std::string* base64_encoded_ciphertext,
- std::string* error) OVERRIDE {
- using extensions::api::networking_private::VerifyAndEncryptData::Params;
- scoped_ptr<Params> params = Params::Create(*args);
-
- if (!VerifyDestination(params->properties)) {
- *error = "VerifyError";
- return;
- }
-
- std::string public_key;
- if (!base::Base64Decode(params->properties.public_key, &public_key)) {
- *error = "DecodeError";
- return;
- }
-
- NetworkingPrivateCrypto crypto;
- std::string ciphertext;
- if (!crypto.EncryptByteString(public_key, params->data, &ciphertext)) {
- *error = "EncryptError";
- return;
- }
-
- base::Base64Encode(ciphertext, base64_encoded_ciphertext);
+ credentials->certificate = properties.certificate;
+ credentials->device_bssid = properties.device_bssid;
+ if (!base::Base64Decode(properties.public_key, &credentials->public_key)) {
+ LOG(ERROR) << "Failed to decode public key";
+ return false;
}
-};
+ return true;
+}
// Deletes WiFiService and CryptoVerify objects on worker thread.
void ShutdownServicesOnWorkerThread(
DCHECK(crypto_verify.get());
}
+// Forwards call back from VerifyAndEncryptCredentials on random thread to
+// |callback| on correct |callback_loop_proxy|.
+void AfterVerifyAndEncryptCredentialsRelay(
+ const NetworkingPrivateServiceClient::CryptoVerify::
+ VerifyAndEncryptCredentialsCallback& callback,
+ scoped_refptr<base::MessageLoopProxy> callback_loop_proxy,
+ const std::string& key_data,
+ const std::string& error) {
+ callback_loop_proxy->PostTask(FROM_HERE,
+ base::Bind(callback, key_data, error));
+}
+
} // namespace
+NetworkingPrivateServiceClient::CryptoVerify::CryptoVerify() {}
+NetworkingPrivateServiceClient::CryptoVerify::~CryptoVerify() {}
+
+NetworkingPrivateServiceClient::CryptoVerify::Credentials::Credentials() {}
+NetworkingPrivateServiceClient::CryptoVerify::Credentials::~Credentials() {}
+
NetworkingPrivateServiceClient::NetworkingPrivateServiceClient(
wifi::WiFiService* wifi_service,
CryptoVerify* crypto_verify)
task_runner_->PostTask(
FROM_HERE,
base::Bind(
+ &WiFiService::Initialize,
+ base::Unretained(wifi_service_.get()),
+ task_runner_));
+ task_runner_->PostTask(
+ FROM_HERE,
+ base::Bind(
&WiFiService::SetEventObservers,
base::Unretained(wifi_service_.get()),
base::MessageLoopProxy::current(),
&NetworkingPrivateServiceClient::
OnNetworkListChangedEventOnUIThread,
weak_factory_.GetWeakPtr())));
- task_runner_->PostTask(
- FROM_HERE,
- base::Bind(
- &WiFiService::Initialize,
- base::Unretained(wifi_service_.get()),
- task_runner_));
+ net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
}
NetworkingPrivateServiceClient::~NetworkingPrivateServiceClient() {
DCHECK(!crypto_verify_.get());
}
-NetworkingPrivateServiceClient::CryptoVerify*
- NetworkingPrivateServiceClient::CryptoVerify::Create() {
- return new CryptoVerifyImpl();
-}
-
NetworkingPrivateServiceClient::ServiceCallbacks::ServiceCallbacks() {}
NetworkingPrivateServiceClient::ServiceCallbacks::~ServiceCallbacks() {}
void NetworkingPrivateServiceClient::Shutdown() {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+ net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
// Clear callbacks map to release callbacks from UI thread.
callbacks_map_.Clear();
// Post ShutdownServicesOnWorkerThread task to delete services when all posted
network_events_observers_.RemoveObserver(observer);
}
+void NetworkingPrivateServiceClient::OnNetworkChanged(
+ net::NetworkChangeNotifier::ConnectionType type) {
+ task_runner_->PostTask(
+ FROM_HERE,
+ base::Bind(&WiFiService::RequestConnectedNetworkUpdate,
+ base::Unretained(wifi_service_.get())));
+}
+
NetworkingPrivateServiceClient::ServiceCallbacks*
NetworkingPrivateServiceClient::AddServiceCallbacks() {
ServiceCallbacks* service_callbacks = new ServiceCallbacks();
callbacks_map_.Remove(callback_id);
}
+// NetworkingPrivateServiceClient implementation
+
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),
- 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(),
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;
base::Bind(&WiFiService::CreateNetwork,
base::Unretained(wifi_service_.get()),
shared,
- base::Passed(&properties_ptr),
+ base::Passed(&properties),
network_guid,
error),
base::Bind(&NetworkingPrivateServiceClient::AfterCreateNetwork,
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;
FROM_HERE,
base::Bind(&WiFiService::StartConnect,
base::Unretained(wifi_service_.get()),
- network_guid,
+ guid,
error),
base::Bind(&NetworkingPrivateServiceClient::AfterStartConnect,
weak_factory_.GetWeakPtr(),
}
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;
FROM_HERE,
base::Bind(&WiFiService::StartDisconnect,
base::Unretained(wifi_service_.get()),
- network_guid,
+ guid,
error),
base::Bind(&NetworkingPrivateServiceClient::AfterStartDisconnect,
weak_factory_.GetWeakPtr(),
}
void NetworkingPrivateServiceClient::VerifyDestination(
- scoped_ptr<base::ListValue> args,
- const BoolResultCallback& callback,
- const CryptoErrorCallback& error_callback) {
+ const VerificationProperties& verification_properties,
+ const BoolCallback& success_callback,
+ const FailureCallback& failure_callback) {
+ if (!crypto_verify_) {
+ failure_callback.Run(networking_private::kErrorNotSupported);
+ return;
+ }
+
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;
+
+ CryptoVerify::Credentials credentials;
+ if (!GetVerificationCredentials(verification_properties, &credentials)) {
+ failure_callback.Run(networking_private::kErrorEncryptionError);
+ return;
+ }
bool* result = new bool;
std::string* error = new std::string;
FROM_HERE,
base::Bind(&CryptoVerify::VerifyDestination,
base::Unretained(crypto_verify_.get()),
- base::Passed(&args),
+ credentials,
result,
error),
base::Bind(&NetworkingPrivateServiceClient::AfterVerifyDestination,
base::Owned(error)));
}
+void NetworkingPrivateServiceClient::VerifyAndEncryptCredentials(
+ const std::string& guid,
+ const VerificationProperties& verification_properties,
+ const StringCallback& success_callback,
+ const FailureCallback& failure_callback) {
+ if (!crypto_verify_) {
+ failure_callback.Run(networking_private::kErrorNotSupported);
+ return;
+ }
+
+ ServiceCallbacks* service_callbacks = AddServiceCallbacks();
+ service_callbacks->failure_callback = failure_callback;
+ service_callbacks->verify_and_encrypt_credentials_callback = success_callback;
+
+ CryptoVerify::Credentials credentials;
+ if (!GetVerificationCredentials(verification_properties, &credentials)) {
+ failure_callback.Run(networking_private::kErrorEncryptionError);
+ return;
+ }
+
+ CryptoVerify::VerifyAndEncryptCredentialsCallback callback_relay(base::Bind(
+ &AfterVerifyAndEncryptCredentialsRelay,
+ base::Bind(
+ &NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials,
+ weak_factory_.GetWeakPtr(),
+ service_callbacks->id),
+ base::MessageLoopProxy::current()));
+
+ task_runner_->PostTask(FROM_HERE,
+ base::Bind(&CryptoVerify::VerifyAndEncryptCredentials,
+ base::Unretained(crypto_verify_.get()),
+ guid,
+ credentials,
+ callback_relay));
+}
+
void NetworkingPrivateServiceClient::VerifyAndEncryptData(
- scoped_ptr<base::ListValue> args,
- const StringResultCallback& callback,
- const CryptoErrorCallback& error_callback) {
+ const VerificationProperties& verification_properties,
+ const std::string& data,
+ const StringCallback& success_callback,
+ const FailureCallback& failure_callback) {
+ if (!crypto_verify_) {
+ failure_callback.Run(networking_private::kErrorNotSupported);
+ return;
+ }
+
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;
+
+ CryptoVerify::Credentials credentials;
+ if (!GetVerificationCredentials(verification_properties, &credentials)) {
+ failure_callback.Run(networking_private::kErrorEncryptionError);
+ return;
+ }
std::string* result = new std::string;
std::string* error = new std::string;
FROM_HERE,
base::Bind(&CryptoVerify::VerifyAndEncryptData,
base::Unretained(crypto_verify_.get()),
- base::Passed(&args),
+ credentials,
+ data,
result,
error),
base::Bind(&NetworkingPrivateServiceClient::AfterVerifyAndEncryptData,
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;
+ 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);
}
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();
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);
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();
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();
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);
RemoveServiceCallbacks(callback_id);
}
+void NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials(
+ ServiceCallbacksID callback_id,
+ const std::string& encrypted_data,
+ const std::string& error) {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+ ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
+ DCHECK(service_callbacks);
+ if (!error.empty()) {
+ DCHECK(!service_callbacks->failure_callback.is_null());
+ service_callbacks->failure_callback.Run(error);
+ } else {
+ DCHECK(
+ !service_callbacks->verify_and_encrypt_credentials_callback.is_null());
+ service_callbacks->verify_and_encrypt_credentials_callback.Run(
+ encrypted_data);
+ }
+ RemoveServiceCallbacks(callback_id);
+}
+
void NetworkingPrivateServiceClient::AfterVerifyAndEncryptData(
ServiceCallbacksID callback_id,
const std::string* result,
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);
void NetworkingPrivateServiceClient::OnNetworksChangedEventOnUIThread(
const std::vector<std::string>& network_guids) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
FOR_EACH_OBSERVER(Observer,
network_events_observers_,
OnNetworksChangedEvent(network_guids));
void NetworkingPrivateServiceClient::OnNetworkListChangedEventOnUIThread(
const std::vector<std::string>& network_guids) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
FOR_EACH_OBSERVER(Observer,
network_events_observers_,
OnNetworkListChangedEvent(network_guids));
projects / platform / framework / web / crosswalk.git / blobdiff