1 // Copyright 2013 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.
4
5 #include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
6
7 #include "base/bind.h"
8 #include "base/bind_helpers.h"
9 #include "base/callback.h"
10 #include "base/command_line.h"
11 #include "base/json/json_reader.h"
12 #include "chrome/browser/browser_process.h"
13 #include "chrome/browser/extensions/api/networking_private/networking_private_service_client.h"
14 #include "chrome/browser/extensions/api/networking_private/networking_private_service_client_factory.h"
15 #include "chrome/common/chrome_switches.h"
16 #include "chrome/common/extensions/api/networking_private.h"
17 #include "components/onc/onc_constants.h"
18 #include "extensions/browser/event_router.h"
19 #include "extensions/browser/extension_function_registry.h"
20 #include "extensions/browser/extension_system.h"
21
22 using extensions::NetworkingPrivateServiceClient;
23 using extensions::NetworkingPrivateServiceClientFactory;
24 namespace api = extensions::api::networking_private;
25
26 ////////////////////////////////////////////////////////////////////////////////
27 // NetworkingPrivateGetPropertiesFunction
28
29 NetworkingPrivateGetPropertiesFunction::
~NetworkingPrivateGetPropertiesFunction()30 ~NetworkingPrivateGetPropertiesFunction() {
31 }
32
RunAsync()33 bool NetworkingPrivateGetPropertiesFunction::RunAsync() {
34 scoped_ptr<api::GetProperties::Params> params =
35 api::GetProperties::Params::Create(*args_);
36 EXTENSION_FUNCTION_VALIDATE(params);
37
38 NetworkingPrivateServiceClient* service_client =
39 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
40
41 service_client->GetProperties(
42 params->network_guid,
43 base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess,
44 this),
45 base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed,
46 this));
47 return true;
48 }
49
GetPropertiesSuccess(const std::string & network_guid,const base::DictionaryValue & dictionary)50 void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess(
51 const std::string& network_guid,
52 const base::DictionaryValue& dictionary) {
53 SetResult(dictionary.DeepCopy());
54 SendResponse(true);
55 }
56
GetPropertiesFailed(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)57 void NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed(
58 const std::string& error_name,
59 scoped_ptr<base::DictionaryValue> error_data) {
60 error_ = error_name;
61 SendResponse(false);
62 }
63
64 ////////////////////////////////////////////////////////////////////////////////
65 // NetworkingPrivateGetManagedPropertiesFunction
66
67 NetworkingPrivateGetManagedPropertiesFunction::
~NetworkingPrivateGetManagedPropertiesFunction()68 ~NetworkingPrivateGetManagedPropertiesFunction() {
69 }
70
RunAsync()71 bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() {
72 scoped_ptr<api::GetManagedProperties::Params> params =
73 api::GetManagedProperties::Params::Create(*args_);
74 EXTENSION_FUNCTION_VALIDATE(params);
75 NetworkingPrivateServiceClient* service_client =
76 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
77
78 service_client->GetManagedProperties(
79 params->network_guid,
80 base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success,
81 this),
82 base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
83 this));
84 return true;
85 }
86
Success(const std::string & network_guid,const base::DictionaryValue & dictionary)87 void NetworkingPrivateGetManagedPropertiesFunction::Success(
88 const std::string& network_guid,
89 const base::DictionaryValue& dictionary) {
90 SetResult(dictionary.DeepCopy());
91 SendResponse(true);
92 }
93
Failure(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)94 void NetworkingPrivateGetManagedPropertiesFunction::Failure(
95 const std::string& error_name,
96 scoped_ptr<base::DictionaryValue> error_data) {
97 error_ = error_name;
98 SendResponse(false);
99 }
100
101 ////////////////////////////////////////////////////////////////////////////////
102 // NetworkingPrivateGetStateFunction
103
104 NetworkingPrivateGetStateFunction::
~NetworkingPrivateGetStateFunction()105 ~NetworkingPrivateGetStateFunction() {
106 }
107
RunAsync()108 bool NetworkingPrivateGetStateFunction::RunAsync() {
109 scoped_ptr<api::GetState::Params> params =
110 api::GetState::Params::Create(*args_);
111 EXTENSION_FUNCTION_VALIDATE(params);
112 NetworkingPrivateServiceClient* service_client =
113 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
114
115 service_client->GetState(
116 params->network_guid,
117 base::Bind(&NetworkingPrivateGetStateFunction::Success,
118 this),
119 base::Bind(&NetworkingPrivateGetStateFunction::Failure,
120 this));
121 return true;
122 }
123
Success(const std::string & network_guid,const base::DictionaryValue & dictionary)124 void NetworkingPrivateGetStateFunction::Success(
125 const std::string& network_guid,
126 const base::DictionaryValue& dictionary) {
127 SetResult(dictionary.DeepCopy());
128 SendResponse(true);
129 }
130
Failure(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)131 void NetworkingPrivateGetStateFunction::Failure(
132 const std::string& error_name,
133 scoped_ptr<base::DictionaryValue> error_data) {
134 error_ = error_name;
135 SendResponse(false);
136 }
137
138 ////////////////////////////////////////////////////////////////////////////////
139 // NetworkingPrivateSetPropertiesFunction
140
141 NetworkingPrivateSetPropertiesFunction::
~NetworkingPrivateSetPropertiesFunction()142 ~NetworkingPrivateSetPropertiesFunction() {
143 }
144
RunAsync()145 bool NetworkingPrivateSetPropertiesFunction::RunAsync() {
146 scoped_ptr<api::SetProperties::Params> params =
147 api::SetProperties::Params::Create(*args_);
148 EXTENSION_FUNCTION_VALIDATE(params);
149 scoped_ptr<base::DictionaryValue> properties_dict(
150 params->properties.ToValue());
151
152 NetworkingPrivateServiceClient* service_client =
153 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
154
155 service_client->SetProperties(
156 params->network_guid,
157 *properties_dict,
158 base::Bind(&NetworkingPrivateSetPropertiesFunction::ResultCallback, this),
159 base::Bind(&NetworkingPrivateSetPropertiesFunction::ErrorCallback, this));
160 return true;
161 }
162
ResultCallback()163 void NetworkingPrivateSetPropertiesFunction::ResultCallback() {
164 SendResponse(true);
165 }
166
ErrorCallback(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)167 void NetworkingPrivateSetPropertiesFunction::ErrorCallback(
168 const std::string& error_name,
169 const scoped_ptr<base::DictionaryValue> error_data) {
170 error_ = error_name;
171 SendResponse(false);
172 }
173
174 ////////////////////////////////////////////////////////////////////////////////
175 // NetworkingPrivateCreateNetworkFunction
176
177 NetworkingPrivateCreateNetworkFunction::
~NetworkingPrivateCreateNetworkFunction()178 ~NetworkingPrivateCreateNetworkFunction() {
179 }
180
RunAsync()181 bool NetworkingPrivateCreateNetworkFunction::RunAsync() {
182 scoped_ptr<api::CreateNetwork::Params> params =
183 api::CreateNetwork::Params::Create(*args_);
184 EXTENSION_FUNCTION_VALIDATE(params);
185 scoped_ptr<base::DictionaryValue> properties_dict(
186 params->properties.ToValue());
187
188 NetworkingPrivateServiceClient* service_client =
189 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
190
191 service_client->CreateNetwork(
192 params->shared,
193 *properties_dict,
194 base::Bind(&NetworkingPrivateCreateNetworkFunction::ResultCallback, this),
195 base::Bind(&NetworkingPrivateCreateNetworkFunction::ErrorCallback, this));
196 return true;
197 }
198
ErrorCallback(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)199 void NetworkingPrivateCreateNetworkFunction::ErrorCallback(
200 const std::string& error_name,
201 const scoped_ptr<base::DictionaryValue> error_data) {
202 error_ = error_name;
203 SendResponse(false);
204 }
205
ResultCallback(const std::string & guid)206 void NetworkingPrivateCreateNetworkFunction::ResultCallback(
207 const std::string& guid) {
208 results_ = api::CreateNetwork::Results::Create(guid);
209 SendResponse(true);
210 }
211
212 ////////////////////////////////////////////////////////////////////////////////
213 // NetworkingPrivateGetNetworksFunction
214
215 NetworkingPrivateGetNetworksFunction::
~NetworkingPrivateGetNetworksFunction()216 ~NetworkingPrivateGetNetworksFunction() {
217 }
218
RunAsync()219 bool NetworkingPrivateGetNetworksFunction::RunAsync() {
220 scoped_ptr<api::GetNetworks::Params> params =
221 api::GetNetworks::Params::Create(*args_);
222 EXTENSION_FUNCTION_VALIDATE(params);
223
224 // TODO(stevenjb/mef): Apply filters (visible, configured).
225 NetworkingPrivateServiceClient* service_client =
226 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
227
228 service_client->GetVisibleNetworks(
229 api::ToString(params->filter.network_type),
230 base::Bind(&NetworkingPrivateGetNetworksFunction::ResultCallback, this));
231
232 return true;
233 }
234
ResultCallback(const base::ListValue & network_list)235 void NetworkingPrivateGetNetworksFunction::ResultCallback(
236 const base::ListValue& network_list) {
237 SetResult(network_list.DeepCopy());
238 SendResponse(true);
239 }
240
241 ////////////////////////////////////////////////////////////////////////////////
242 // NetworkingPrivateGetVisibleNetworksFunction
243
244 NetworkingPrivateGetVisibleNetworksFunction::
~NetworkingPrivateGetVisibleNetworksFunction()245 ~NetworkingPrivateGetVisibleNetworksFunction() {
246 }
247
RunAsync()248 bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() {
249 scoped_ptr<api::GetVisibleNetworks::Params> params =
250 api::GetVisibleNetworks::Params::Create(*args_);
251 EXTENSION_FUNCTION_VALIDATE(params);
252
253 NetworkingPrivateServiceClient* service_client =
254 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
255
256 service_client->GetVisibleNetworks(
257 api::ToString(params->network_type),
258 base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::ResultCallback,
259 this));
260
261 return true;
262 }
263
ResultCallback(const base::ListValue & network_list)264 void NetworkingPrivateGetVisibleNetworksFunction::ResultCallback(
265 const base::ListValue& network_list) {
266 SetResult(network_list.DeepCopy());
267 SendResponse(true);
268 }
269
270 ////////////////////////////////////////////////////////////////////////////////
271 // NetworkingPrivateGetEnabledNetworkTypesFunction
272
273 NetworkingPrivateGetEnabledNetworkTypesFunction::
~NetworkingPrivateGetEnabledNetworkTypesFunction()274 ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
275 }
276
RunSync()277 bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
278 base::ListValue* network_list = new base::ListValue;
279 network_list->Append(new base::StringValue(onc::network_type::kWiFi));
280 SetResult(network_list);
281 return true;
282 }
283
284 ////////////////////////////////////////////////////////////////////////////////
285 // NetworkingPrivateEnableNetworkTypeFunction
286
287 NetworkingPrivateEnableNetworkTypeFunction::
~NetworkingPrivateEnableNetworkTypeFunction()288 ~NetworkingPrivateEnableNetworkTypeFunction() {
289 }
290
RunSync()291 bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
292 scoped_ptr<api::EnableNetworkType::Params> params =
293 api::EnableNetworkType::Params::Create(*args_);
294 EXTENSION_FUNCTION_VALIDATE(params);
295 return true;
296 }
297
298 ////////////////////////////////////////////////////////////////////////////////
299 // NetworkingPrivateDisableNetworkTypeFunction
300
301 NetworkingPrivateDisableNetworkTypeFunction::
~NetworkingPrivateDisableNetworkTypeFunction()302 ~NetworkingPrivateDisableNetworkTypeFunction() {
303 }
304
RunSync()305 bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
306 scoped_ptr<api::DisableNetworkType::Params> params =
307 api::DisableNetworkType::Params::Create(*args_);
308 EXTENSION_FUNCTION_VALIDATE(params);
309 return true;
310 }
311
312 ////////////////////////////////////////////////////////////////////////////////
313 // NetworkingPrivateRequestNetworkScanFunction
314
315 NetworkingPrivateRequestNetworkScanFunction::
~NetworkingPrivateRequestNetworkScanFunction()316 ~NetworkingPrivateRequestNetworkScanFunction() {
317 }
318
RunSync()319 bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
320 NetworkingPrivateServiceClient* service_client =
321 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
322 service_client->RequestNetworkScan();
323 return true;
324 }
325
326 ////////////////////////////////////////////////////////////////////////////////
327 // NetworkingPrivateStartConnectFunction
328
329 NetworkingPrivateStartConnectFunction::
~NetworkingPrivateStartConnectFunction()330 ~NetworkingPrivateStartConnectFunction() {
331 }
332
RunAsync()333 bool NetworkingPrivateStartConnectFunction::RunAsync() {
334 scoped_ptr<api::StartConnect::Params> params =
335 api::StartConnect::Params::Create(*args_);
336 EXTENSION_FUNCTION_VALIDATE(params);
337 NetworkingPrivateServiceClient* service_client =
338 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
339 service_client->StartConnect(
340 params->network_guid,
341 base::Bind(&NetworkingPrivateStartConnectFunction::ConnectionStartSuccess,
342 this),
343 base::Bind(&NetworkingPrivateStartConnectFunction::ConnectionStartFailed,
344 this));
345 return true;
346 }
347
ConnectionStartSuccess()348 void NetworkingPrivateStartConnectFunction::ConnectionStartSuccess() {
349 SendResponse(true);
350 }
351
ConnectionStartFailed(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)352 void NetworkingPrivateStartConnectFunction::ConnectionStartFailed(
353 const std::string& error_name,
354 const scoped_ptr<base::DictionaryValue> error_data) {
355 error_ = error_name;
356 SendResponse(false);
357 }
358
359 ////////////////////////////////////////////////////////////////////////////////
360 // NetworkingPrivateStartDisconnectFunction
361
362 NetworkingPrivateStartDisconnectFunction::
~NetworkingPrivateStartDisconnectFunction()363 ~NetworkingPrivateStartDisconnectFunction() {
364 }
365
RunAsync()366 bool NetworkingPrivateStartDisconnectFunction::RunAsync() {
367 scoped_ptr<api::StartDisconnect::Params> params =
368 api::StartDisconnect::Params::Create(*args_);
369 EXTENSION_FUNCTION_VALIDATE(params);
370 NetworkingPrivateServiceClient* service_client =
371 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
372 service_client->StartDisconnect(
373 params->network_guid,
374 base::Bind(
375 &NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess,
376 this),
377 base::Bind(
378 &NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed,
379 this));
380 return true;
381 }
382
DisconnectionStartSuccess()383 void NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess() {
384 SendResponse(true);
385 }
386
DisconnectionStartFailed(const std::string & error_name,const scoped_ptr<base::DictionaryValue> error_data)387 void NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed(
388 const std::string& error_name,
389 const scoped_ptr<base::DictionaryValue> error_data) {
390 error_ = error_name;
391 SendResponse(false);
392 }
393
394 ////////////////////////////////////////////////////////////////////////////////
395 // NetworkingPrivateVerifyDestinationFunction
396
397 NetworkingPrivateVerifyDestinationFunction::
~NetworkingPrivateVerifyDestinationFunction()398 ~NetworkingPrivateVerifyDestinationFunction() {}
399
RunAsync()400 bool NetworkingPrivateVerifyDestinationFunction::RunAsync() {
401 scoped_ptr<api::VerifyDestination::Params> params =
402 api::VerifyDestination::Params::Create(*args_);
403 EXTENSION_FUNCTION_VALIDATE(params);
404 NetworkingPrivateServiceClient* service_client =
405 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
406 service_client->VerifyDestination(
407 args_.Pass(),
408 base::Bind(
409 &NetworkingPrivateVerifyDestinationFunction::ResultCallback,
410 this),
411 base::Bind(
412 &NetworkingPrivateVerifyDestinationFunction::ErrorCallback,
413 this));
414 return true;
415 }
416
ResultCallback(bool result)417 void NetworkingPrivateVerifyDestinationFunction::ResultCallback(bool result) {
418 SetResult(new base::FundamentalValue(result));
419 SendResponse(true);
420 }
421
ErrorCallback(const std::string & error_name,const std::string & error)422 void NetworkingPrivateVerifyDestinationFunction::ErrorCallback(
423 const std::string& error_name, const std::string& error) {
424 error_ = error_name;
425 SendResponse(false);
426 }
427
428 ////////////////////////////////////////////////////////////////////////////////
429 // NetworkingPrivateVerifyAndEncryptCredentialsFunction
430
431 NetworkingPrivateVerifyAndEncryptCredentialsFunction::
~NetworkingPrivateVerifyAndEncryptCredentialsFunction()432 ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
433 }
434
RunAsync()435 bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() {
436 scoped_ptr<api::VerifyAndEncryptCredentials::Params> params =
437 api::VerifyAndEncryptCredentials::Params::Create(*args_);
438 EXTENSION_FUNCTION_VALIDATE(params);
439 NetworkingPrivateServiceClient* service_client =
440 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
441 service_client->VerifyAndEncryptCredentials(
442 args_.Pass(),
443 base::Bind(
444 &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback,
445 this),
446 base::Bind(
447 &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback,
448 this));
449 return true;
450 }
451
ResultCallback(const std::string & result)452 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback(
453 const std::string& result) {
454 SetResult(new base::StringValue(result));
455 SendResponse(true);
456 }
457
ErrorCallback(const std::string & error_name,const std::string & error)458 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback(
459 const std::string& error_name,
460 const std::string& error) {
461 error_ = error_name;
462 SendResponse(false);
463 }
464
465 ////////////////////////////////////////////////////////////////////////////////
466 // NetworkingPrivateVerifyAndEncryptDataFunction
467
468 NetworkingPrivateVerifyAndEncryptDataFunction::
~NetworkingPrivateVerifyAndEncryptDataFunction()469 ~NetworkingPrivateVerifyAndEncryptDataFunction() {
470 }
471
RunAsync()472 bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() {
473 scoped_ptr<api::VerifyAndEncryptData::Params> params =
474 api::VerifyAndEncryptData::Params::Create(*args_);
475 EXTENSION_FUNCTION_VALIDATE(params);
476 NetworkingPrivateServiceClient* service_client =
477 NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
478 service_client->VerifyAndEncryptData(
479 args_.Pass(),
480 base::Bind(
481 &NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback,
482 this),
483 base::Bind(
484 &NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback,
485 this));
486 return true;
487 }
488
ResultCallback(const std::string & result)489 void NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback(
490 const std::string& result) {
491 SetResult(new base::StringValue(result));
492 SendResponse(true);
493 }
494
ErrorCallback(const std::string & error_name,const std::string & error)495 void NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback(
496 const std::string& error_name, const std::string& error) {
497 error_ = error_name;
498 SendResponse(false);
499 }
500
501 ////////////////////////////////////////////////////////////////////////////////
502 // NetworkingPrivateSetWifiTDLSEnabledStateFunction
503
504 NetworkingPrivateSetWifiTDLSEnabledStateFunction::
~NetworkingPrivateSetWifiTDLSEnabledStateFunction()505 ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
506 }
507
RunAsync()508 bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() {
509 scoped_ptr<api::SetWifiTDLSEnabledState::Params> params =
510 api::SetWifiTDLSEnabledState::Params::Create(*args_);
511 EXTENSION_FUNCTION_VALIDATE(params);
512 SetError("not-implemented");
513 return false;
514 }
515
516 ////////////////////////////////////////////////////////////////////////////////
517 // NetworkingPrivateGetWifiTDLSStatusFunction
518
519 NetworkingPrivateGetWifiTDLSStatusFunction::
~NetworkingPrivateGetWifiTDLSStatusFunction()520 ~NetworkingPrivateGetWifiTDLSStatusFunction() {
521 }
522
RunAsync()523 bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() {
524 scoped_ptr<api::GetWifiTDLSStatus::Params> params =
525 api::GetWifiTDLSStatus::Params::Create(*args_);
526 EXTENSION_FUNCTION_VALIDATE(params);
527 SetError("not-implemented");
528 return false;
529 }
530
531 ////////////////////////////////////////////////////////////////////////////////
532 // NetworkingPrivateGetCaptivePortalStatusFunction
533
534 NetworkingPrivateGetCaptivePortalStatusFunction::
~NetworkingPrivateGetCaptivePortalStatusFunction()535 ~NetworkingPrivateGetCaptivePortalStatusFunction() {}
536
RunAsync()537 bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() {
538 scoped_ptr<api::GetCaptivePortalStatus::Params> params =
539 api::GetCaptivePortalStatus::Params::Create(*args_);
540 EXTENSION_FUNCTION_VALIDATE(params);
541 SetError("not-implemented");
542 return false;
543 }
544