networking_private_service_client.cc revision 6e8cce623b6e4fe0c9e4af605d675dd9d0338c38 
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  task_runner_->PostTaskAndReply(
178      FROM_HERE,
179      base::Bind(&WiFiService::GetProperties,
180                 base::Unretained(wifi_service_.get()),
181                 guid,
182                 properties.get(),
183                 error),
184      base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
185                 weak_factory_.GetWeakPtr(),
186                 service_callbacks->id,
187                 guid,
188                 base::Passed(&properties),
189                 base::Owned(error)));
190}
191
192void NetworkingPrivateServiceClient::GetManagedProperties(
193    const std::string& guid,
194    const DictionaryCallback& success_callback,
195    const FailureCallback& failure_callback) {
196  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
197  service_callbacks->failure_callback = failure_callback;
198  service_callbacks->get_properties_callback = success_callback;
199
200  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
201  std::string* error = new std::string;
202
203  task_runner_->PostTaskAndReply(
204      FROM_HERE,
205      base::Bind(&WiFiService::GetManagedProperties,
206                 base::Unretained(wifi_service_.get()),
207                 guid,
208                 properties.get(),
209                 error),
210      base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
211                 weak_factory_.GetWeakPtr(),
212                 service_callbacks->id,
213                 guid,
214                 base::Passed(&properties),
215                 base::Owned(error)));
216}
217
218void NetworkingPrivateServiceClient::GetState(
219    const std::string& guid,
220    const DictionaryCallback& success_callback,
221    const FailureCallback& failure_callback) {
222  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
223  service_callbacks->failure_callback = failure_callback;
224  service_callbacks->get_properties_callback = success_callback;
225
226  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
227  std::string* error = new std::string;
228
229  task_runner_->PostTaskAndReply(
230      FROM_HERE,
231      base::Bind(&WiFiService::GetState,
232                 base::Unretained(wifi_service_.get()),
233                 guid,
234                 properties.get(),
235                 error),
236      base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
237                 weak_factory_.GetWeakPtr(),
238                 service_callbacks->id,
239                 guid,
240                 base::Passed(&properties),
241                 base::Owned(error)));
242}
243
244void NetworkingPrivateServiceClient::SetProperties(
245    const std::string& guid,
246    scoped_ptr<base::DictionaryValue> properties,
247    const VoidCallback& success_callback,
248    const FailureCallback& failure_callback) {
249  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
250  service_callbacks->failure_callback = failure_callback;
251  service_callbacks->set_properties_callback = success_callback;
252
253  std::string* error = new std::string;
254
255  task_runner_->PostTaskAndReply(
256      FROM_HERE,
257      base::Bind(&WiFiService::SetProperties,
258                 base::Unretained(wifi_service_.get()),
259                 guid,
260                 base::Passed(&properties),
261                 error),
262      base::Bind(&NetworkingPrivateServiceClient::AfterSetProperties,
263                 weak_factory_.GetWeakPtr(),
264                 service_callbacks->id,
265                 base::Owned(error)));
266}
267
268void NetworkingPrivateServiceClient::CreateNetwork(
269    bool shared,
270    scoped_ptr<base::DictionaryValue> properties,
271    const StringCallback& success_callback,
272    const FailureCallback& failure_callback) {
273  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
274  service_callbacks->failure_callback = failure_callback;
275  service_callbacks->create_network_callback = success_callback;
276
277  std::string* network_guid = new std::string;
278  std::string* error = new std::string;
279
280  task_runner_->PostTaskAndReply(
281      FROM_HERE,
282      base::Bind(&WiFiService::CreateNetwork,
283                 base::Unretained(wifi_service_.get()),
284                 shared,
285                 base::Passed(&properties),
286                 network_guid,
287                 error),
288      base::Bind(&NetworkingPrivateServiceClient::AfterCreateNetwork,
289                 weak_factory_.GetWeakPtr(),
290                 service_callbacks->id,
291                 base::Owned(network_guid),
292                 base::Owned(error)));
293}
294
295void NetworkingPrivateServiceClient::GetNetworks(
296    const std::string& network_type,
297    bool configured_only,
298    bool visible_only,
299    int limit,
300    const NetworkListCallback& success_callback,
301    const FailureCallback& failure_callback) {
302  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
303  service_callbacks->failure_callback = failure_callback;
304  service_callbacks->get_visible_networks_callback = success_callback;
305
306  scoped_ptr<base::ListValue> networks(new base::ListValue);
307
308  // TODO(stevenjb/mef): Apply filters (configured, visible, limit).
309
310  task_runner_->PostTaskAndReply(
311      FROM_HERE,
312      base::Bind(&WiFiService::GetVisibleNetworks,
313                 base::Unretained(wifi_service_.get()),
314                 network_type,
315                 networks.get(),
316                 false),
317      base::Bind(&NetworkingPrivateServiceClient::AfterGetVisibleNetworks,
318                 weak_factory_.GetWeakPtr(),
319                 service_callbacks->id,
320                 base::Passed(&networks)));
321}
322
323void NetworkingPrivateServiceClient::StartConnect(
324    const std::string& guid,
325    const VoidCallback& success_callback,
326    const FailureCallback& failure_callback) {
327  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
328  service_callbacks->failure_callback = failure_callback;
329  service_callbacks->start_connect_callback = success_callback;
330
331  std::string* error = new std::string;
332
333  task_runner_->PostTaskAndReply(
334      FROM_HERE,
335      base::Bind(&WiFiService::StartConnect,
336                 base::Unretained(wifi_service_.get()),
337                 guid,
338                 error),
339      base::Bind(&NetworkingPrivateServiceClient::AfterStartConnect,
340                 weak_factory_.GetWeakPtr(),
341                 service_callbacks->id,
342                 base::Owned(error)));
343}
344
345void NetworkingPrivateServiceClient::StartDisconnect(
346    const std::string& guid,
347    const VoidCallback& success_callback,
348    const FailureCallback& failure_callback) {
349  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
350  service_callbacks->failure_callback = failure_callback;
351  service_callbacks->start_disconnect_callback = success_callback;
352
353  std::string* error = new std::string;
354
355  task_runner_->PostTaskAndReply(
356      FROM_HERE,
357      base::Bind(&WiFiService::StartDisconnect,
358                 base::Unretained(wifi_service_.get()),
359                 guid,
360                 error),
361      base::Bind(&NetworkingPrivateServiceClient::AfterStartDisconnect,
362                 weak_factory_.GetWeakPtr(),
363                 service_callbacks->id,
364                 base::Owned(error)));
365}
366
367void NetworkingPrivateServiceClient::VerifyDestination(
368    const VerificationProperties& verification_properties,
369    const BoolCallback& success_callback,
370    const FailureCallback& failure_callback) {
371  if (!crypto_verify_) {
372    failure_callback.Run(networking_private::kErrorNotSupported);
373    return;
374  }
375
376  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
377  service_callbacks->failure_callback = failure_callback;
378  service_callbacks->verify_destination_callback = success_callback;
379
380  CryptoVerify::Credentials credentials;
381  if (!GetVerificationCredentials(verification_properties, &credentials)) {
382    failure_callback.Run(networking_private::kErrorEncryptionError);
383    return;
384  }
385
386  bool* result = new bool;
387  std::string* error = new std::string;
388
389  task_runner_->PostTaskAndReply(
390      FROM_HERE,
391      base::Bind(&CryptoVerify::VerifyDestination,
392                 base::Unretained(crypto_verify_.get()),
393                 credentials,
394                 result,
395                 error),
396      base::Bind(&NetworkingPrivateServiceClient::AfterVerifyDestination,
397                 weak_factory_.GetWeakPtr(),
398                 service_callbacks->id,
399                 base::Owned(result),
400                 base::Owned(error)));
401}
402
403void NetworkingPrivateServiceClient::VerifyAndEncryptCredentials(
404    const std::string& guid,
405    const VerificationProperties& verification_properties,
406    const StringCallback& success_callback,
407    const FailureCallback& failure_callback) {
408  if (!crypto_verify_) {
409    failure_callback.Run(networking_private::kErrorNotSupported);
410    return;
411  }
412
413  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
414  service_callbacks->failure_callback = failure_callback;
415  service_callbacks->verify_and_encrypt_credentials_callback = success_callback;
416
417  CryptoVerify::Credentials credentials;
418  if (!GetVerificationCredentials(verification_properties, &credentials)) {
419    failure_callback.Run(networking_private::kErrorEncryptionError);
420    return;
421  }
422
423  CryptoVerify::VerifyAndEncryptCredentialsCallback callback_relay(base::Bind(
424      &AfterVerifyAndEncryptCredentialsRelay,
425      base::Bind(
426          &NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials,
427          weak_factory_.GetWeakPtr(),
428          service_callbacks->id),
429      base::MessageLoopProxy::current()));
430
431  task_runner_->PostTask(FROM_HERE,
432                         base::Bind(&CryptoVerify::VerifyAndEncryptCredentials,
433                                    base::Unretained(crypto_verify_.get()),
434                                    guid,
435                                    credentials,
436                                    callback_relay));
437}
438
439void NetworkingPrivateServiceClient::VerifyAndEncryptData(
440    const VerificationProperties& verification_properties,
441    const std::string& data,
442    const StringCallback& success_callback,
443    const FailureCallback& failure_callback) {
444  if (!crypto_verify_) {
445    failure_callback.Run(networking_private::kErrorNotSupported);
446    return;
447  }
448
449  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
450  service_callbacks->failure_callback = failure_callback;
451  service_callbacks->verify_and_encrypt_data_callback = success_callback;
452
453  CryptoVerify::Credentials credentials;
454  if (!GetVerificationCredentials(verification_properties, &credentials)) {
455    failure_callback.Run(networking_private::kErrorEncryptionError);
456    return;
457  }
458
459  std::string* result = new std::string;
460  std::string* error = new std::string;
461
462  task_runner_->PostTaskAndReply(
463      FROM_HERE,
464      base::Bind(&CryptoVerify::VerifyAndEncryptData,
465                 base::Unretained(crypto_verify_.get()),
466                 credentials,
467                 data,
468                 result,
469                 error),
470      base::Bind(&NetworkingPrivateServiceClient::AfterVerifyAndEncryptData,
471                 weak_factory_.GetWeakPtr(),
472                 service_callbacks->id,
473                 base::Owned(result),
474                 base::Owned(error)));
475}
476
477void NetworkingPrivateServiceClient::SetWifiTDLSEnabledState(
478    const std::string& ip_or_mac_address,
479    bool enabled,
480    const StringCallback& success_callback,
481    const FailureCallback& failure_callback) {
482  failure_callback.Run(networking_private::kErrorNotSupported);
483}
484
485void NetworkingPrivateServiceClient::GetWifiTDLSStatus(
486    const std::string& ip_or_mac_address,
487    const StringCallback& success_callback,
488    const FailureCallback& failure_callback) {
489  failure_callback.Run(networking_private::kErrorNotSupported);
490}
491
492void NetworkingPrivateServiceClient::GetCaptivePortalStatus(
493    const std::string& guid,
494    const StringCallback& success_callback,
495    const FailureCallback& failure_callback) {
496  failure_callback.Run(networking_private::kErrorNotSupported);
497}
498
499scoped_ptr<base::ListValue>
500NetworkingPrivateServiceClient::GetEnabledNetworkTypes() {
501  scoped_ptr<base::ListValue> network_list;
502  return network_list.Pass();
503}
504
505bool NetworkingPrivateServiceClient::EnableNetworkType(
506    const std::string& type) {
507  return false;
508}
509
510bool NetworkingPrivateServiceClient::DisableNetworkType(
511    const std::string& type) {
512  return false;
513}
514
515bool NetworkingPrivateServiceClient::RequestScan() {
516  task_runner_->PostTask(
517      FROM_HERE,
518      base::Bind(&WiFiService::RequestNetworkScan,
519                 base::Unretained(wifi_service_.get())));
520  return true;
521}
522
523////////////////////////////////////////////////////////////////////////////////
524
525void NetworkingPrivateServiceClient::AfterGetProperties(
526    ServiceCallbacksID callback_id,
527    const std::string& network_guid,
528    scoped_ptr<base::DictionaryValue> properties,
529    const std::string* error) {
530  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
531  DCHECK(service_callbacks);
532  if (!error->empty()) {
533    DCHECK(!service_callbacks->failure_callback.is_null());
534    service_callbacks->failure_callback.Run(*error);
535  } else {
536    DCHECK(!service_callbacks->get_properties_callback.is_null());
537    service_callbacks->get_properties_callback.Run(properties.Pass());
538  }
539  RemoveServiceCallbacks(callback_id);
540}
541
542void NetworkingPrivateServiceClient::AfterGetVisibleNetworks(
543    ServiceCallbacksID callback_id,
544    scoped_ptr<base::ListValue> networks) {
545  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
546  DCHECK(service_callbacks);
547  DCHECK(!service_callbacks->get_visible_networks_callback.is_null());
548  service_callbacks->get_visible_networks_callback.Run(networks.Pass());
549  RemoveServiceCallbacks(callback_id);
550}
551
552void NetworkingPrivateServiceClient::AfterSetProperties(
553    ServiceCallbacksID callback_id,
554    const std::string* error) {
555  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
556  DCHECK(service_callbacks);
557  if (!error->empty()) {
558    DCHECK(!service_callbacks->failure_callback.is_null());
559    service_callbacks->failure_callback.Run(*error);
560  } else {
561    DCHECK(!service_callbacks->set_properties_callback.is_null());
562    service_callbacks->set_properties_callback.Run();
563  }
564  RemoveServiceCallbacks(callback_id);
565}
566
567void NetworkingPrivateServiceClient::AfterCreateNetwork(
568    ServiceCallbacksID callback_id,
569    const std::string* network_guid,
570    const std::string* error) {
571  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
572  DCHECK(service_callbacks);
573  if (!error->empty()) {
574    DCHECK(!service_callbacks->failure_callback.is_null());
575    service_callbacks->failure_callback.Run(*error);
576  } else {
577    DCHECK(!service_callbacks->create_network_callback.is_null());
578    service_callbacks->create_network_callback.Run(*network_guid);
579  }
580  RemoveServiceCallbacks(callback_id);
581}
582
583void NetworkingPrivateServiceClient::AfterStartConnect(
584    ServiceCallbacksID callback_id,
585    const std::string* error) {
586  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
587  DCHECK(service_callbacks);
588  if (!error->empty()) {
589    DCHECK(!service_callbacks->failure_callback.is_null());
590    service_callbacks->failure_callback.Run(*error);
591  } else {
592    DCHECK(!service_callbacks->start_connect_callback.is_null());
593    service_callbacks->start_connect_callback.Run();
594  }
595  RemoveServiceCallbacks(callback_id);
596}
597
598void NetworkingPrivateServiceClient::AfterStartDisconnect(
599    ServiceCallbacksID callback_id,
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->failure_callback.is_null());
605    service_callbacks->failure_callback.Run(*error);
606  } else {
607    DCHECK(!service_callbacks->start_disconnect_callback.is_null());
608    service_callbacks->start_disconnect_callback.Run();
609  }
610  RemoveServiceCallbacks(callback_id);
611}
612
613void NetworkingPrivateServiceClient::AfterVerifyDestination(
614    ServiceCallbacksID callback_id,
615    const bool* result,
616    const std::string* error) {
617  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
618  DCHECK(service_callbacks);
619  if (!error->empty()) {
620    DCHECK(!service_callbacks->failure_callback.is_null());
621    service_callbacks->failure_callback.Run(*error);
622  } else {
623    DCHECK(!service_callbacks->verify_destination_callback.is_null());
624    service_callbacks->verify_destination_callback.Run(*result);
625  }
626  RemoveServiceCallbacks(callback_id);
627}
628
629void NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials(
630    ServiceCallbacksID callback_id,
631    const std::string& encrypted_data,
632    const std::string& error) {
633  DCHECK_CURRENTLY_ON(BrowserThread::UI);
634  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
635  DCHECK(service_callbacks);
636  if (!error.empty()) {
637    DCHECK(!service_callbacks->failure_callback.is_null());
638    service_callbacks->failure_callback.Run(error);
639  } else {
640    DCHECK(
641        !service_callbacks->verify_and_encrypt_credentials_callback.is_null());
642    service_callbacks->verify_and_encrypt_credentials_callback.Run(
643        encrypted_data);
644  }
645  RemoveServiceCallbacks(callback_id);
646}
647
648void NetworkingPrivateServiceClient::AfterVerifyAndEncryptData(
649    ServiceCallbacksID callback_id,
650    const std::string* result,
651    const std::string* error) {
652  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
653  DCHECK(service_callbacks);
654  if (!error->empty()) {
655    DCHECK(!service_callbacks->failure_callback.is_null());
656    service_callbacks->failure_callback.Run(*error);
657  } else {
658    DCHECK(!service_callbacks->verify_and_encrypt_data_callback.is_null());
659    service_callbacks->verify_and_encrypt_data_callback.Run(*result);
660  }
661  RemoveServiceCallbacks(callback_id);
662}
663
664void NetworkingPrivateServiceClient::OnNetworksChangedEventOnUIThread(
665    const std::vector<std::string>& network_guids) {
666  DCHECK_CURRENTLY_ON(BrowserThread::UI);
667  FOR_EACH_OBSERVER(Observer,
668                    network_events_observers_,
669                    OnNetworksChangedEvent(network_guids));
670}
671
672void NetworkingPrivateServiceClient::OnNetworkListChangedEventOnUIThread(
673    const std::vector<std::string>& network_guids) {
674  DCHECK_CURRENTLY_ON(BrowserThread::UI);
675  FOR_EACH_OBSERVER(Observer,
676                    network_events_observers_,
677                    OnNetworkListChangedEvent(network_guids));
678}
679
680}  // namespace extensions
681