OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "dbus/test_service.h" | 5 #include "dbus/test_service.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <string> | 8 #include <string> |
9 #include <utility> | 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
(...skipping 291 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
302 LOG(ERROR) << "The number of methods does not match"; | 302 LOG(ERROR) << "The number of methods does not match"; |
303 } | 303 } |
304 message_loop->Run(); | 304 message_loop->Run(); |
305 } | 305 } |
306 | 306 |
307 void TestService::Echo(MethodCall* method_call, | 307 void TestService::Echo(MethodCall* method_call, |
308 ExportedObject::ResponseSender response_sender) { | 308 ExportedObject::ResponseSender response_sender) { |
309 MessageReader reader(method_call); | 309 MessageReader reader(method_call); |
310 std::string text_message; | 310 std::string text_message; |
311 if (!reader.PopString(&text_message)) { | 311 if (!reader.PopString(&text_message)) { |
312 response_sender.Run(scoped_ptr<Response>()); | 312 response_sender.Run(std::unique_ptr<Response>()); |
313 return; | 313 return; |
314 } | 314 } |
315 | 315 |
316 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 316 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
317 MessageWriter writer(response.get()); | 317 MessageWriter writer(response.get()); |
318 writer.AppendString(text_message); | 318 writer.AppendString(text_message); |
319 response_sender.Run(std::move(response)); | 319 response_sender.Run(std::move(response)); |
320 } | 320 } |
321 | 321 |
322 void TestService::SlowEcho(MethodCall* method_call, | 322 void TestService::SlowEcho(MethodCall* method_call, |
323 ExportedObject::ResponseSender response_sender) { | 323 ExportedObject::ResponseSender response_sender) { |
324 base::PlatformThread::Sleep(TestTimeouts::tiny_timeout()); | 324 base::PlatformThread::Sleep(TestTimeouts::tiny_timeout()); |
325 Echo(method_call, response_sender); | 325 Echo(method_call, response_sender); |
326 } | 326 } |
327 | 327 |
328 void TestService::AsyncEcho(MethodCall* method_call, | 328 void TestService::AsyncEcho(MethodCall* method_call, |
329 ExportedObject::ResponseSender response_sender) { | 329 ExportedObject::ResponseSender response_sender) { |
330 // Schedule a call to Echo() to send an asynchronous response after we return. | 330 // Schedule a call to Echo() to send an asynchronous response after we return. |
331 message_loop()->PostDelayedTask(FROM_HERE, | 331 message_loop()->PostDelayedTask(FROM_HERE, |
332 base::Bind(&TestService::Echo, | 332 base::Bind(&TestService::Echo, |
333 base::Unretained(this), | 333 base::Unretained(this), |
334 method_call, | 334 method_call, |
335 response_sender), | 335 response_sender), |
336 TestTimeouts::tiny_timeout()); | 336 TestTimeouts::tiny_timeout()); |
337 } | 337 } |
338 | 338 |
339 void TestService::BrokenMethod(MethodCall* method_call, | 339 void TestService::BrokenMethod(MethodCall* method_call, |
340 ExportedObject::ResponseSender response_sender) { | 340 ExportedObject::ResponseSender response_sender) { |
341 response_sender.Run(scoped_ptr<Response>()); | 341 response_sender.Run(std::unique_ptr<Response>()); |
342 } | 342 } |
343 | 343 |
344 | 344 |
345 void TestService::GetAllProperties( | 345 void TestService::GetAllProperties( |
346 MethodCall* method_call, | 346 MethodCall* method_call, |
347 ExportedObject::ResponseSender response_sender) { | 347 ExportedObject::ResponseSender response_sender) { |
348 MessageReader reader(method_call); | 348 MessageReader reader(method_call); |
349 std::string interface; | 349 std::string interface; |
350 if (!reader.PopString(&interface)) { | 350 if (!reader.PopString(&interface)) { |
351 response_sender.Run(scoped_ptr<Response>()); | 351 response_sender.Run(std::unique_ptr<Response>()); |
352 return; | 352 return; |
353 } | 353 } |
354 | 354 |
355 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 355 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
356 MessageWriter writer(response.get()); | 356 MessageWriter writer(response.get()); |
357 | 357 |
358 AddPropertiesToWriter(&writer); | 358 AddPropertiesToWriter(&writer); |
359 | 359 |
360 response_sender.Run(std::move(response)); | 360 response_sender.Run(std::move(response)); |
361 } | 361 } |
362 | 362 |
363 void TestService::GetProperty(MethodCall* method_call, | 363 void TestService::GetProperty(MethodCall* method_call, |
364 ExportedObject::ResponseSender response_sender) { | 364 ExportedObject::ResponseSender response_sender) { |
365 MessageReader reader(method_call); | 365 MessageReader reader(method_call); |
366 std::string interface; | 366 std::string interface; |
367 if (!reader.PopString(&interface)) { | 367 if (!reader.PopString(&interface)) { |
368 response_sender.Run(scoped_ptr<Response>()); | 368 response_sender.Run(std::unique_ptr<Response>()); |
369 return; | 369 return; |
370 } | 370 } |
371 | 371 |
372 std::string name; | 372 std::string name; |
373 if (!reader.PopString(&name)) { | 373 if (!reader.PopString(&name)) { |
374 response_sender.Run(scoped_ptr<Response>()); | 374 response_sender.Run(std::unique_ptr<Response>()); |
375 return; | 375 return; |
376 } | 376 } |
377 | 377 |
378 if (name == "Name") { | 378 if (name == "Name") { |
379 // Return the previous value for the "Name" property: | 379 // Return the previous value for the "Name" property: |
380 // Variant<"TestService"> | 380 // Variant<"TestService"> |
381 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 381 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
382 MessageWriter writer(response.get()); | 382 MessageWriter writer(response.get()); |
383 | 383 |
384 writer.AppendVariantOfString("TestService"); | 384 writer.AppendVariantOfString("TestService"); |
385 | 385 |
386 response_sender.Run(std::move(response)); | 386 response_sender.Run(std::move(response)); |
387 } else if (name == "Version") { | 387 } else if (name == "Version") { |
388 // Return a new value for the "Version" property: | 388 // Return a new value for the "Version" property: |
389 // Variant<20> | 389 // Variant<20> |
390 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 390 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
391 MessageWriter writer(response.get()); | 391 MessageWriter writer(response.get()); |
392 | 392 |
393 writer.AppendVariantOfInt16(20); | 393 writer.AppendVariantOfInt16(20); |
394 | 394 |
395 response_sender.Run(std::move(response)); | 395 response_sender.Run(std::move(response)); |
396 } else if (name == "Methods") { | 396 } else if (name == "Methods") { |
397 // Return the previous value for the "Methods" property: | 397 // Return the previous value for the "Methods" property: |
398 // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]> | 398 // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]> |
399 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 399 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
400 MessageWriter writer(response.get()); | 400 MessageWriter writer(response.get()); |
401 MessageWriter variant_writer(NULL); | 401 MessageWriter variant_writer(NULL); |
402 MessageWriter variant_array_writer(NULL); | 402 MessageWriter variant_array_writer(NULL); |
403 | 403 |
404 writer.OpenVariant("as", &variant_writer); | 404 writer.OpenVariant("as", &variant_writer); |
405 variant_writer.OpenArray("s", &variant_array_writer); | 405 variant_writer.OpenArray("s", &variant_array_writer); |
406 variant_array_writer.AppendString("Echo"); | 406 variant_array_writer.AppendString("Echo"); |
407 variant_array_writer.AppendString("SlowEcho"); | 407 variant_array_writer.AppendString("SlowEcho"); |
408 variant_array_writer.AppendString("AsyncEcho"); | 408 variant_array_writer.AppendString("AsyncEcho"); |
409 variant_array_writer.AppendString("BrokenMethod"); | 409 variant_array_writer.AppendString("BrokenMethod"); |
410 variant_writer.CloseContainer(&variant_array_writer); | 410 variant_writer.CloseContainer(&variant_array_writer); |
411 writer.CloseContainer(&variant_writer); | 411 writer.CloseContainer(&variant_writer); |
412 | 412 |
413 response_sender.Run(std::move(response)); | 413 response_sender.Run(std::move(response)); |
414 } else if (name == "Objects") { | 414 } else if (name == "Objects") { |
415 // Return the previous value for the "Objects" property: | 415 // Return the previous value for the "Objects" property: |
416 // Variant<[objectpath:"/TestObjectPath"]> | 416 // Variant<[objectpath:"/TestObjectPath"]> |
417 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 417 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
418 MessageWriter writer(response.get()); | 418 MessageWriter writer(response.get()); |
419 MessageWriter variant_writer(NULL); | 419 MessageWriter variant_writer(NULL); |
420 MessageWriter variant_array_writer(NULL); | 420 MessageWriter variant_array_writer(NULL); |
421 | 421 |
422 writer.OpenVariant("ao", &variant_writer); | 422 writer.OpenVariant("ao", &variant_writer); |
423 variant_writer.OpenArray("o", &variant_array_writer); | 423 variant_writer.OpenArray("o", &variant_array_writer); |
424 variant_array_writer.AppendObjectPath(ObjectPath("/TestObjectPath")); | 424 variant_array_writer.AppendObjectPath(ObjectPath("/TestObjectPath")); |
425 variant_writer.CloseContainer(&variant_array_writer); | 425 variant_writer.CloseContainer(&variant_array_writer); |
426 writer.CloseContainer(&variant_writer); | 426 writer.CloseContainer(&variant_writer); |
427 | 427 |
428 response_sender.Run(std::move(response)); | 428 response_sender.Run(std::move(response)); |
429 } else if (name == "Bytes") { | 429 } else if (name == "Bytes") { |
430 // Return the previous value for the "Bytes" property: | 430 // Return the previous value for the "Bytes" property: |
431 // Variant<[0x54, 0x65, 0x73, 0x74]> | 431 // Variant<[0x54, 0x65, 0x73, 0x74]> |
432 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 432 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
433 MessageWriter writer(response.get()); | 433 MessageWriter writer(response.get()); |
434 MessageWriter variant_writer(NULL); | 434 MessageWriter variant_writer(NULL); |
435 MessageWriter variant_array_writer(NULL); | 435 MessageWriter variant_array_writer(NULL); |
436 | 436 |
437 writer.OpenVariant("ay", &variant_writer); | 437 writer.OpenVariant("ay", &variant_writer); |
438 const uint8_t bytes[] = {0x54, 0x65, 0x73, 0x74}; | 438 const uint8_t bytes[] = {0x54, 0x65, 0x73, 0x74}; |
439 variant_writer.AppendArrayOfBytes(bytes, sizeof(bytes)); | 439 variant_writer.AppendArrayOfBytes(bytes, sizeof(bytes)); |
440 writer.CloseContainer(&variant_writer); | 440 writer.CloseContainer(&variant_writer); |
441 | 441 |
442 response_sender.Run(std::move(response)); | 442 response_sender.Run(std::move(response)); |
443 } else { | 443 } else { |
444 // Return error. | 444 // Return error. |
445 response_sender.Run(scoped_ptr<Response>()); | 445 response_sender.Run(std::unique_ptr<Response>()); |
446 return; | 446 return; |
447 } | 447 } |
448 } | 448 } |
449 | 449 |
450 void TestService::SetProperty(MethodCall* method_call, | 450 void TestService::SetProperty(MethodCall* method_call, |
451 ExportedObject::ResponseSender response_sender) { | 451 ExportedObject::ResponseSender response_sender) { |
452 MessageReader reader(method_call); | 452 MessageReader reader(method_call); |
453 std::string interface; | 453 std::string interface; |
454 if (!reader.PopString(&interface)) { | 454 if (!reader.PopString(&interface)) { |
455 response_sender.Run(scoped_ptr<Response>()); | 455 response_sender.Run(std::unique_ptr<Response>()); |
456 return; | 456 return; |
457 } | 457 } |
458 | 458 |
459 std::string name; | 459 std::string name; |
460 if (!reader.PopString(&name)) { | 460 if (!reader.PopString(&name)) { |
461 response_sender.Run(scoped_ptr<Response>()); | 461 response_sender.Run(std::unique_ptr<Response>()); |
462 return; | 462 return; |
463 } | 463 } |
464 | 464 |
465 if (name != "Name") { | 465 if (name != "Name") { |
466 response_sender.Run(scoped_ptr<Response>()); | 466 response_sender.Run(std::unique_ptr<Response>()); |
467 return; | 467 return; |
468 } | 468 } |
469 | 469 |
470 std::string value; | 470 std::string value; |
471 if (!reader.PopVariantOfString(&value)) { | 471 if (!reader.PopVariantOfString(&value)) { |
472 response_sender.Run(scoped_ptr<Response>()); | 472 response_sender.Run(std::unique_ptr<Response>()); |
473 return; | 473 return; |
474 } | 474 } |
475 | 475 |
476 SendPropertyChangedSignal(value); | 476 SendPropertyChangedSignal(value); |
477 | 477 |
478 response_sender.Run(Response::FromMethodCall(method_call)); | 478 response_sender.Run(Response::FromMethodCall(method_call)); |
479 } | 479 } |
480 | 480 |
481 void TestService::PerformAction( | 481 void TestService::PerformAction( |
482 MethodCall* method_call, | 482 MethodCall* method_call, |
483 ExportedObject::ResponseSender response_sender) { | 483 ExportedObject::ResponseSender response_sender) { |
484 MessageReader reader(method_call); | 484 MessageReader reader(method_call); |
485 std::string action; | 485 std::string action; |
486 ObjectPath object_path; | 486 ObjectPath object_path; |
487 if (!reader.PopString(&action) || !reader.PopObjectPath(&object_path)) { | 487 if (!reader.PopString(&action) || !reader.PopObjectPath(&object_path)) { |
488 response_sender.Run(scoped_ptr<Response>()); | 488 response_sender.Run(std::unique_ptr<Response>()); |
489 return; | 489 return; |
490 } | 490 } |
491 | 491 |
492 if (action == "AddObject") { | 492 if (action == "AddObject") { |
493 AddObject(object_path); | 493 AddObject(object_path); |
494 } else if (action == "RemoveObject") { | 494 } else if (action == "RemoveObject") { |
495 RemoveObject(object_path); | 495 RemoveObject(object_path); |
496 } else if (action == "SetSendImmediatePropertiesChanged") { | 496 } else if (action == "SetSendImmediatePropertiesChanged") { |
497 SetSendImmediatePropertiesChanged(); | 497 SetSendImmediatePropertiesChanged(); |
498 } else if (action == "ReleaseOwnership") { | 498 } else if (action == "ReleaseOwnership") { |
499 ReleaseOwnership(base::Bind(&TestService::PerformActionResponse, | 499 ReleaseOwnership(base::Bind(&TestService::PerformActionResponse, |
500 base::Unretained(this), | 500 base::Unretained(this), |
501 method_call, response_sender)); | 501 method_call, response_sender)); |
502 return; | 502 return; |
503 } else if (action == "Ownership") { | 503 } else if (action == "Ownership") { |
504 ReleaseOwnership(base::Bind(&TestService::OwnershipReleased, | 504 ReleaseOwnership(base::Bind(&TestService::OwnershipReleased, |
505 base::Unretained(this), | 505 base::Unretained(this), |
506 method_call, response_sender)); | 506 method_call, response_sender)); |
507 return; | 507 return; |
508 } else if (action == "InvalidateProperty") { | 508 } else if (action == "InvalidateProperty") { |
509 SendPropertyInvalidatedSignal(); | 509 SendPropertyInvalidatedSignal(); |
510 } | 510 } |
511 | 511 |
512 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 512 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
513 response_sender.Run(std::move(response)); | 513 response_sender.Run(std::move(response)); |
514 } | 514 } |
515 | 515 |
516 void TestService::PerformActionResponse( | 516 void TestService::PerformActionResponse( |
517 MethodCall* method_call, | 517 MethodCall* method_call, |
518 ExportedObject::ResponseSender response_sender) { | 518 ExportedObject::ResponseSender response_sender) { |
519 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 519 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
520 response_sender.Run(std::move(response)); | 520 response_sender.Run(std::move(response)); |
521 } | 521 } |
522 | 522 |
523 void TestService::OwnershipReleased( | 523 void TestService::OwnershipReleased( |
524 MethodCall* method_call, | 524 MethodCall* method_call, |
525 ExportedObject::ResponseSender response_sender) { | 525 ExportedObject::ResponseSender response_sender) { |
526 RequestOwnership(base::Bind(&TestService::OwnershipRegained, | 526 RequestOwnership(base::Bind(&TestService::OwnershipRegained, |
527 base::Unretained(this), | 527 base::Unretained(this), |
528 method_call, response_sender)); | 528 method_call, response_sender)); |
529 } | 529 } |
530 | 530 |
531 | 531 |
532 void TestService::OwnershipRegained( | 532 void TestService::OwnershipRegained( |
533 MethodCall* method_call, | 533 MethodCall* method_call, |
534 ExportedObject::ResponseSender response_sender, | 534 ExportedObject::ResponseSender response_sender, |
535 bool success) { | 535 bool success) { |
536 PerformActionResponse(method_call, response_sender); | 536 PerformActionResponse(method_call, response_sender); |
537 } | 537 } |
538 | 538 |
539 | 539 |
540 void TestService::GetManagedObjects( | 540 void TestService::GetManagedObjects( |
541 MethodCall* method_call, | 541 MethodCall* method_call, |
542 ExportedObject::ResponseSender response_sender) { | 542 ExportedObject::ResponseSender response_sender) { |
543 scoped_ptr<Response> response = Response::FromMethodCall(method_call); | 543 std::unique_ptr<Response> response = Response::FromMethodCall(method_call); |
544 MessageWriter writer(response.get()); | 544 MessageWriter writer(response.get()); |
545 | 545 |
546 // The managed objects response is a dictionary of object paths identifying | 546 // The managed objects response is a dictionary of object paths identifying |
547 // the object(s) with a dictionary of strings identifying the interface(s) | 547 // the object(s) with a dictionary of strings identifying the interface(s) |
548 // they implement and then a dictionary of property values. | 548 // they implement and then a dictionary of property values. |
549 // | 549 // |
550 // Thus this looks something like: | 550 // Thus this looks something like: |
551 // | 551 // |
552 // { | 552 // { |
553 // "/org/chromium/TestObject": { | 553 // "/org/chromium/TestObject": { |
(...skipping 188 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
742 MessageWriter invalidated_array_writer(NULL); | 742 MessageWriter invalidated_array_writer(NULL); |
743 | 743 |
744 writer.OpenArray("s", &invalidated_array_writer); | 744 writer.OpenArray("s", &invalidated_array_writer); |
745 invalidated_array_writer.AppendString("Name"); | 745 invalidated_array_writer.AppendString("Name"); |
746 writer.CloseContainer(&invalidated_array_writer); | 746 writer.CloseContainer(&invalidated_array_writer); |
747 | 747 |
748 exported_object_->SendSignal(&signal); | 748 exported_object_->SendSignal(&signal); |
749 } | 749 } |
750 | 750 |
751 } // namespace dbus | 751 } // namespace dbus |
OLD | NEW |