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:: 30 ~NetworkingPrivateGetPropertiesFunction() { 31 } 32 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 50 void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess( 51 const std::string& network_guid, 52 const base::DictionaryValue& dictionary) { 53 SetResult(dictionary.DeepCopy()); 54 SendResponse(true); 55 } 56 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:: 68 ~NetworkingPrivateGetManagedPropertiesFunction() { 69 } 70 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 87 void NetworkingPrivateGetManagedPropertiesFunction::Success( 88 const std::string& network_guid, 89 const base::DictionaryValue& dictionary) { 90 SetResult(dictionary.DeepCopy()); 91 SendResponse(true); 92 } 93 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:: 105 ~NetworkingPrivateGetStateFunction() { 106 } 107 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 124 void NetworkingPrivateGetStateFunction::Success( 125 const std::string& network_guid, 126 const base::DictionaryValue& dictionary) { 127 SetResult(dictionary.DeepCopy()); 128 SendResponse(true); 129 } 130 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:: 142 ~NetworkingPrivateSetPropertiesFunction() { 143 } 144 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 163 void NetworkingPrivateSetPropertiesFunction::ResultCallback() { 164 SendResponse(true); 165 } 166 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:: 178 ~NetworkingPrivateCreateNetworkFunction() { 179 } 180 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 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 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:: 216 ~NetworkingPrivateGetNetworksFunction() { 217 } 218 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 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:: 245 ~NetworkingPrivateGetVisibleNetworksFunction() { 246 } 247 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 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:: 274 ~NetworkingPrivateGetEnabledNetworkTypesFunction() { 275 } 276 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:: 288 ~NetworkingPrivateEnableNetworkTypeFunction() { 289 } 290 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:: 302 ~NetworkingPrivateDisableNetworkTypeFunction() { 303 } 304 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:: 316 ~NetworkingPrivateRequestNetworkScanFunction() { 317 } 318 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:: 330 ~NetworkingPrivateStartConnectFunction() { 331 } 332 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 348 void NetworkingPrivateStartConnectFunction::ConnectionStartSuccess() { 349 SendResponse(true); 350 } 351 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:: 363 ~NetworkingPrivateStartDisconnectFunction() { 364 } 365 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 383 void NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess() { 384 SendResponse(true); 385 } 386 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:: 398 ~NetworkingPrivateVerifyDestinationFunction() {} 399 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 417 void NetworkingPrivateVerifyDestinationFunction::ResultCallback(bool result) { 418 SetResult(new base::FundamentalValue(result)); 419 SendResponse(true); 420 } 421 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:: 432 ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() { 433 } 434 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 452 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback( 453 const std::string& result) { 454 SetResult(new base::StringValue(result)); 455 SendResponse(true); 456 } 457 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:: 469 ~NetworkingPrivateVerifyAndEncryptDataFunction() { 470 } 471 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 489 void NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback( 490 const std::string& result) { 491 SetResult(new base::StringValue(result)); 492 SendResponse(true); 493 } 494 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:: 505 ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() { 506 } 507 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:: 520 ~NetworkingPrivateGetWifiTDLSStatusFunction() { 521 } 522 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:: 535 ~NetworkingPrivateGetCaptivePortalStatusFunction() {} 536 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
