src/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc

   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