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_service_client.h" 6 7 #include "base/base64.h" 8 #include "base/bind.h" 9 #include "base/sequenced_task_runner.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "base/strings/string_util.h" 12 #include "base/threading/worker_pool.h" 13 #include "chrome/browser/browser_process.h" 14 #include "chrome/browser/extensions/api/networking_private/networking_private_api.h" 15 #include "chrome/common/extensions/api/networking_private.h" 16 #include "content/public/browser/browser_thread.h" 17 18 using content::BrowserThread; 19 20 namespace extensions { 21 22 namespace { 23 24 const char kNetworkingPrivateSequenceTokenName[] = "NetworkingPrivate"; 25 26 bool GetVerificationCredentials( 27 const NetworkingPrivateDelegate::VerificationProperties& properties, 28 NetworkingPrivateServiceClient::CryptoVerify::Credentials* credentials) { 29 std::vector<std::string> data_parts; 30 data_parts.push_back(properties.device_ssid); 31 data_parts.push_back(properties.device_serial); 32 data_parts.push_back(properties.device_bssid); 33 data_parts.push_back(properties.public_key); 34 data_parts.push_back(properties.nonce); 35 credentials->unsigned_data = JoinString(data_parts, ","); 36 if (!base::Base64Decode(properties.signed_data, &credentials->signed_data)) { 37 LOG(ERROR) << "Failed to decode signed data: " << properties.signed_data; 38 return false; 39 } 40 credentials->certificate = properties.certificate; 41 credentials->device_bssid = properties.device_bssid; 42 if (!base::Base64Decode(properties.public_key, &credentials->public_key)) { 43 LOG(ERROR) << "Failed to decode public key"; 44 return false; 45 } 46 return true; 47 } 48 49 // Deletes WiFiService and CryptoVerify objects on worker thread. 50 void ShutdownServicesOnWorkerThread( 51 scoped_ptr<wifi::WiFiService> wifi_service, 52 scoped_ptr<NetworkingPrivateServiceClient::CryptoVerify> crypto_verify) { 53 DCHECK(wifi_service.get()); 54 DCHECK(crypto_verify.get()); 55 } 56 57 // Forwards call back from VerifyAndEncryptCredentials on random thread to 58 // |callback| on correct |callback_loop_proxy|. 59 void AfterVerifyAndEncryptCredentialsRelay( 60 const NetworkingPrivateServiceClient::CryptoVerify:: 61 VerifyAndEncryptCredentialsCallback& callback, 62 scoped_refptr<base::MessageLoopProxy> callback_loop_proxy, 63 const std::string& key_data, 64 const std::string& error) { 65 callback_loop_proxy->PostTask(FROM_HERE, 66 base::Bind(callback, key_data, error)); 67 } 68 69 } // namespace 70 71 NetworkingPrivateServiceClient::CryptoVerify::CryptoVerify() {} 72 NetworkingPrivateServiceClient::CryptoVerify::~CryptoVerify() {} 73 74 NetworkingPrivateServiceClient::CryptoVerify::Credentials::Credentials() {} 75 NetworkingPrivateServiceClient::CryptoVerify::Credentials::~Credentials() {} 76 77 NetworkingPrivateServiceClient::NetworkingPrivateServiceClient( 78 wifi::WiFiService* wifi_service, 79 CryptoVerify* crypto_verify) 80 : crypto_verify_(crypto_verify), 81 wifi_service_(wifi_service), 82 weak_factory_(this) { 83 sequence_token_ = BrowserThread::GetBlockingPool()-> 84 GetNamedSequenceToken(kNetworkingPrivateSequenceTokenName); 85 task_runner_ = BrowserThread::GetBlockingPool()-> 86 GetSequencedTaskRunnerWithShutdownBehavior( 87 sequence_token_, 88 base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN); 89 task_runner_->PostTask( 90 FROM_HERE, 91 base::Bind( 92 &WiFiService::Initialize, 93 base::Unretained(wifi_service_.get()), 94 task_runner_)); 95 task_runner_->PostTask( 96 FROM_HERE, 97 base::Bind( 98 &WiFiService::SetEventObservers, 99 base::Unretained(wifi_service_.get()), 100 base::MessageLoopProxy::current(), 101 base::Bind( 102 &NetworkingPrivateServiceClient::OnNetworksChangedEventOnUIThread, 103 weak_factory_.GetWeakPtr()), 104 base::Bind( 105 &NetworkingPrivateServiceClient:: 106 OnNetworkListChangedEventOnUIThread, 107 weak_factory_.GetWeakPtr()))); 108 net::NetworkChangeNotifier::AddNetworkChangeObserver(this); 109 } 110 111 NetworkingPrivateServiceClient::~NetworkingPrivateServiceClient() { 112 // Verify that these objects were passed to ShutdownServicesOnWorkerThread to 113 // be deleted after completion of all posted tasks. 114 DCHECK(!wifi_service_.get()); 115 DCHECK(!crypto_verify_.get()); 116 } 117 118 NetworkingPrivateServiceClient::ServiceCallbacks::ServiceCallbacks() {} 119 120 NetworkingPrivateServiceClient::ServiceCallbacks::~ServiceCallbacks() {} 121 122 void NetworkingPrivateServiceClient::Shutdown() { 123 DCHECK_CURRENTLY_ON(BrowserThread::UI); 124 net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this); 125 // Clear callbacks map to release callbacks from UI thread. 126 callbacks_map_.Clear(); 127 // Post ShutdownServicesOnWorkerThread task to delete services when all posted 128 // tasks are done. 129 task_runner_->PostTask( 130 FROM_HERE, 131 base::Bind(&ShutdownServicesOnWorkerThread, 132 base::Passed(&wifi_service_), 133 base::Passed(&crypto_verify_))); 134 } 135 136 void NetworkingPrivateServiceClient::AddObserver(Observer* observer) { 137 network_events_observers_.AddObserver(observer); 138 } 139 140 void NetworkingPrivateServiceClient::RemoveObserver(Observer* observer) { 141 network_events_observers_.RemoveObserver(observer); 142 } 143 144 void NetworkingPrivateServiceClient::OnNetworkChanged( 145 net::NetworkChangeNotifier::ConnectionType type) { 146 task_runner_->PostTask( 147 FROM_HERE, 148 base::Bind(&WiFiService::RequestConnectedNetworkUpdate, 149 base::Unretained(wifi_service_.get()))); 150 } 151 152 NetworkingPrivateServiceClient::ServiceCallbacks* 153 NetworkingPrivateServiceClient::AddServiceCallbacks() { 154 ServiceCallbacks* service_callbacks = new ServiceCallbacks(); 155 service_callbacks->id = callbacks_map_.Add(service_callbacks); 156 return service_callbacks; 157 } 158 159 void NetworkingPrivateServiceClient::RemoveServiceCallbacks( 160 ServiceCallbacksID callback_id) { 161 callbacks_map_.Remove(callback_id); 162 } 163 164 // NetworkingPrivateServiceClient implementation 165 166 void NetworkingPrivateServiceClient::GetProperties( 167 const std::string& guid, 168 const DictionaryCallback& success_callback, 169 const FailureCallback& failure_callback) { 170 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 171 service_callbacks->failure_callback = failure_callback; 172 service_callbacks->get_properties_callback = success_callback; 173 174 scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue); 175 std::string* error = new std::string; 176 177 base::DictionaryValue* properties_ptr = properties.get(); 178 task_runner_->PostTaskAndReply( 179 FROM_HERE, 180 base::Bind(&WiFiService::GetProperties, 181 base::Unretained(wifi_service_.get()), 182 guid, 183 properties_ptr, 184 error), 185 base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties, 186 weak_factory_.GetWeakPtr(), 187 service_callbacks->id, 188 guid, 189 base::Passed(&properties), 190 base::Owned(error))); 191 } 192 193 void NetworkingPrivateServiceClient::GetManagedProperties( 194 const std::string& guid, 195 const DictionaryCallback& success_callback, 196 const FailureCallback& failure_callback) { 197 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 198 service_callbacks->failure_callback = failure_callback; 199 service_callbacks->get_properties_callback = success_callback; 200 201 scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue); 202 std::string* error = new std::string; 203 204 base::DictionaryValue* properties_ptr = properties.get(); 205 task_runner_->PostTaskAndReply( 206 FROM_HERE, 207 base::Bind(&WiFiService::GetManagedProperties, 208 base::Unretained(wifi_service_.get()), 209 guid, 210 properties_ptr, 211 error), 212 base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties, 213 weak_factory_.GetWeakPtr(), 214 service_callbacks->id, 215 guid, 216 base::Passed(&properties), 217 base::Owned(error))); 218 } 219 220 void NetworkingPrivateServiceClient::GetState( 221 const std::string& guid, 222 const DictionaryCallback& success_callback, 223 const FailureCallback& failure_callback) { 224 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 225 service_callbacks->failure_callback = failure_callback; 226 service_callbacks->get_properties_callback = success_callback; 227 228 scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue); 229 std::string* error = new std::string; 230 231 base::DictionaryValue* properties_ptr = properties.get(); 232 task_runner_->PostTaskAndReply( 233 FROM_HERE, 234 base::Bind(&WiFiService::GetState, 235 base::Unretained(wifi_service_.get()), 236 guid, 237 properties_ptr, 238 error), 239 base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties, 240 weak_factory_.GetWeakPtr(), 241 service_callbacks->id, 242 guid, 243 base::Passed(&properties), 244 base::Owned(error))); 245 } 246 247 void NetworkingPrivateServiceClient::SetProperties( 248 const std::string& guid, 249 scoped_ptr<base::DictionaryValue> properties, 250 const VoidCallback& success_callback, 251 const FailureCallback& failure_callback) { 252 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 253 service_callbacks->failure_callback = failure_callback; 254 service_callbacks->set_properties_callback = success_callback; 255 256 std::string* error = new std::string; 257 258 task_runner_->PostTaskAndReply( 259 FROM_HERE, 260 base::Bind(&WiFiService::SetProperties, 261 base::Unretained(wifi_service_.get()), 262 guid, 263 base::Passed(&properties), 264 error), 265 base::Bind(&NetworkingPrivateServiceClient::AfterSetProperties, 266 weak_factory_.GetWeakPtr(), 267 service_callbacks->id, 268 base::Owned(error))); 269 } 270 271 void NetworkingPrivateServiceClient::CreateNetwork( 272 bool shared, 273 scoped_ptr<base::DictionaryValue> properties, 274 const StringCallback& success_callback, 275 const FailureCallback& failure_callback) { 276 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 277 service_callbacks->failure_callback = failure_callback; 278 service_callbacks->create_network_callback = success_callback; 279 280 std::string* network_guid = new std::string; 281 std::string* error = new std::string; 282 283 task_runner_->PostTaskAndReply( 284 FROM_HERE, 285 base::Bind(&WiFiService::CreateNetwork, 286 base::Unretained(wifi_service_.get()), 287 shared, 288 base::Passed(&properties), 289 network_guid, 290 error), 291 base::Bind(&NetworkingPrivateServiceClient::AfterCreateNetwork, 292 weak_factory_.GetWeakPtr(), 293 service_callbacks->id, 294 base::Owned(network_guid), 295 base::Owned(error))); 296 } 297 298 void NetworkingPrivateServiceClient::GetNetworks( 299 const std::string& network_type, 300 bool configured_only, 301 bool visible_only, 302 int limit, 303 const NetworkListCallback& success_callback, 304 const FailureCallback& failure_callback) { 305 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 306 service_callbacks->failure_callback = failure_callback; 307 service_callbacks->get_visible_networks_callback = success_callback; 308 309 scoped_ptr<base::ListValue> networks(new base::ListValue); 310 311 // TODO(stevenjb/mef): Apply filters (configured, visible, limit). 312 313 base::ListValue* networks_ptr = networks.get(); 314 task_runner_->PostTaskAndReply( 315 FROM_HERE, 316 base::Bind(&WiFiService::GetVisibleNetworks, 317 base::Unretained(wifi_service_.get()), 318 network_type, 319 networks_ptr, 320 false), 321 base::Bind(&NetworkingPrivateServiceClient::AfterGetVisibleNetworks, 322 weak_factory_.GetWeakPtr(), 323 service_callbacks->id, 324 base::Passed(&networks))); 325 } 326 327 void NetworkingPrivateServiceClient::StartConnect( 328 const std::string& guid, 329 const VoidCallback& success_callback, 330 const FailureCallback& failure_callback) { 331 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 332 service_callbacks->failure_callback = failure_callback; 333 service_callbacks->start_connect_callback = success_callback; 334 335 std::string* error = new std::string; 336 337 task_runner_->PostTaskAndReply( 338 FROM_HERE, 339 base::Bind(&WiFiService::StartConnect, 340 base::Unretained(wifi_service_.get()), 341 guid, 342 error), 343 base::Bind(&NetworkingPrivateServiceClient::AfterStartConnect, 344 weak_factory_.GetWeakPtr(), 345 service_callbacks->id, 346 base::Owned(error))); 347 } 348 349 void NetworkingPrivateServiceClient::StartDisconnect( 350 const std::string& guid, 351 const VoidCallback& success_callback, 352 const FailureCallback& failure_callback) { 353 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 354 service_callbacks->failure_callback = failure_callback; 355 service_callbacks->start_disconnect_callback = success_callback; 356 357 std::string* error = new std::string; 358 359 task_runner_->PostTaskAndReply( 360 FROM_HERE, 361 base::Bind(&WiFiService::StartDisconnect, 362 base::Unretained(wifi_service_.get()), 363 guid, 364 error), 365 base::Bind(&NetworkingPrivateServiceClient::AfterStartDisconnect, 366 weak_factory_.GetWeakPtr(), 367 service_callbacks->id, 368 base::Owned(error))); 369 } 370 371 void NetworkingPrivateServiceClient::VerifyDestination( 372 const VerificationProperties& verification_properties, 373 const BoolCallback& success_callback, 374 const FailureCallback& failure_callback) { 375 if (!crypto_verify_) { 376 failure_callback.Run(networking_private::kErrorNotSupported); 377 return; 378 } 379 380 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 381 service_callbacks->failure_callback = failure_callback; 382 service_callbacks->verify_destination_callback = success_callback; 383 384 CryptoVerify::Credentials credentials; 385 if (!GetVerificationCredentials(verification_properties, &credentials)) { 386 failure_callback.Run(networking_private::kErrorEncryptionError); 387 return; 388 } 389 390 bool* result = new bool; 391 std::string* error = new std::string; 392 393 task_runner_->PostTaskAndReply( 394 FROM_HERE, 395 base::Bind(&CryptoVerify::VerifyDestination, 396 base::Unretained(crypto_verify_.get()), 397 credentials, 398 result, 399 error), 400 base::Bind(&NetworkingPrivateServiceClient::AfterVerifyDestination, 401 weak_factory_.GetWeakPtr(), 402 service_callbacks->id, 403 base::Owned(result), 404 base::Owned(error))); 405 } 406 407 void NetworkingPrivateServiceClient::VerifyAndEncryptCredentials( 408 const std::string& guid, 409 const VerificationProperties& verification_properties, 410 const StringCallback& success_callback, 411 const FailureCallback& failure_callback) { 412 if (!crypto_verify_) { 413 failure_callback.Run(networking_private::kErrorNotSupported); 414 return; 415 } 416 417 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 418 service_callbacks->failure_callback = failure_callback; 419 service_callbacks->verify_and_encrypt_credentials_callback = success_callback; 420 421 CryptoVerify::Credentials credentials; 422 if (!GetVerificationCredentials(verification_properties, &credentials)) { 423 failure_callback.Run(networking_private::kErrorEncryptionError); 424 return; 425 } 426 427 CryptoVerify::VerifyAndEncryptCredentialsCallback callback_relay(base::Bind( 428 &AfterVerifyAndEncryptCredentialsRelay, 429 base::Bind( 430 &NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials, 431 weak_factory_.GetWeakPtr(), 432 service_callbacks->id), 433 base::MessageLoopProxy::current())); 434 435 task_runner_->PostTask(FROM_HERE, 436 base::Bind(&CryptoVerify::VerifyAndEncryptCredentials, 437 base::Unretained(crypto_verify_.get()), 438 guid, 439 credentials, 440 callback_relay)); 441 } 442 443 void NetworkingPrivateServiceClient::VerifyAndEncryptData( 444 const VerificationProperties& verification_properties, 445 const std::string& data, 446 const StringCallback& success_callback, 447 const FailureCallback& failure_callback) { 448 if (!crypto_verify_) { 449 failure_callback.Run(networking_private::kErrorNotSupported); 450 return; 451 } 452 453 ServiceCallbacks* service_callbacks = AddServiceCallbacks(); 454 service_callbacks->failure_callback = failure_callback; 455 service_callbacks->verify_and_encrypt_data_callback = success_callback; 456 457 CryptoVerify::Credentials credentials; 458 if (!GetVerificationCredentials(verification_properties, &credentials)) { 459 failure_callback.Run(networking_private::kErrorEncryptionError); 460 return; 461 } 462 463 std::string* result = new std::string; 464 std::string* error = new std::string; 465 466 task_runner_->PostTaskAndReply( 467 FROM_HERE, 468 base::Bind(&CryptoVerify::VerifyAndEncryptData, 469 base::Unretained(crypto_verify_.get()), 470 credentials, 471 data, 472 result, 473 error), 474 base::Bind(&NetworkingPrivateServiceClient::AfterVerifyAndEncryptData, 475 weak_factory_.GetWeakPtr(), 476 service_callbacks->id, 477 base::Owned(result), 478 base::Owned(error))); 479 } 480 481 void NetworkingPrivateServiceClient::SetWifiTDLSEnabledState( 482 const std::string& ip_or_mac_address, 483 bool enabled, 484 const StringCallback& success_callback, 485 const FailureCallback& failure_callback) { 486 failure_callback.Run(networking_private::kErrorNotSupported); 487 } 488 489 void NetworkingPrivateServiceClient::GetWifiTDLSStatus( 490 const std::string& ip_or_mac_address, 491 const StringCallback& success_callback, 492 const FailureCallback& failure_callback) { 493 failure_callback.Run(networking_private::kErrorNotSupported); 494 } 495 496 void NetworkingPrivateServiceClient::GetCaptivePortalStatus( 497 const std::string& guid, 498 const StringCallback& success_callback, 499 const FailureCallback& failure_callback) { 500 failure_callback.Run(networking_private::kErrorNotSupported); 501 } 502 503 scoped_ptr<base::ListValue> 504 NetworkingPrivateServiceClient::GetEnabledNetworkTypes() { 505 scoped_ptr<base::ListValue> network_list; 506 return network_list.Pass(); 507 } 508 509 bool NetworkingPrivateServiceClient::EnableNetworkType( 510 const std::string& type) { 511 return false; 512 } 513 514 bool NetworkingPrivateServiceClient::DisableNetworkType( 515 const std::string& type) { 516 return false; 517 } 518 519 bool NetworkingPrivateServiceClient::RequestScan() { 520 task_runner_->PostTask( 521 FROM_HERE, 522 base::Bind(&WiFiService::RequestNetworkScan, 523 base::Unretained(wifi_service_.get()))); 524 return true; 525 } 526 527 //////////////////////////////////////////////////////////////////////////////// 528 529 void NetworkingPrivateServiceClient::AfterGetProperties( 530 ServiceCallbacksID callback_id, 531 const std::string& network_guid, 532 scoped_ptr<base::DictionaryValue> properties, 533 const std::string* error) { 534 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 535 DCHECK(service_callbacks); 536 if (!error->empty()) { 537 DCHECK(!service_callbacks->failure_callback.is_null()); 538 service_callbacks->failure_callback.Run(*error); 539 } else { 540 DCHECK(!service_callbacks->get_properties_callback.is_null()); 541 service_callbacks->get_properties_callback.Run(properties.Pass()); 542 } 543 RemoveServiceCallbacks(callback_id); 544 } 545 546 void NetworkingPrivateServiceClient::AfterGetVisibleNetworks( 547 ServiceCallbacksID callback_id, 548 scoped_ptr<base::ListValue> networks) { 549 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 550 DCHECK(service_callbacks); 551 DCHECK(!service_callbacks->get_visible_networks_callback.is_null()); 552 service_callbacks->get_visible_networks_callback.Run(networks.Pass()); 553 RemoveServiceCallbacks(callback_id); 554 } 555 556 void NetworkingPrivateServiceClient::AfterSetProperties( 557 ServiceCallbacksID callback_id, 558 const std::string* error) { 559 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 560 DCHECK(service_callbacks); 561 if (!error->empty()) { 562 DCHECK(!service_callbacks->failure_callback.is_null()); 563 service_callbacks->failure_callback.Run(*error); 564 } else { 565 DCHECK(!service_callbacks->set_properties_callback.is_null()); 566 service_callbacks->set_properties_callback.Run(); 567 } 568 RemoveServiceCallbacks(callback_id); 569 } 570 571 void NetworkingPrivateServiceClient::AfterCreateNetwork( 572 ServiceCallbacksID callback_id, 573 const std::string* network_guid, 574 const std::string* error) { 575 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 576 DCHECK(service_callbacks); 577 if (!error->empty()) { 578 DCHECK(!service_callbacks->failure_callback.is_null()); 579 service_callbacks->failure_callback.Run(*error); 580 } else { 581 DCHECK(!service_callbacks->create_network_callback.is_null()); 582 service_callbacks->create_network_callback.Run(*network_guid); 583 } 584 RemoveServiceCallbacks(callback_id); 585 } 586 587 void NetworkingPrivateServiceClient::AfterStartConnect( 588 ServiceCallbacksID callback_id, 589 const std::string* error) { 590 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 591 DCHECK(service_callbacks); 592 if (!error->empty()) { 593 DCHECK(!service_callbacks->failure_callback.is_null()); 594 service_callbacks->failure_callback.Run(*error); 595 } else { 596 DCHECK(!service_callbacks->start_connect_callback.is_null()); 597 service_callbacks->start_connect_callback.Run(); 598 } 599 RemoveServiceCallbacks(callback_id); 600 } 601 602 void NetworkingPrivateServiceClient::AfterStartDisconnect( 603 ServiceCallbacksID callback_id, 604 const std::string* error) { 605 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 606 DCHECK(service_callbacks); 607 if (!error->empty()) { 608 DCHECK(!service_callbacks->failure_callback.is_null()); 609 service_callbacks->failure_callback.Run(*error); 610 } else { 611 DCHECK(!service_callbacks->start_disconnect_callback.is_null()); 612 service_callbacks->start_disconnect_callback.Run(); 613 } 614 RemoveServiceCallbacks(callback_id); 615 } 616 617 void NetworkingPrivateServiceClient::AfterVerifyDestination( 618 ServiceCallbacksID callback_id, 619 const bool* result, 620 const std::string* error) { 621 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 622 DCHECK(service_callbacks); 623 if (!error->empty()) { 624 DCHECK(!service_callbacks->failure_callback.is_null()); 625 service_callbacks->failure_callback.Run(*error); 626 } else { 627 DCHECK(!service_callbacks->verify_destination_callback.is_null()); 628 service_callbacks->verify_destination_callback.Run(*result); 629 } 630 RemoveServiceCallbacks(callback_id); 631 } 632 633 void NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials( 634 ServiceCallbacksID callback_id, 635 const std::string& encrypted_data, 636 const std::string& error) { 637 DCHECK_CURRENTLY_ON(BrowserThread::UI); 638 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 639 DCHECK(service_callbacks); 640 if (!error.empty()) { 641 DCHECK(!service_callbacks->failure_callback.is_null()); 642 service_callbacks->failure_callback.Run(error); 643 } else { 644 DCHECK( 645 !service_callbacks->verify_and_encrypt_credentials_callback.is_null()); 646 service_callbacks->verify_and_encrypt_credentials_callback.Run( 647 encrypted_data); 648 } 649 RemoveServiceCallbacks(callback_id); 650 } 651 652 void NetworkingPrivateServiceClient::AfterVerifyAndEncryptData( 653 ServiceCallbacksID callback_id, 654 const std::string* result, 655 const std::string* error) { 656 ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); 657 DCHECK(service_callbacks); 658 if (!error->empty()) { 659 DCHECK(!service_callbacks->failure_callback.is_null()); 660 service_callbacks->failure_callback.Run(*error); 661 } else { 662 DCHECK(!service_callbacks->verify_and_encrypt_data_callback.is_null()); 663 service_callbacks->verify_and_encrypt_data_callback.Run(*result); 664 } 665 RemoveServiceCallbacks(callback_id); 666 } 667 668 void NetworkingPrivateServiceClient::OnNetworksChangedEventOnUIThread( 669 const std::vector<std::string>& network_guids) { 670 DCHECK_CURRENTLY_ON(BrowserThread::UI); 671 FOR_EACH_OBSERVER(Observer, 672 network_events_observers_, 673 OnNetworksChangedEvent(network_guids)); 674 } 675 676 void NetworkingPrivateServiceClient::OnNetworkListChangedEventOnUIThread( 677 const std::vector<std::string>& network_guids) { 678 DCHECK_CURRENTLY_ON(BrowserThread::UI); 679 FOR_EACH_OBSERVER(Observer, 680 network_events_observers_, 681 OnNetworkListChangedEvent(network_guids)); 682 } 683 684 } // namespace extensions 685
