networking_private_service_client.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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
18using content::BrowserThread;
19
20namespace extensions {
21
22namespace {
23
24const char kNetworkingPrivateSequenceTokenName[] = "NetworkingPrivate";
25
26bool 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.
50void 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|.
59void 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
71NetworkingPrivateServiceClient::CryptoVerify::CryptoVerify() {}
72NetworkingPrivateServiceClient::CryptoVerify::~CryptoVerify() {}
73
74NetworkingPrivateServiceClient::CryptoVerify::Credentials::Credentials() {}
75NetworkingPrivateServiceClient::CryptoVerify::Credentials::~Credentials() {}
76
77NetworkingPrivateServiceClient::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
111NetworkingPrivateServiceClient::~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
118NetworkingPrivateServiceClient::ServiceCallbacks::ServiceCallbacks() {}
119
120NetworkingPrivateServiceClient::ServiceCallbacks::~ServiceCallbacks() {}
121
122void 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
136void NetworkingPrivateServiceClient::AddObserver(Observer* observer) {
137  network_events_observers_.AddObserver(observer);
138}
139
140void NetworkingPrivateServiceClient::RemoveObserver(Observer* observer) {
141  network_events_observers_.RemoveObserver(observer);
142}
143
144void 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
152NetworkingPrivateServiceClient::ServiceCallbacks*
153NetworkingPrivateServiceClient::AddServiceCallbacks() {
154  ServiceCallbacks* service_callbacks = new ServiceCallbacks();
155  service_callbacks->id = callbacks_map_.Add(service_callbacks);
156  return service_callbacks;
157}
158
159void NetworkingPrivateServiceClient::RemoveServiceCallbacks(
160    ServiceCallbacksID callback_id) {
161  callbacks_map_.Remove(callback_id);
162}
163
164// NetworkingPrivateServiceClient implementation
165
166void 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
193void 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
220void 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
247void 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
271void 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
298void 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
327void 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
349void 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
371void 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
407void 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
443void 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
481void 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
489void 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
496void 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
503scoped_ptr<base::ListValue>
504NetworkingPrivateServiceClient::GetEnabledNetworkTypes() {
505  scoped_ptr<base::ListValue> network_list;
506  return network_list.Pass();
507}
508
509bool NetworkingPrivateServiceClient::EnableNetworkType(
510    const std::string& type) {
511  return false;
512}
513
514bool NetworkingPrivateServiceClient::DisableNetworkType(
515    const std::string& type) {
516  return false;
517}
518
519bool 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
529void 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
546void 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
556void 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
571void 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
587void 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
602void 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
617void 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
633void 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
652void 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
668void 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
676void 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