| // Copyright 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 "chrome/browser/extensions/api/networking_private/networking_private_api.h" |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/callback.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/browser_process_platform_part_chromeos.h" |
| #include "chrome/browser/chromeos/net/network_portal_detector.h" |
| #include "chrome/browser/chromeos/profiles/profile_helper.h" |
| #include "chrome/browser/profiles/profiles_state.h" |
| #include "chrome/common/extensions/api/networking_private.h" |
| #include "chromeos/dbus/dbus_thread_manager.h" |
| #include "chromeos/dbus/shill_manager_client.h" |
| #include "chromeos/network/favorite_state.h" |
| #include "chromeos/network/managed_network_configuration_handler.h" |
| #include "chromeos/network/network_connection_handler.h" |
| #include "chromeos/network/network_device_handler.h" |
| #include "chromeos/network/network_state.h" |
| #include "chromeos/network/network_state_handler.h" |
| #include "chromeos/network/network_util.h" |
| #include "chromeos/network/onc/onc_signature.h" |
| #include "chromeos/network/onc/onc_translator.h" |
| #include "chromeos/network/onc/onc_utils.h" |
| #include "components/onc/onc_constants.h" |
| #include "extensions/browser/extension_function_registry.h" |
| |
| namespace api = extensions::api::networking_private; |
| |
| using chromeos::DBusThreadManager; |
| using chromeos::FavoriteState; |
| using chromeos::ManagedNetworkConfigurationHandler; |
| using chromeos::NetworkHandler; |
| using chromeos::NetworkPortalDetector; |
| using chromeos::NetworkState; |
| using chromeos::NetworkStateHandler; |
| using chromeos::NetworkTypePattern; |
| using chromeos::ShillManagerClient; |
| |
| namespace { |
| |
| const int kDefaultNetworkListLimit = 1000; |
| |
| // Helper function that converts between the two types of verification |
| // properties. They should always have the same fields, but we do this here to |
| // prevent ShillManagerClient from depending directly on the extension API. |
| ShillManagerClient::VerificationProperties ConvertVerificationProperties( |
| const api::VerificationProperties& input) { |
| ShillManagerClient::VerificationProperties output; |
| COMPILE_ASSERT(sizeof(api::VerificationProperties) == |
| sizeof(ShillManagerClient::VerificationProperties), |
| verification_properties_no_longer_match); |
| |
| output.certificate = input.certificate; |
| output.public_key = input.public_key; |
| output.nonce = input.nonce; |
| output.signed_data = input.signed_data; |
| output.device_serial = input.device_serial; |
| output.device_ssid = input.device_ssid; |
| output.device_bssid = input.device_bssid; |
| return output; |
| } |
| |
| std::string GetUserIdHash(Profile* profile) { |
| return g_browser_process->platform_part()-> |
| profile_helper()->GetUserIdHashFromProfile(profile); |
| } |
| |
| bool GetServicePathFromGuid(const std::string& guid, |
| std::string* service_path, |
| std::string* error) { |
| const FavoriteState* network = |
| NetworkHandler::Get()->network_state_handler()->GetFavoriteStateFromGuid( |
| guid); |
| if (!network) { |
| *error = "Error.InvalidNetworkGuid"; |
| return false; |
| } |
| *service_path = network->path(); |
| return true; |
| } |
| |
| } // namespace |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetPropertiesFunction |
| |
| NetworkingPrivateGetPropertiesFunction:: |
| ~NetworkingPrivateGetPropertiesFunction() { |
| } |
| |
| bool NetworkingPrivateGetPropertiesFunction::RunAsync() { |
| scoped_ptr<api::GetProperties::Params> params = |
| api::GetProperties::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| NetworkHandler::Get()->managed_network_configuration_handler()->GetProperties( |
| service_path, |
| base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess, |
| this), |
| base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess( |
| const std::string& service_path, |
| const base::DictionaryValue& dictionary) { |
| SetResult(dictionary.DeepCopy()); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed( |
| const std::string& error_name, |
| scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetManagedPropertiesFunction |
| |
| NetworkingPrivateGetManagedPropertiesFunction:: |
| ~NetworkingPrivateGetManagedPropertiesFunction() { |
| } |
| |
| bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() { |
| scoped_ptr<api::GetManagedProperties::Params> params = |
| api::GetManagedProperties::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| std::string user_id_hash; |
| GetUserIdHash(GetProfile()); |
| NetworkHandler::Get()->managed_network_configuration_handler()-> |
| GetManagedProperties( |
| user_id_hash, |
| service_path, |
| base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success, |
| this), |
| base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateGetManagedPropertiesFunction::Success( |
| const std::string& service_path, |
| const base::DictionaryValue& dictionary) { |
| SetResult(dictionary.DeepCopy()); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateGetManagedPropertiesFunction::Failure( |
| const std::string& error_name, |
| scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetStateFunction |
| |
| NetworkingPrivateGetStateFunction:: |
| ~NetworkingPrivateGetStateFunction() { |
| } |
| |
| bool NetworkingPrivateGetStateFunction::RunAsync() { |
| scoped_ptr<api::GetState::Params> params = |
| api::GetState::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| const FavoriteState* favorite_state = |
| NetworkHandler::Get() |
| ->network_state_handler() |
| ->GetFavoriteStateFromServicePath(service_path, |
| false /* configured_only */); |
| if (!favorite_state) { |
| error_ = "Error.NetworkUnavailable"; |
| return false; |
| } |
| |
| scoped_ptr<base::DictionaryValue> network_properties = |
| chromeos::network_util::TranslateFavoriteStateToONC(favorite_state); |
| |
| SetResult(network_properties.release()); |
| SendResponse(true); |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateSetPropertiesFunction |
| |
| NetworkingPrivateSetPropertiesFunction:: |
| ~NetworkingPrivateSetPropertiesFunction() { |
| } |
| |
| bool NetworkingPrivateSetPropertiesFunction::RunAsync() { |
| scoped_ptr<api::SetProperties::Params> params = |
| api::SetProperties::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| scoped_ptr<base::DictionaryValue> properties_dict( |
| params->properties.ToValue()); |
| |
| NetworkHandler::Get()->managed_network_configuration_handler()->SetProperties( |
| service_path, |
| *properties_dict, |
| base::Bind(&NetworkingPrivateSetPropertiesFunction::ResultCallback, |
| this), |
| base::Bind(&NetworkingPrivateSetPropertiesFunction::ErrorCallback, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateSetPropertiesFunction::ErrorCallback( |
| const std::string& error_name, |
| const scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| void NetworkingPrivateSetPropertiesFunction::ResultCallback() { |
| SendResponse(true); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateCreateNetworkFunction |
| |
| NetworkingPrivateCreateNetworkFunction:: |
| ~NetworkingPrivateCreateNetworkFunction() { |
| } |
| |
| bool NetworkingPrivateCreateNetworkFunction::RunAsync() { |
| scoped_ptr<api::CreateNetwork::Params> params = |
| api::CreateNetwork::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| std::string user_id_hash; |
| if (!params->shared) |
| user_id_hash = GetUserIdHash(GetProfile()); |
| |
| scoped_ptr<base::DictionaryValue> properties_dict( |
| params->properties.ToValue()); |
| |
| NetworkHandler::Get()->managed_network_configuration_handler()-> |
| CreateConfiguration( |
| user_id_hash, |
| *properties_dict, |
| base::Bind(&NetworkingPrivateCreateNetworkFunction::ResultCallback, |
| this), |
| base::Bind(&NetworkingPrivateCreateNetworkFunction::ErrorCallback, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateCreateNetworkFunction::ErrorCallback( |
| const std::string& error_name, |
| const scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| void NetworkingPrivateCreateNetworkFunction::ResultCallback( |
| const std::string& guid) { |
| results_ = api::CreateNetwork::Results::Create(guid); |
| SendResponse(true); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetNetworksFunction |
| |
| NetworkingPrivateGetNetworksFunction:: |
| ~NetworkingPrivateGetNetworksFunction() { |
| } |
| |
| bool NetworkingPrivateGetNetworksFunction::RunAsync() { |
| scoped_ptr<api::GetNetworks::Params> params = |
| api::GetNetworks::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType( |
| api::ToString(params->filter.network_type)); |
| const bool configured_only = |
| params->filter.configured ? *params->filter.configured : false; |
| const bool visible_only = |
| params->filter.visible ? *params->filter.visible : false; |
| const int limit = |
| params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit; |
| scoped_ptr<base::ListValue> network_properties_list = |
| chromeos::network_util::TranslateNetworkListToONC( |
| pattern, configured_only, visible_only, limit, false /* debugging */); |
| SetResult(network_properties_list.release()); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetVisibleNetworksFunction |
| |
| NetworkingPrivateGetVisibleNetworksFunction:: |
| ~NetworkingPrivateGetVisibleNetworksFunction() { |
| } |
| |
| bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() { |
| scoped_ptr<api::GetVisibleNetworks::Params> params = |
| api::GetVisibleNetworks::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType( |
| api::ToString(params->network_type)); |
| const bool configured_only = false; |
| const bool visible_only = true; |
| scoped_ptr<base::ListValue> network_properties_list = |
| chromeos::network_util::TranslateNetworkListToONC( |
| pattern, configured_only, visible_only, kDefaultNetworkListLimit, |
| false /* debugging */); |
| SetResult(network_properties_list.release()); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetEnabledNetworkTypesFunction |
| |
| NetworkingPrivateGetEnabledNetworkTypesFunction:: |
| ~NetworkingPrivateGetEnabledNetworkTypesFunction() { |
| } |
| |
| bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() { |
| NetworkStateHandler* state_handler = |
| NetworkHandler::Get()->network_state_handler(); |
| |
| base::ListValue* network_list = new base::ListValue; |
| |
| if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Ethernet())) |
| network_list->AppendString(api::ToString(api::NETWORK_TYPE_ETHERNET)); |
| if (state_handler->IsTechnologyEnabled(NetworkTypePattern::WiFi())) |
| network_list->AppendString(api::ToString(api::NETWORK_TYPE_WIFI)); |
| if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Wimax())) |
| network_list->AppendString(api::ToString(api::NETWORK_TYPE_WIMAX)); |
| if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Cellular())) |
| network_list->AppendString(api::ToString(api::NETWORK_TYPE_CELLULAR)); |
| |
| SetResult(network_list); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateEnableNetworkTypeFunction |
| |
| NetworkingPrivateEnableNetworkTypeFunction:: |
| ~NetworkingPrivateEnableNetworkTypeFunction() { |
| } |
| |
| bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() { |
| scoped_ptr<api::EnableNetworkType::Params> params = |
| api::EnableNetworkType::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType( |
| api::ToString(params->network_type)); |
| |
| NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( |
| pattern, true, chromeos::network_handler::ErrorCallback()); |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateDisableNetworkTypeFunction |
| |
| NetworkingPrivateDisableNetworkTypeFunction:: |
| ~NetworkingPrivateDisableNetworkTypeFunction() { |
| } |
| |
| bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() { |
| scoped_ptr<api::DisableNetworkType::Params> params = |
| api::DisableNetworkType::Params::Create(*args_); |
| |
| NetworkTypePattern pattern = chromeos::onc::NetworkTypePatternFromOncType( |
| api::ToString(params->network_type)); |
| |
| NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( |
| pattern, false, chromeos::network_handler::ErrorCallback()); |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateRequestNetworkScanFunction |
| |
| NetworkingPrivateRequestNetworkScanFunction:: |
| ~NetworkingPrivateRequestNetworkScanFunction() { |
| } |
| |
| bool NetworkingPrivateRequestNetworkScanFunction::RunSync() { |
| NetworkHandler::Get()->network_state_handler()->RequestScan(); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateStartConnectFunction |
| |
| NetworkingPrivateStartConnectFunction:: |
| ~NetworkingPrivateStartConnectFunction() { |
| } |
| |
| void NetworkingPrivateStartConnectFunction::ConnectionStartSuccess() { |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateStartConnectFunction::ConnectionStartFailed( |
| const std::string& error_name, |
| const scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| bool NetworkingPrivateStartConnectFunction::RunAsync() { |
| scoped_ptr<api::StartConnect::Params> params = |
| api::StartConnect::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| const bool check_error_state = false; |
| NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork( |
| service_path, |
| base::Bind( |
| &NetworkingPrivateStartConnectFunction::ConnectionStartSuccess, |
| this), |
| base::Bind( |
| &NetworkingPrivateStartConnectFunction::ConnectionStartFailed, |
| this), |
| check_error_state); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateStartDisconnectFunction |
| |
| NetworkingPrivateStartDisconnectFunction:: |
| ~NetworkingPrivateStartDisconnectFunction() { |
| } |
| |
| void NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess() { |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed( |
| const std::string& error_name, |
| const scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| bool NetworkingPrivateStartDisconnectFunction::RunAsync() { |
| scoped_ptr<api::StartDisconnect::Params> params = |
| api::StartDisconnect::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork( |
| service_path, |
| base::Bind( |
| &NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess, |
| this), |
| base::Bind( |
| &NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed, |
| this)); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateVerifyDestinationFunction |
| |
| NetworkingPrivateVerifyDestinationFunction:: |
| ~NetworkingPrivateVerifyDestinationFunction() { |
| } |
| |
| bool NetworkingPrivateVerifyDestinationFunction::RunAsync() { |
| scoped_ptr<api::VerifyDestination::Params> params = |
| api::VerifyDestination::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| ShillManagerClient::VerificationProperties verification_properties = |
| ConvertVerificationProperties(params->properties); |
| |
| DBusThreadManager::Get()->GetShillManagerClient()->VerifyDestination( |
| verification_properties, |
| base::Bind( |
| &NetworkingPrivateVerifyDestinationFunction::ResultCallback, |
| this), |
| base::Bind( |
| &NetworkingPrivateVerifyDestinationFunction::ErrorCallback, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateVerifyDestinationFunction::ResultCallback( |
| bool result) { |
| results_ = api::VerifyDestination::Results::Create(result); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateVerifyDestinationFunction::ErrorCallback( |
| const std::string& error_name, const std::string& error) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateVerifyAndEncryptCredentialsFunction |
| |
| NetworkingPrivateVerifyAndEncryptCredentialsFunction:: |
| ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() { |
| } |
| |
| bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() { |
| scoped_ptr<api::VerifyAndEncryptCredentials::Params> params = |
| api::VerifyAndEncryptCredentials::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| ShillManagerClient::VerificationProperties verification_properties = |
| ConvertVerificationProperties(params->properties); |
| |
| ShillManagerClient* shill_manager_client = |
| DBusThreadManager::Get()->GetShillManagerClient(); |
| shill_manager_client->VerifyAndEncryptCredentials( |
| verification_properties, |
| service_path, |
| base::Bind( |
| &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback, |
| this), |
| base::Bind( |
| &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback( |
| const std::string& result) { |
| results_ = api::VerifyAndEncryptCredentials::Results::Create(result); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback( |
| const std::string& error_name, const std::string& error) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateVerifyAndEncryptDataFunction |
| |
| NetworkingPrivateVerifyAndEncryptDataFunction:: |
| ~NetworkingPrivateVerifyAndEncryptDataFunction() { |
| } |
| |
| bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() { |
| scoped_ptr<api::VerifyAndEncryptData::Params> params = |
| api::VerifyAndEncryptData::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| ShillManagerClient::VerificationProperties verification_properties = |
| ConvertVerificationProperties(params->properties); |
| |
| DBusThreadManager::Get()->GetShillManagerClient()->VerifyAndEncryptData( |
| verification_properties, |
| params->data, |
| base::Bind( |
| &NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback, |
| this), |
| base::Bind( |
| &NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback, |
| this)); |
| return true; |
| } |
| |
| void NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback( |
| const std::string& result) { |
| results_ = api::VerifyAndEncryptData::Results::Create(result); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback( |
| const std::string& error_name, |
| const std::string& error) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateSetWifiTDLSEnabledStateFunction |
| |
| NetworkingPrivateSetWifiTDLSEnabledStateFunction:: |
| ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() { |
| } |
| |
| bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() { |
| scoped_ptr<api::SetWifiTDLSEnabledState::Params> params = |
| api::SetWifiTDLSEnabledState::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| std::string ip_or_mac_address = params->ip_or_mac_address; |
| bool enable = params->enabled; |
| |
| NetworkHandler::Get()->network_device_handler()-> |
| SetWifiTDLSEnabled( |
| ip_or_mac_address, |
| enable, |
| base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success, |
| this), |
| base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure, |
| this)); |
| |
| return true; |
| } |
| |
| void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success( |
| const std::string& result) { |
| results_ = api::SetWifiTDLSEnabledState::Results::Create(result); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure( |
| const std::string& error_name, |
| scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetWifiTDLSStatusFunction |
| |
| NetworkingPrivateGetWifiTDLSStatusFunction:: |
| ~NetworkingPrivateGetWifiTDLSStatusFunction() { |
| } |
| |
| bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() { |
| scoped_ptr<api::GetWifiTDLSStatus::Params> params = |
| api::GetWifiTDLSStatus::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| std::string ip_or_mac_address = params->ip_or_mac_address; |
| |
| NetworkHandler::Get()->network_device_handler()-> |
| GetWifiTDLSStatus( |
| ip_or_mac_address, |
| base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Success, |
| this), |
| base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Failure, |
| this)); |
| |
| return true; |
| } |
| |
| void NetworkingPrivateGetWifiTDLSStatusFunction::Success( |
| const std::string& result) { |
| results_ = api::GetWifiTDLSStatus::Results::Create(result); |
| SendResponse(true); |
| } |
| |
| void NetworkingPrivateGetWifiTDLSStatusFunction::Failure( |
| const std::string& error_name, |
| scoped_ptr<base::DictionaryValue> error_data) { |
| error_ = error_name; |
| SendResponse(false); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetCaptivePortalStatusFunction |
| |
| NetworkingPrivateGetCaptivePortalStatusFunction:: |
| ~NetworkingPrivateGetCaptivePortalStatusFunction() {} |
| |
| bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() { |
| scoped_ptr<api::GetCaptivePortalStatus::Params> params = |
| api::GetCaptivePortalStatus::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| std::string service_path; |
| if (!GetServicePathFromGuid(params->network_guid, &service_path, &error_)) |
| return false; |
| |
| NetworkPortalDetector* detector = NetworkPortalDetector::Get(); |
| if (!detector) { |
| error_ = "Error.NotReady"; |
| return false; |
| } |
| |
| NetworkPortalDetector::CaptivePortalState state = |
| detector->GetCaptivePortalState(service_path); |
| |
| SetResult(new base::StringValue( |
| NetworkPortalDetector::CaptivePortalStatusString(state.status))); |
| SendResponse(true); |
| return true; |
| } |