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 "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/test/test_timeouts.h" | 8 #include "base/test/test_timeouts.h" |
9 #include "base/threading/platform_thread.h" | 9 #include "base/threading/platform_thread.h" |
10 #include "dbus/bus.h" | 10 #include "dbus/bus.h" |
(...skipping 225 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
236 LOG(ERROR) << "The number of methods does not match"; | 236 LOG(ERROR) << "The number of methods does not match"; |
237 } | 237 } |
238 message_loop->Run(); | 238 message_loop->Run(); |
239 } | 239 } |
240 | 240 |
241 void TestService::Echo(MethodCall* method_call, | 241 void TestService::Echo(MethodCall* method_call, |
242 dbus::ExportedObject::ResponseSender response_sender) { | 242 dbus::ExportedObject::ResponseSender response_sender) { |
243 MessageReader reader(method_call); | 243 MessageReader reader(method_call); |
244 std::string text_message; | 244 std::string text_message; |
245 if (!reader.PopString(&text_message)) { | 245 if (!reader.PopString(&text_message)) { |
246 response_sender.Run(NULL); | 246 response_sender.Run(scoped_ptr<dbus::Response>()); |
247 return; | 247 return; |
248 } | 248 } |
249 | 249 |
250 Response* response = Response::FromMethodCall(method_call); | 250 scoped_ptr<Response> response = Response::FromMethodCall(method_call); |
251 MessageWriter writer(response); | 251 MessageWriter writer(response.get()); |
252 writer.AppendString(text_message); | 252 writer.AppendString(text_message); |
253 response_sender.Run(response); | 253 response_sender.Run(response.Pass()); |
254 } | 254 } |
255 | 255 |
256 void TestService::SlowEcho( | 256 void TestService::SlowEcho( |
257 MethodCall* method_call, | 257 MethodCall* method_call, |
258 dbus::ExportedObject::ResponseSender response_sender) { | 258 dbus::ExportedObject::ResponseSender response_sender) { |
259 base::PlatformThread::Sleep(TestTimeouts::tiny_timeout()); | 259 base::PlatformThread::Sleep(TestTimeouts::tiny_timeout()); |
260 Echo(method_call, response_sender); | 260 Echo(method_call, response_sender); |
261 } | 261 } |
262 | 262 |
263 void TestService::AsyncEcho( | 263 void TestService::AsyncEcho( |
264 MethodCall* method_call, | 264 MethodCall* method_call, |
265 dbus::ExportedObject::ResponseSender response_sender) { | 265 dbus::ExportedObject::ResponseSender response_sender) { |
266 // Schedule a call to Echo() to send an asynchronous response after we return. | 266 // Schedule a call to Echo() to send an asynchronous response after we return. |
267 message_loop()->PostDelayedTask(FROM_HERE, | 267 message_loop()->PostDelayedTask(FROM_HERE, |
268 base::Bind(&TestService::Echo, | 268 base::Bind(&TestService::Echo, |
269 base::Unretained(this), | 269 base::Unretained(this), |
270 method_call, | 270 method_call, |
271 response_sender), | 271 response_sender), |
272 TestTimeouts::tiny_timeout()); | 272 TestTimeouts::tiny_timeout()); |
273 } | 273 } |
274 | 274 |
275 void TestService::BrokenMethod( | 275 void TestService::BrokenMethod( |
276 MethodCall* method_call, | 276 MethodCall* method_call, |
277 dbus::ExportedObject::ResponseSender response_sender) { | 277 dbus::ExportedObject::ResponseSender response_sender) { |
278 response_sender.Run(NULL); | 278 response_sender.Run(scoped_ptr<dbus::Response>()); |
279 } | 279 } |
280 | 280 |
281 | 281 |
282 void TestService::GetAllProperties( | 282 void TestService::GetAllProperties( |
283 MethodCall* method_call, | 283 MethodCall* method_call, |
284 dbus::ExportedObject::ResponseSender response_sender) { | 284 dbus::ExportedObject::ResponseSender response_sender) { |
285 MessageReader reader(method_call); | 285 MessageReader reader(method_call); |
286 std::string interface; | 286 std::string interface; |
287 if (!reader.PopString(&interface)) { | 287 if (!reader.PopString(&interface)) { |
288 response_sender.Run(NULL); | 288 response_sender.Run(scoped_ptr<dbus::Response>()); |
289 return; | 289 return; |
290 } | 290 } |
291 | 291 |
292 // The properties response is a dictionary of strings identifying the | 292 // The properties response is a dictionary of strings identifying the |
293 // property and a variant containing the property value. We return all | 293 // property and a variant containing the property value. We return all |
294 // of the properties, thus the response is: | 294 // of the properties, thus the response is: |
295 // | 295 // |
296 // { | 296 // { |
297 // "Name": Variant<"TestService">, | 297 // "Name": Variant<"TestService">, |
298 // "Version": Variant<10>, | 298 // "Version": Variant<10>, |
299 // "Methods": Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>, | 299 // "Methods": Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>, |
300 // "Objects": Variant<[objectpath:"/TestObjectPath"]> | 300 // "Objects": Variant<[objectpath:"/TestObjectPath"]> |
301 // ] | 301 // ] |
302 | 302 |
303 Response* response = Response::FromMethodCall(method_call); | 303 scoped_ptr<Response> response = Response::FromMethodCall(method_call); |
304 MessageWriter writer(response); | 304 MessageWriter writer(response.get()); |
305 | 305 |
306 MessageWriter array_writer(NULL); | 306 MessageWriter array_writer(NULL); |
307 MessageWriter dict_entry_writer(NULL); | 307 MessageWriter dict_entry_writer(NULL); |
308 MessageWriter variant_writer(NULL); | 308 MessageWriter variant_writer(NULL); |
309 MessageWriter variant_array_writer(NULL); | 309 MessageWriter variant_array_writer(NULL); |
310 | 310 |
311 writer.OpenArray("{sv}", &array_writer); | 311 writer.OpenArray("{sv}", &array_writer); |
312 | 312 |
313 array_writer.OpenDictEntry(&dict_entry_writer); | 313 array_writer.OpenDictEntry(&dict_entry_writer); |
314 dict_entry_writer.AppendString("Name"); | 314 dict_entry_writer.AppendString("Name"); |
(...skipping 21 matching lines...) Expand all Loading... |
336 dict_entry_writer.AppendString("Objects"); | 336 dict_entry_writer.AppendString("Objects"); |
337 dict_entry_writer.OpenVariant("ao", &variant_writer); | 337 dict_entry_writer.OpenVariant("ao", &variant_writer); |
338 variant_writer.OpenArray("o", &variant_array_writer); | 338 variant_writer.OpenArray("o", &variant_array_writer); |
339 variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath")); | 339 variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath")); |
340 variant_writer.CloseContainer(&variant_array_writer); | 340 variant_writer.CloseContainer(&variant_array_writer); |
341 dict_entry_writer.CloseContainer(&variant_writer); | 341 dict_entry_writer.CloseContainer(&variant_writer); |
342 array_writer.CloseContainer(&dict_entry_writer); | 342 array_writer.CloseContainer(&dict_entry_writer); |
343 | 343 |
344 writer.CloseContainer(&array_writer); | 344 writer.CloseContainer(&array_writer); |
345 | 345 |
346 response_sender.Run(response); | 346 response_sender.Run(response.Pass()); |
347 } | 347 } |
348 | 348 |
349 void TestService::GetProperty( | 349 void TestService::GetProperty( |
350 MethodCall* method_call, | 350 MethodCall* method_call, |
351 dbus::ExportedObject::ResponseSender response_sender) { | 351 dbus::ExportedObject::ResponseSender response_sender) { |
352 MessageReader reader(method_call); | 352 MessageReader reader(method_call); |
353 std::string interface; | 353 std::string interface; |
354 if (!reader.PopString(&interface)) { | 354 if (!reader.PopString(&interface)) { |
355 response_sender.Run(NULL); | 355 response_sender.Run(scoped_ptr<dbus::Response>()); |
356 return; | 356 return; |
357 } | 357 } |
358 | 358 |
359 std::string name; | 359 std::string name; |
360 if (!reader.PopString(&name)) { | 360 if (!reader.PopString(&name)) { |
361 response_sender.Run(NULL); | 361 response_sender.Run(scoped_ptr<dbus::Response>()); |
362 return; | 362 return; |
363 } | 363 } |
364 | 364 |
365 if (name == "Name") { | 365 if (name == "Name") { |
366 // Return the previous value for the "Name" property: | 366 // Return the previous value for the "Name" property: |
367 // Variant<"TestService"> | 367 // Variant<"TestService"> |
368 Response* response = Response::FromMethodCall(method_call); | 368 scoped_ptr<Response> response = Response::FromMethodCall(method_call); |
369 MessageWriter writer(response); | 369 MessageWriter writer(response.get()); |
370 | 370 |
371 writer.AppendVariantOfString("TestService"); | 371 writer.AppendVariantOfString("TestService"); |
372 | 372 |
373 response_sender.Run(response); | 373 response_sender.Run(response.Pass()); |
374 } else if (name == "Version") { | 374 } else if (name == "Version") { |
375 // Return a new value for the "Version" property: | 375 // Return a new value for the "Version" property: |
376 // Variant<20> | 376 // Variant<20> |
377 Response* response = Response::FromMethodCall(method_call); | 377 scoped_ptr<Response> response = Response::FromMethodCall(method_call); |
378 MessageWriter writer(response); | 378 MessageWriter writer(response.get()); |
379 | 379 |
380 writer.AppendVariantOfInt16(20); | 380 writer.AppendVariantOfInt16(20); |
381 | 381 |
382 response_sender.Run(response); | 382 response_sender.Run(response.Pass()); |
383 } else if (name == "Methods") { | 383 } else if (name == "Methods") { |
384 // Return the previous value for the "Methods" property: | 384 // Return the previous value for the "Methods" property: |
385 // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]> | 385 // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]> |
386 Response* response = Response::FromMethodCall(method_call); | 386 scoped_ptr<Response> response = Response::FromMethodCall(method_call); |
387 MessageWriter writer(response); | 387 MessageWriter writer(response.get()); |
388 MessageWriter variant_writer(NULL); | 388 MessageWriter variant_writer(NULL); |
389 MessageWriter variant_array_writer(NULL); | 389 MessageWriter variant_array_writer(NULL); |
390 | 390 |
391 writer.OpenVariant("as", &variant_writer); | 391 writer.OpenVariant("as", &variant_writer); |
392 variant_writer.OpenArray("s", &variant_array_writer); | 392 variant_writer.OpenArray("s", &variant_array_writer); |
393 variant_array_writer.AppendString("Echo"); | 393 variant_array_writer.AppendString("Echo"); |
394 variant_array_writer.AppendString("SlowEcho"); | 394 variant_array_writer.AppendString("SlowEcho"); |
395 variant_array_writer.AppendString("AsyncEcho"); | 395 variant_array_writer.AppendString("AsyncEcho"); |
396 variant_array_writer.AppendString("BrokenMethod"); | 396 variant_array_writer.AppendString("BrokenMethod"); |
397 variant_writer.CloseContainer(&variant_array_writer); | 397 variant_writer.CloseContainer(&variant_array_writer); |
398 writer.CloseContainer(&variant_writer); | 398 writer.CloseContainer(&variant_writer); |
399 | 399 |
400 response_sender.Run(response); | 400 response_sender.Run(response.Pass()); |
401 } else if (name == "Objects") { | 401 } else if (name == "Objects") { |
402 // Return the previous value for the "Objects" property: | 402 // Return the previous value for the "Objects" property: |
403 // Variant<[objectpath:"/TestObjectPath"]> | 403 // Variant<[objectpath:"/TestObjectPath"]> |
404 Response* response = Response::FromMethodCall(method_call); | 404 scoped_ptr<Response> response = Response::FromMethodCall(method_call); |
405 MessageWriter writer(response); | 405 MessageWriter writer(response.get()); |
406 MessageWriter variant_writer(NULL); | 406 MessageWriter variant_writer(NULL); |
407 MessageWriter variant_array_writer(NULL); | 407 MessageWriter variant_array_writer(NULL); |
408 | 408 |
409 writer.OpenVariant("ao", &variant_writer); | 409 writer.OpenVariant("ao", &variant_writer); |
410 variant_writer.OpenArray("o", &variant_array_writer); | 410 variant_writer.OpenArray("o", &variant_array_writer); |
411 variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath")); | 411 variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath")); |
412 variant_writer.CloseContainer(&variant_array_writer); | 412 variant_writer.CloseContainer(&variant_array_writer); |
413 writer.CloseContainer(&variant_writer); | 413 writer.CloseContainer(&variant_writer); |
414 | 414 |
415 response_sender.Run(response); | 415 response_sender.Run(response.Pass()); |
416 } else { | 416 } else { |
417 // Return error. | 417 // Return error. |
418 response_sender.Run(NULL); | 418 response_sender.Run(scoped_ptr<dbus::Response>()); |
419 return; | 419 return; |
420 } | 420 } |
421 } | 421 } |
422 | 422 |
423 void TestService::SetProperty( | 423 void TestService::SetProperty( |
424 MethodCall* method_call, | 424 MethodCall* method_call, |
425 dbus::ExportedObject::ResponseSender response_sender) { | 425 dbus::ExportedObject::ResponseSender response_sender) { |
426 MessageReader reader(method_call); | 426 MessageReader reader(method_call); |
427 std::string interface; | 427 std::string interface; |
428 if (!reader.PopString(&interface)) { | 428 if (!reader.PopString(&interface)) { |
429 response_sender.Run(NULL); | 429 response_sender.Run(scoped_ptr<dbus::Response>()); |
430 return; | 430 return; |
431 } | 431 } |
432 | 432 |
433 std::string name; | 433 std::string name; |
434 if (!reader.PopString(&name)) { | 434 if (!reader.PopString(&name)) { |
435 response_sender.Run(NULL); | 435 response_sender.Run(scoped_ptr<dbus::Response>()); |
436 return; | 436 return; |
437 } | 437 } |
438 | 438 |
439 if (name != "Name") { | 439 if (name != "Name") { |
440 response_sender.Run(NULL); | 440 response_sender.Run(scoped_ptr<dbus::Response>()); |
441 return; | 441 return; |
442 } | 442 } |
443 | 443 |
444 std::string value; | 444 std::string value; |
445 if (!reader.PopVariantOfString(&value)) { | 445 if (!reader.PopVariantOfString(&value)) { |
446 response_sender.Run(NULL); | 446 response_sender.Run(scoped_ptr<dbus::Response>()); |
447 return; | 447 return; |
448 } | 448 } |
449 | 449 |
450 SendPropertyChangedSignal(value); | 450 SendPropertyChangedSignal(value); |
451 | 451 |
452 Response* response = Response::FromMethodCall(method_call); | 452 response_sender.Run(Response::FromMethodCall(method_call)); |
453 response_sender.Run(response); | |
454 } | 453 } |
455 | 454 |
456 void TestService::SendPropertyChangedSignal(const std::string& name) { | 455 void TestService::SendPropertyChangedSignal(const std::string& name) { |
457 message_loop()->PostTask( | 456 message_loop()->PostTask( |
458 FROM_HERE, | 457 FROM_HERE, |
459 base::Bind(&TestService::SendPropertyChangedSignalInternal, | 458 base::Bind(&TestService::SendPropertyChangedSignalInternal, |
460 base::Unretained(this), | 459 base::Unretained(this), |
461 name)); | 460 name)); |
462 } | 461 } |
463 | 462 |
464 void TestService::SendPropertyChangedSignalInternal(const std::string& name) { | 463 void TestService::SendPropertyChangedSignalInternal(const std::string& name) { |
465 dbus::Signal signal(kPropertiesInterface, kPropertiesChanged); | 464 dbus::Signal signal(kPropertiesInterface, kPropertiesChanged); |
466 dbus::MessageWriter writer(&signal); | 465 dbus::MessageWriter writer(&signal); |
467 writer.AppendString("org.chromium.TestService"); | 466 writer.AppendString("org.chromium.TestService"); |
468 | 467 |
469 MessageWriter array_writer(NULL); | 468 MessageWriter array_writer(NULL); |
470 MessageWriter dict_entry_writer(NULL); | 469 MessageWriter dict_entry_writer(NULL); |
471 | 470 |
472 writer.OpenArray("{sv}", &array_writer); | 471 writer.OpenArray("{sv}", &array_writer); |
473 array_writer.OpenDictEntry(&dict_entry_writer); | 472 array_writer.OpenDictEntry(&dict_entry_writer); |
474 dict_entry_writer.AppendString("Name"); | 473 dict_entry_writer.AppendString("Name"); |
475 dict_entry_writer.AppendVariantOfString(name); | 474 dict_entry_writer.AppendVariantOfString(name); |
476 array_writer.CloseContainer(&dict_entry_writer); | 475 array_writer.CloseContainer(&dict_entry_writer); |
477 writer.CloseContainer(&array_writer); | 476 writer.CloseContainer(&array_writer); |
478 | 477 |
479 exported_object_->SendSignal(&signal); | 478 exported_object_->SendSignal(&signal); |
480 } | 479 } |
481 | 480 |
482 } // namespace dbus | 481 } // namespace dbus |
OLD | NEW |