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