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 {
VerifyDestination(const VerificationProperties & properties)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
VerifyDestination(scoped_ptr<base::ListValue> args,bool * verified,std::string * error)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
VerifyAndEncryptCredentials(scoped_ptr<base::ListValue> args,const VerifyAndEncryptCredentialsCallback & callback)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
VerifyAndEncryptData(scoped_ptr<base::ListValue> args,std::string * base64_encoded_ciphertext,std::string * error)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.
ShutdownServicesOnWorkerThread(scoped_ptr<wifi::WiFiService> wifi_service,scoped_ptr<NetworkingPrivateServiceClient::CryptoVerify> crypto_verify)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|.
AfterVerifyAndEncryptCredentialsRelay(const NetworkingPrivateServiceClient::CryptoVerify::VerifyAndEncryptCredentialsCallback & callback,scoped_refptr<base::MessageLoopProxy> callback_loop_proxy,const std::string & key_data,const std::string & error)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
NetworkingPrivateServiceClient(wifi::WiFiService * wifi_service,CryptoVerify * crypto_verify)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
~NetworkingPrivateServiceClient()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*
Create()178 NetworkingPrivateServiceClient::CryptoVerify::Create() {
179 return new CryptoVerifyImpl();
180 }
181
ServiceCallbacks()182 NetworkingPrivateServiceClient::ServiceCallbacks::ServiceCallbacks() {}
183
~ServiceCallbacks()184 NetworkingPrivateServiceClient::ServiceCallbacks::~ServiceCallbacks() {}
185
Shutdown()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
AddObserver(Observer * observer)200 void NetworkingPrivateServiceClient::AddObserver(Observer* observer) {
201 network_events_observers_.AddObserver(observer);
202 }
203
RemoveObserver(Observer * observer)204 void NetworkingPrivateServiceClient::RemoveObserver(Observer* observer) {
205 network_events_observers_.RemoveObserver(observer);
206 }
207
OnNetworkChanged(net::NetworkChangeNotifier::ConnectionType type)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*
AddServiceCallbacks()217 NetworkingPrivateServiceClient::AddServiceCallbacks() {
218 ServiceCallbacks* service_callbacks = new ServiceCallbacks();
219 service_callbacks->id = callbacks_map_.Add(service_callbacks);
220 return service_callbacks;
221 }
222
RemoveServiceCallbacks(ServiceCallbacksID callback_id)223 void NetworkingPrivateServiceClient::RemoveServiceCallbacks(
224 ServiceCallbacksID callback_id) {
225 callbacks_map_.Remove(callback_id);
226 }
227
GetProperties(const std::string & network_guid,const DictionaryResultCallback & callback,const ErrorCallback & error_callback)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
GetManagedProperties(const std::string & network_guid,const DictionaryResultCallback & callback,const ErrorCallback & error_callback)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
GetState(const std::string & network_guid,const DictionaryResultCallback & callback,const ErrorCallback & error_callback)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
GetVisibleNetworks(const std::string & network_type,const ListResultCallback & callback)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
RequestNetworkScan()327 void NetworkingPrivateServiceClient::RequestNetworkScan() {
328 task_runner_->PostTask(
329 FROM_HERE,
330 base::Bind(&WiFiService::RequestNetworkScan,
331 base::Unretained(wifi_service_.get())));
332 }
333
SetProperties(const std::string & network_guid,const base::DictionaryValue & properties,const base::Closure & callback,const ErrorCallback & error_callback)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
CreateNetwork(bool shared,const base::DictionaryValue & properties,const StringResultCallback & callback,const ErrorCallback & error_callback)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
StartConnect(const std::string & network_guid,const base::Closure & callback,const ErrorCallback & error_callback)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
StartDisconnect(const std::string & network_guid,const base::Closure & callback,const ErrorCallback & error_callback)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
VerifyDestination(scoped_ptr<base::ListValue> args,const BoolResultCallback & callback,const CryptoErrorCallback & error_callback)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
VerifyAndEncryptCredentials(scoped_ptr<base::ListValue> args,const StringResultCallback & callback,const CryptoErrorCallback & error_callback)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
VerifyAndEncryptData(scoped_ptr<base::ListValue> args,const StringResultCallback & callback,const CryptoErrorCallback & error_callback)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
AfterGetProperties(ServiceCallbacksID callback_id,const std::string & network_guid,const base::DictionaryValue * properties,const std::string * error)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
AfterGetVisibleNetworks(ServiceCallbacksID callback_id,const base::ListValue * networks)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
AfterSetProperties(ServiceCallbacksID callback_id,const std::string * error)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
AfterCreateNetwork(ServiceCallbacksID callback_id,const std::string * network_guid,const std::string * error)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
AfterStartConnect(ServiceCallbacksID callback_id,const std::string * error)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
AfterStartDisconnect(ServiceCallbacksID callback_id,const std::string * error)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
AfterVerifyDestination(ServiceCallbacksID callback_id,const bool * result,const std::string * error)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
AfterVerifyAndEncryptCredentials(ServiceCallbacksID callback_id,const std::string & encrypted_data,const std::string & error)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
AfterVerifyAndEncryptData(ServiceCallbacksID callback_id,const std::string * result,const std::string * error)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
OnNetworksChangedEventOnUIThread(const std::vector<std::string> & network_guids)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
OnNetworkListChangedEventOnUIThread(const std::vector<std::string> & network_guids)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