1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
8 #include "base/bind_helpers.h"
9 #include "base/callback.h"
10 #include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
11 #include "chrome/common/extensions/api/networking_private.h"
12 #include "components/onc/onc_constants.h"
13 #include "extensions/browser/extension_function_registry.h"
17 const int kDefaultNetworkListLimit = 1000;
19 extensions::NetworkingPrivateDelegate* GetDelegate(
20 content::BrowserContext* browser_context) {
21 return extensions::NetworkingPrivateDelegate::GetForBrowserContext(
27 namespace private_api = extensions::api::networking_private;
29 namespace extensions {
31 namespace networking_private {
34 const char kErrorInvalidNetworkGuid[] = "Error.InvalidNetworkGuid";
35 const char kErrorNetworkUnavailable[] = "Error.NetworkUnavailable";
36 const char kErrorEncryptionError[] = "Error.EncryptionError";
37 const char kErrorNotReady[] = "Error.NotReady";
38 const char kErrorNotSupported[] = "Error.NotSupported";
40 } // namespace networking_private
42 ////////////////////////////////////////////////////////////////////////////////
43 // NetworkingPrivateGetPropertiesFunction
45 NetworkingPrivateGetPropertiesFunction::
46 ~NetworkingPrivateGetPropertiesFunction() {
49 bool NetworkingPrivateGetPropertiesFunction::RunAsync() {
50 scoped_ptr<private_api::GetProperties::Params> params =
51 private_api::GetProperties::Params::Create(*args_);
52 EXTENSION_FUNCTION_VALIDATE(params);
54 GetDelegate(browser_context())->GetProperties(
56 base::Bind(&NetworkingPrivateGetPropertiesFunction::Success, this),
57 base::Bind(&NetworkingPrivateGetPropertiesFunction::Failure, this));
61 void NetworkingPrivateGetPropertiesFunction::Success(
62 scoped_ptr<base::DictionaryValue> result) {
63 SetResult(result.release());
67 void NetworkingPrivateGetPropertiesFunction::Failure(const std::string& error) {
72 ////////////////////////////////////////////////////////////////////////////////
73 // NetworkingPrivateGetManagedPropertiesFunction
75 NetworkingPrivateGetManagedPropertiesFunction::
76 ~NetworkingPrivateGetManagedPropertiesFunction() {
79 bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() {
80 scoped_ptr<private_api::GetManagedProperties::Params> params =
81 private_api::GetManagedProperties::Params::Create(*args_);
82 EXTENSION_FUNCTION_VALIDATE(params);
84 GetDelegate(browser_context())->GetManagedProperties(
86 base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success, this),
87 base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
92 void NetworkingPrivateGetManagedPropertiesFunction::Success(
93 scoped_ptr<base::DictionaryValue> result) {
94 SetResult(result.release());
98 void NetworkingPrivateGetManagedPropertiesFunction::Failure(
99 const std::string& error) {
104 ////////////////////////////////////////////////////////////////////////////////
105 // NetworkingPrivateGetStateFunction
107 NetworkingPrivateGetStateFunction::~NetworkingPrivateGetStateFunction() {
110 bool NetworkingPrivateGetStateFunction::RunAsync() {
111 scoped_ptr<private_api::GetState::Params> params =
112 private_api::GetState::Params::Create(*args_);
113 EXTENSION_FUNCTION_VALIDATE(params);
115 GetDelegate(browser_context())->GetState(
116 params->network_guid,
117 base::Bind(&NetworkingPrivateGetStateFunction::Success, this),
118 base::Bind(&NetworkingPrivateGetStateFunction::Failure, this));
122 void NetworkingPrivateGetStateFunction::Success(
123 scoped_ptr<base::DictionaryValue> result) {
124 SetResult(result.release());
128 void NetworkingPrivateGetStateFunction::Failure(const std::string& error) {
133 ////////////////////////////////////////////////////////////////////////////////
134 // NetworkingPrivateSetPropertiesFunction
136 NetworkingPrivateSetPropertiesFunction::
137 ~NetworkingPrivateSetPropertiesFunction() {
140 bool NetworkingPrivateSetPropertiesFunction::RunAsync() {
141 scoped_ptr<private_api::SetProperties::Params> params =
142 private_api::SetProperties::Params::Create(*args_);
143 EXTENSION_FUNCTION_VALIDATE(params);
145 scoped_ptr<base::DictionaryValue> properties_dict(
146 params->properties.ToValue());
148 GetDelegate(browser_context())->SetProperties(
149 params->network_guid,
150 properties_dict.Pass(),
151 base::Bind(&NetworkingPrivateSetPropertiesFunction::Success, this),
152 base::Bind(&NetworkingPrivateSetPropertiesFunction::Failure, this));
156 void NetworkingPrivateSetPropertiesFunction::Success() {
160 void NetworkingPrivateSetPropertiesFunction::Failure(const std::string& error) {
165 ////////////////////////////////////////////////////////////////////////////////
166 // NetworkingPrivateCreateNetworkFunction
168 NetworkingPrivateCreateNetworkFunction::
169 ~NetworkingPrivateCreateNetworkFunction() {
172 bool NetworkingPrivateCreateNetworkFunction::RunAsync() {
173 scoped_ptr<private_api::CreateNetwork::Params> params =
174 private_api::CreateNetwork::Params::Create(*args_);
175 EXTENSION_FUNCTION_VALIDATE(params);
177 scoped_ptr<base::DictionaryValue> properties_dict(
178 params->properties.ToValue());
180 GetDelegate(browser_context())->CreateNetwork(
182 properties_dict.Pass(),
183 base::Bind(&NetworkingPrivateCreateNetworkFunction::Success, this),
184 base::Bind(&NetworkingPrivateCreateNetworkFunction::Failure, this));
188 void NetworkingPrivateCreateNetworkFunction::Success(const std::string& guid) {
189 results_ = private_api::CreateNetwork::Results::Create(guid);
193 void NetworkingPrivateCreateNetworkFunction::Failure(const std::string& error) {
198 ////////////////////////////////////////////////////////////////////////////////
199 // NetworkingPrivateGetNetworksFunction
201 NetworkingPrivateGetNetworksFunction::~NetworkingPrivateGetNetworksFunction() {
204 bool NetworkingPrivateGetNetworksFunction::RunAsync() {
205 scoped_ptr<private_api::GetNetworks::Params> params =
206 private_api::GetNetworks::Params::Create(*args_);
207 EXTENSION_FUNCTION_VALIDATE(params);
209 std::string network_type = private_api::ToString(params->filter.network_type);
210 const bool configured_only =
211 params->filter.configured ? *params->filter.configured : false;
212 const bool visible_only =
213 params->filter.visible ? *params->filter.visible : false;
215 params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit;
217 GetDelegate(browser_context())->GetNetworks(
222 base::Bind(&NetworkingPrivateGetNetworksFunction::Success, this),
223 base::Bind(&NetworkingPrivateGetNetworksFunction::Failure, this));
227 void NetworkingPrivateGetNetworksFunction::Success(
228 scoped_ptr<base::ListValue> network_list) {
229 SetResult(network_list.release());
233 void NetworkingPrivateGetNetworksFunction::Failure(const std::string& error) {
238 ////////////////////////////////////////////////////////////////////////////////
239 // NetworkingPrivateGetVisibleNetworksFunction
241 NetworkingPrivateGetVisibleNetworksFunction::
242 ~NetworkingPrivateGetVisibleNetworksFunction() {
245 bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() {
246 scoped_ptr<private_api::GetVisibleNetworks::Params> params =
247 private_api::GetVisibleNetworks::Params::Create(*args_);
248 EXTENSION_FUNCTION_VALIDATE(params);
250 std::string network_type = private_api::ToString(params->network_type);
251 const bool configured_only = false;
252 const bool visible_only = true;
254 GetDelegate(browser_context())->GetNetworks(
258 kDefaultNetworkListLimit,
259 base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Success, this),
260 base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Failure, this));
264 void NetworkingPrivateGetVisibleNetworksFunction::Success(
265 scoped_ptr<base::ListValue> network_properties_list) {
266 SetResult(network_properties_list.release());
270 void NetworkingPrivateGetVisibleNetworksFunction::Failure(
271 const std::string& error) {
276 ////////////////////////////////////////////////////////////////////////////////
277 // NetworkingPrivateGetEnabledNetworkTypesFunction
279 NetworkingPrivateGetEnabledNetworkTypesFunction::
280 ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
283 bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
284 scoped_ptr<base::ListValue> enabled_networks_onc_types(
285 GetDelegate(browser_context())->GetEnabledNetworkTypes());
286 if (!enabled_networks_onc_types) {
287 error_ = networking_private::kErrorNotSupported;
290 scoped_ptr<base::ListValue> enabled_networks_list;
291 for (base::ListValue::iterator iter = enabled_networks_onc_types->begin();
292 iter != enabled_networks_onc_types->end(); ++iter) {
294 if (!(*iter)->GetAsString(&type))
296 if (type == ::onc::network_type::kEthernet) {
297 enabled_networks_list->AppendString(api::networking_private::ToString(
298 api::networking_private::NETWORK_TYPE_ETHERNET));
299 } else if (type == ::onc::network_type::kWiFi) {
300 enabled_networks_list->AppendString(api::networking_private::ToString(
301 api::networking_private::NETWORK_TYPE_WIFI));
302 } else if (type == ::onc::network_type::kWimax) {
303 enabled_networks_list->AppendString(api::networking_private::ToString(
304 api::networking_private::NETWORK_TYPE_WIMAX));
305 } else if (type == ::onc::network_type::kCellular) {
306 enabled_networks_list->AppendString(api::networking_private::ToString(
307 api::networking_private::NETWORK_TYPE_CELLULAR));
309 LOG(ERROR) << "networkingPrivate: Unexpected type: " << type;
312 SetResult(enabled_networks_list.release());
316 ////////////////////////////////////////////////////////////////////////////////
317 // NetworkingPrivateEnableNetworkTypeFunction
319 NetworkingPrivateEnableNetworkTypeFunction::
320 ~NetworkingPrivateEnableNetworkTypeFunction() {
323 bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
324 scoped_ptr<private_api::EnableNetworkType::Params> params =
325 private_api::EnableNetworkType::Params::Create(*args_);
326 EXTENSION_FUNCTION_VALIDATE(params);
328 return GetDelegate(browser_context())->EnableNetworkType(
329 private_api::ToString(params->network_type));
332 ////////////////////////////////////////////////////////////////////////////////
333 // NetworkingPrivateDisableNetworkTypeFunction
335 NetworkingPrivateDisableNetworkTypeFunction::
336 ~NetworkingPrivateDisableNetworkTypeFunction() {
339 bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
340 scoped_ptr<private_api::DisableNetworkType::Params> params =
341 private_api::DisableNetworkType::Params::Create(*args_);
343 return GetDelegate(browser_context())->DisableNetworkType(
344 private_api::ToString(params->network_type));
347 ////////////////////////////////////////////////////////////////////////////////
348 // NetworkingPrivateRequestNetworkScanFunction
350 NetworkingPrivateRequestNetworkScanFunction::
351 ~NetworkingPrivateRequestNetworkScanFunction() {
354 bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
355 return GetDelegate(browser_context())->RequestScan();
358 ////////////////////////////////////////////////////////////////////////////////
359 // NetworkingPrivateStartConnectFunction
361 NetworkingPrivateStartConnectFunction::
362 ~NetworkingPrivateStartConnectFunction() {
365 bool NetworkingPrivateStartConnectFunction::RunAsync() {
366 scoped_ptr<private_api::StartConnect::Params> params =
367 private_api::StartConnect::Params::Create(*args_);
368 EXTENSION_FUNCTION_VALIDATE(params);
370 GetDelegate(browser_context())->StartConnect(
371 params->network_guid,
372 base::Bind(&NetworkingPrivateStartConnectFunction::Success, this),
373 base::Bind(&NetworkingPrivateStartConnectFunction::Failure, this));
377 void NetworkingPrivateStartConnectFunction::Success() {
381 void NetworkingPrivateStartConnectFunction::Failure(const std::string& error) {
386 ////////////////////////////////////////////////////////////////////////////////
387 // NetworkingPrivateStartDisconnectFunction
389 NetworkingPrivateStartDisconnectFunction::
390 ~NetworkingPrivateStartDisconnectFunction() {
393 bool NetworkingPrivateStartDisconnectFunction::RunAsync() {
394 scoped_ptr<private_api::StartDisconnect::Params> params =
395 private_api::StartDisconnect::Params::Create(*args_);
396 EXTENSION_FUNCTION_VALIDATE(params);
398 GetDelegate(browser_context())->StartDisconnect(
399 params->network_guid,
400 base::Bind(&NetworkingPrivateStartDisconnectFunction::Success, this),
401 base::Bind(&NetworkingPrivateStartDisconnectFunction::Failure, this));
405 void NetworkingPrivateStartDisconnectFunction::Success() {
409 void NetworkingPrivateStartDisconnectFunction::Failure(
410 const std::string& error) {
415 ////////////////////////////////////////////////////////////////////////////////
416 // NetworkingPrivateVerifyDestinationFunction
418 NetworkingPrivateVerifyDestinationFunction::
419 ~NetworkingPrivateVerifyDestinationFunction() {
422 bool NetworkingPrivateVerifyDestinationFunction::RunAsync() {
423 scoped_ptr<private_api::VerifyDestination::Params> params =
424 private_api::VerifyDestination::Params::Create(*args_);
425 EXTENSION_FUNCTION_VALIDATE(params);
427 GetDelegate(browser_context())->VerifyDestination(
429 base::Bind(&NetworkingPrivateVerifyDestinationFunction::Success, this),
430 base::Bind(&NetworkingPrivateVerifyDestinationFunction::Failure, this));
434 void NetworkingPrivateVerifyDestinationFunction::Success(bool result) {
435 results_ = private_api::VerifyDestination::Results::Create(result);
439 void NetworkingPrivateVerifyDestinationFunction::Failure(
440 const std::string& error) {
445 ////////////////////////////////////////////////////////////////////////////////
446 // NetworkingPrivateVerifyAndEncryptCredentialsFunction
448 NetworkingPrivateVerifyAndEncryptCredentialsFunction::
449 ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
452 bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() {
453 scoped_ptr<private_api::VerifyAndEncryptCredentials::Params> params =
454 private_api::VerifyAndEncryptCredentials::Params::Create(*args_);
455 EXTENSION_FUNCTION_VALIDATE(params);
457 GetDelegate(browser_context())->VerifyAndEncryptCredentials(
458 params->network_guid,
460 base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
462 base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
467 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success(
468 const std::string& result) {
469 results_ = private_api::VerifyAndEncryptCredentials::Results::Create(result);
473 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure(
474 const std::string& error) {
479 ////////////////////////////////////////////////////////////////////////////////
480 // NetworkingPrivateVerifyAndEncryptDataFunction
482 NetworkingPrivateVerifyAndEncryptDataFunction::
483 ~NetworkingPrivateVerifyAndEncryptDataFunction() {
486 bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() {
487 scoped_ptr<private_api::VerifyAndEncryptData::Params> params =
488 private_api::VerifyAndEncryptData::Params::Create(*args_);
489 EXTENSION_FUNCTION_VALIDATE(params);
491 GetDelegate(browser_context())->VerifyAndEncryptData(
494 base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Success, this),
495 base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Failure,
500 void NetworkingPrivateVerifyAndEncryptDataFunction::Success(
501 const std::string& result) {
502 results_ = private_api::VerifyAndEncryptData::Results::Create(result);
506 void NetworkingPrivateVerifyAndEncryptDataFunction::Failure(
507 const std::string& error) {
512 ////////////////////////////////////////////////////////////////////////////////
513 // NetworkingPrivateSetWifiTDLSEnabledStateFunction
515 NetworkingPrivateSetWifiTDLSEnabledStateFunction::
516 ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
519 bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() {
520 scoped_ptr<private_api::SetWifiTDLSEnabledState::Params> params =
521 private_api::SetWifiTDLSEnabledState::Params::Create(*args_);
522 EXTENSION_FUNCTION_VALIDATE(params);
524 GetDelegate(browser_context())->SetWifiTDLSEnabledState(
525 params->ip_or_mac_address,
527 base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success,
529 base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure,
535 void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success(
536 const std::string& result) {
537 results_ = private_api::SetWifiTDLSEnabledState::Results::Create(result);
541 void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure(
542 const std::string& error) {
547 ////////////////////////////////////////////////////////////////////////////////
548 // NetworkingPrivateGetWifiTDLSStatusFunction
550 NetworkingPrivateGetWifiTDLSStatusFunction::
551 ~NetworkingPrivateGetWifiTDLSStatusFunction() {
554 bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() {
555 scoped_ptr<private_api::GetWifiTDLSStatus::Params> params =
556 private_api::GetWifiTDLSStatus::Params::Create(*args_);
557 EXTENSION_FUNCTION_VALIDATE(params);
559 GetDelegate(browser_context())->GetWifiTDLSStatus(
560 params->ip_or_mac_address,
561 base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Success, this),
562 base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Failure, this));
567 void NetworkingPrivateGetWifiTDLSStatusFunction::Success(
568 const std::string& result) {
569 results_ = private_api::GetWifiTDLSStatus::Results::Create(result);
573 void NetworkingPrivateGetWifiTDLSStatusFunction::Failure(
574 const std::string& error) {
579 ////////////////////////////////////////////////////////////////////////////////
580 // NetworkingPrivateGetCaptivePortalStatusFunction
582 NetworkingPrivateGetCaptivePortalStatusFunction::
583 ~NetworkingPrivateGetCaptivePortalStatusFunction() {
586 bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() {
587 scoped_ptr<private_api::GetCaptivePortalStatus::Params> params =
588 private_api::GetCaptivePortalStatus::Params::Create(*args_);
589 EXTENSION_FUNCTION_VALIDATE(params);
591 GetDelegate(browser_context())->GetCaptivePortalStatus(
592 params->network_guid,
593 base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Success,
595 base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Failure,
600 void NetworkingPrivateGetCaptivePortalStatusFunction::Success(
601 const std::string& result) {
602 results_ = private_api::GetCaptivePortalStatus::Results::Create(
603 private_api::ParseCaptivePortalStatus(result));
607 void NetworkingPrivateGetCaptivePortalStatusFunction::Failure(
608 const std::string& error) {
613 } // namespace extensions