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 3// found in the LICENSE file. 4 5#include "chromeos/dbus/ibus/ibus_config_client.h" 6 7#include <vector> 8 9#include "base/bind.h" 10#include "base/message_loop/message_loop.h" 11#include "base/values.h" 12#include "chromeos/dbus/ibus/ibus_constants.h" 13#include "dbus/message.h" 14#include "dbus/mock_bus.h" 15#include "dbus/mock_object_proxy.h" 16#include "dbus/object_path.h" 17#include "dbus/values_util.h" 18#include "testing/gmock/include/gmock/gmock.h" 19#include "testing/gtest/include/gtest/gtest.h" 20 21using testing::Invoke; 22using testing::Return; 23using testing::_; 24 25namespace { 26const char kSection[] = "IBus/Section"; 27const char kKey[] = "key"; 28 29enum HandlerBehavior { 30 HANDLER_SUCCESS, 31 HANDLER_FAIL, 32}; 33} // namespace 34 35namespace chromeos { 36 37class MockErrorCallback { 38 public: 39 MOCK_METHOD0(Run, void()); 40}; 41 42class MockOnIBusConfigReadyCallback { 43 public: 44 MOCK_METHOD0(Run, void()); 45}; 46 47// The base class of each type specified SetValue function handler. This class 48// checks "section" and "key" field in SetValue message and callback success or 49// error callback based on given |success| flag. 50class SetValueVerifierBase { 51 public: 52 SetValueVerifierBase(const std::string& expected_section, 53 const std::string& expected_key, 54 HandlerBehavior behavior) 55 : expected_section_(expected_section), 56 expected_key_(expected_key), 57 behavior_(behavior) {} 58 59 virtual ~SetValueVerifierBase() {} 60 61 // Handles SetValue method call. This function checks "section" and "key" 62 // field. For the "value" field, subclass checks it with over riding 63 // VeirfyVariant member function. 64 void Run(dbus::MethodCall* method_call, 65 int timeout_ms, 66 const dbus::ObjectProxy::ResponseCallback& callback, 67 const dbus::ObjectProxy::ErrorCallback& error_callback) { 68 dbus::MessageReader reader(method_call); 69 std::string section; 70 std::string key; 71 72 EXPECT_TRUE(reader.PopString(§ion)); 73 EXPECT_EQ(expected_section_, section); 74 EXPECT_TRUE(reader.PopString(&key)); 75 EXPECT_EQ(expected_key_, key); 76 dbus::MessageReader variant_reader(NULL); 77 EXPECT_TRUE(reader.PopVariant(&variant_reader)); 78 79 VerifyVariant(&variant_reader); 80 81 EXPECT_FALSE(reader.HasMoreData()); 82 if (behavior_ == HANDLER_SUCCESS) { 83 scoped_ptr<dbus::Response> response( 84 dbus::Response::FromMethodCall(method_call)); 85 callback.Run(response.get()); 86 } else { 87 scoped_ptr<dbus::ErrorResponse> error_response( 88 dbus::ErrorResponse::FromMethodCall(method_call, "Error", 89 "Error Message")); 90 error_callback.Run(error_response.get()); 91 } 92 } 93 94 // Verifies "value" field in SetValue method call. 95 virtual void VerifyVariant(dbus::MessageReader* reader) = 0; 96 97 private: 98 const std::string expected_section_; 99 const std::string expected_key_; 100 const HandlerBehavior behavior_; 101 102 DISALLOW_COPY_AND_ASSIGN(SetValueVerifierBase); 103}; 104 105// The class to verify SetStringValue method call arguments. 106class SetStringValueHandler : public SetValueVerifierBase { 107 public: 108 SetStringValueHandler(const std::string& expected_key, 109 const std::string& expected_section, 110 const std::string& expected_value, 111 HandlerBehavior behavior) 112 : SetValueVerifierBase(expected_section, expected_key, behavior), 113 expected_value_(expected_value) {} 114 115 116 // SetValueVerifierBase override. 117 virtual void VerifyVariant(dbus::MessageReader* reader) OVERRIDE { 118 std::string value; 119 EXPECT_TRUE(reader->PopString(&value)); 120 EXPECT_EQ(expected_value_, value); 121 } 122 123 private: 124 const std::string expected_value_; 125 126 DISALLOW_COPY_AND_ASSIGN(SetStringValueHandler); 127}; 128 129// The class to verify SetIntValue method call arguments. 130class SetIntValueHandler : public SetValueVerifierBase { 131 public: 132 SetIntValueHandler(const std::string& expected_key, 133 const std::string& expected_section, 134 int expected_value, 135 HandlerBehavior behavior) 136 : SetValueVerifierBase(expected_section, expected_key, behavior), 137 expected_value_(expected_value) {} 138 139 // SetValueVerifierBase override. 140 virtual void VerifyVariant(dbus::MessageReader* reader) OVERRIDE { 141 int value = -1; 142 EXPECT_TRUE(reader->PopInt32(&value)); 143 EXPECT_EQ(expected_value_, value); 144 } 145 146 private: 147 const int expected_value_; 148 149 DISALLOW_COPY_AND_ASSIGN(SetIntValueHandler); 150}; 151 152// The class to verify SetBoolValue method call arguments. 153class SetBoolValueHandler : public SetValueVerifierBase { 154 public: 155 SetBoolValueHandler(const std::string& expected_key, 156 const std::string& expected_section, 157 bool expected_value, 158 HandlerBehavior behavior) 159 : SetValueVerifierBase(expected_section, expected_key, behavior), 160 expected_value_(expected_value) {} 161 162 // SetValueVerifierBase override. 163 virtual void VerifyVariant(dbus::MessageReader* reader) OVERRIDE { 164 bool value = false; 165 EXPECT_TRUE(reader->PopBool(&value)); 166 EXPECT_EQ(expected_value_, value); 167 } 168 169 private: 170 const bool expected_value_; 171 172 DISALLOW_COPY_AND_ASSIGN(SetBoolValueHandler); 173}; 174 175// The class to verify SetStringListValue method call arguments. 176class SetStringListValueHandler : public SetValueVerifierBase { 177 public: 178 SetStringListValueHandler(const std::string& expected_key, 179 const std::string& expected_section, 180 const std::vector<std::string>& expected_value, 181 HandlerBehavior behavior) 182 : SetValueVerifierBase(expected_section, expected_key, behavior), 183 expected_value_(expected_value) {} 184 185 // SetValueVerifierBase override 186 virtual void VerifyVariant(dbus::MessageReader* reader) OVERRIDE { 187 dbus::MessageReader array_reader(NULL); 188 ASSERT_TRUE(reader->PopArray(&array_reader)); 189 for (size_t i = 0; i < expected_value_.size(); ++i) { 190 std::string value; 191 ASSERT_TRUE(array_reader.HasMoreData()); 192 EXPECT_TRUE(array_reader.PopString(&value)); 193 EXPECT_EQ(expected_value_[i], value); 194 } 195 EXPECT_FALSE(array_reader.HasMoreData()); 196 } 197 198 private: 199 const std::vector<std::string>& expected_value_; 200 201 DISALLOW_COPY_AND_ASSIGN(SetStringListValueHandler); 202}; 203 204// The class verifies GetNameOwner method call and emits response callback 205// asynchronouslly. 206class MockGetNameOwnerMethodCallHandler { 207 public: 208 MockGetNameOwnerMethodCallHandler() {} 209 210 // Handles CallMethod function. 211 void Run(dbus::MethodCall* method_call, 212 int timeout_ms, 213 const dbus::ObjectProxy::ResponseCallback& callback, 214 const dbus::ObjectProxy::ErrorCallback& error_callback) { 215 dbus::MessageReader reader(method_call); 216 std::string target_name; 217 EXPECT_TRUE(reader.PopString(&target_name)); 218 EXPECT_EQ(ibus::config::kServiceName, target_name); 219 EXPECT_FALSE(reader.HasMoreData()); 220 221 callback_ = callback; 222 } 223 224 // Invokes reply with given |callback_| in Run method. 225 void EmitReplyCallback(const std::string& owner) { 226 scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); 227 dbus::MessageWriter writer(response.get()); 228 writer.AppendString(owner); 229 callback_.Run(response.get()); 230 } 231 232 private: 233 dbus::ObjectProxy::ResponseCallback callback_; 234 235 DISALLOW_COPY_AND_ASSIGN(MockGetNameOwnerMethodCallHandler); 236}; 237 238 239// The class emulate GetNameOwner signal. 240class NameOwnerChangedHandler { 241 public: 242 NameOwnerChangedHandler() {} 243 244 // OnConnectToSignal mock function. 245 void OnConnectToSignal( 246 const std::string& interface_name, 247 const std::string& signal_name, 248 const dbus::ObjectProxy::SignalCallback& signal_callback, 249 const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) { 250 callback_ = signal_callback; 251 on_connected_callback.Run(interface_name, signal_name, true); 252 } 253 254 // Invokes reply with given |callback_| in Run method. 255 void InvokeSignal(const std::string& name, 256 const std::string& old_owner, 257 const std::string& new_owner) { 258 dbus::Signal signal(ibus::kDBusInterface, ibus::kGetNameOwnerMethod); 259 dbus::MessageWriter writer(&signal); 260 writer.AppendString(name); 261 writer.AppendString(old_owner); 262 writer.AppendString(new_owner); 263 callback_.Run(&signal); 264 } 265 266 private: 267 dbus::ObjectProxy::SignalCallback callback_; 268 269 DISALLOW_COPY_AND_ASSIGN(NameOwnerChangedHandler); 270}; 271 272 273class IBusConfigClientTest : public testing::Test { 274 public: 275 IBusConfigClientTest() {} 276 277 protected: 278 virtual void SetUp() OVERRIDE { 279 dbus::Bus::Options options; 280 mock_bus_ = new dbus::MockBus(options); 281 mock_proxy_ = new dbus::MockObjectProxy(mock_bus_.get(), 282 ibus::kServiceName, 283 dbus::ObjectPath( 284 ibus::config::kServicePath)); 285 EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()); 286 client_.reset(IBusConfigClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION, 287 mock_bus_.get())); 288 289 // Surpress uninteresting mock function call warning. 290 EXPECT_CALL(*mock_bus_.get(), AssertOnOriginThread()) 291 .WillRepeatedly(Return()); 292 } 293 294 virtual void TearDown() OVERRIDE { 295 mock_bus_->ShutdownAndBlock(); 296 } 297 298 // Initialize |client_| by replying valid owner name synchronously. 299 void InitializeSync() { 300 EXPECT_CALL(*mock_bus_.get(), 301 GetObjectProxy(ibus::config::kServiceName, 302 dbus::ObjectPath(ibus::config::kServicePath))) 303 .WillOnce(Return(mock_proxy_.get())); 304 305 scoped_refptr<dbus::MockObjectProxy> mock_dbus_proxy 306 = new dbus::MockObjectProxy(mock_bus_.get(), 307 ibus::kDBusServiceName, 308 dbus::ObjectPath(ibus::kDBusObjectPath)); 309 EXPECT_CALL(*mock_bus_.get(), 310 GetObjectProxy(ibus::kDBusServiceName, 311 dbus::ObjectPath(ibus::kDBusObjectPath))) 312 .WillOnce(Return(mock_dbus_proxy.get())); 313 314 MockGetNameOwnerMethodCallHandler mock_get_name_owner_method_call; 315 EXPECT_CALL(*mock_dbus_proxy.get(), CallMethodWithErrorCallback(_, _, _, _)) 316 .WillOnce(Invoke(&mock_get_name_owner_method_call, 317 &MockGetNameOwnerMethodCallHandler::Run)); 318 NameOwnerChangedHandler handler; 319 EXPECT_CALL(*mock_dbus_proxy.get(), 320 ConnectToSignal( 321 ibus::kDBusInterface, ibus::kNameOwnerChangedSignal, _, _)) 322 .WillOnce( 323 Invoke(&handler, &NameOwnerChangedHandler::OnConnectToSignal)); 324 client_->InitializeAsync(base::Bind(&base::DoNothing)); 325 mock_get_name_owner_method_call.EmitReplyCallback(":0.1"); 326 } 327 328 // The IBus config client to be tested. 329 scoped_ptr<IBusConfigClient> client_; 330 331 // A message loop to emulate asynchronous behavior. 332 base::MessageLoop message_loop_; 333 scoped_refptr<dbus::MockBus> mock_bus_; 334 scoped_refptr<dbus::MockObjectProxy> mock_proxy_; 335}; 336 337TEST_F(IBusConfigClientTest, SetStringValueTest) { 338 // Set expectations 339 InitializeSync(); 340 const char value[] = "value"; 341 SetStringValueHandler handler(kSection, kKey, value, HANDLER_SUCCESS); 342 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 343 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 344 MockErrorCallback error_callback; 345 EXPECT_CALL(error_callback, Run()).Times(0); 346 347 // Call SetStringValue. 348 client_->SetStringValue(kKey, kSection, value, 349 base::Bind(&MockErrorCallback::Run, 350 base::Unretained(&error_callback))); 351} 352 353TEST_F(IBusConfigClientTest, SetStringValueTest_Fail) { 354 // Set expectations 355 InitializeSync(); 356 const char value[] = "value"; 357 SetStringValueHandler handler(kSection, kKey, value, HANDLER_FAIL); 358 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 359 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 360 MockErrorCallback error_callback; 361 EXPECT_CALL(error_callback, Run()); 362 363 // Call SetStringValue. 364 client_->SetStringValue(kKey, kSection, value, 365 base::Bind(&MockErrorCallback::Run, 366 base::Unretained(&error_callback))); 367} 368 369TEST_F(IBusConfigClientTest, SetIntValueTest) { 370 // Set expectations 371 InitializeSync(); 372 const int value = 1234; 373 SetIntValueHandler handler(kSection, kKey, value, HANDLER_SUCCESS); 374 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 375 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 376 MockErrorCallback error_callback; 377 EXPECT_CALL(error_callback, Run()).Times(0); 378 379 // Call SetIntValue. 380 client_->SetIntValue(kKey, kSection, value, 381 base::Bind(&MockErrorCallback::Run, 382 base::Unretained(&error_callback))); 383} 384 385TEST_F(IBusConfigClientTest, SetIntValueTest_Fail) { 386 // Set expectations 387 InitializeSync(); 388 const int value = 1234; 389 SetIntValueHandler handler(kSection, kKey, value, HANDLER_FAIL); 390 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 391 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 392 MockErrorCallback error_callback; 393 EXPECT_CALL(error_callback, Run()); 394 395 // Call SetIntValue. 396 client_->SetIntValue(kKey, kSection, value, 397 base::Bind(&MockErrorCallback::Run, 398 base::Unretained(&error_callback))); 399} 400 401TEST_F(IBusConfigClientTest, SetBoolValueTest) { 402 // Set expectations 403 InitializeSync(); 404 const bool value = true; 405 SetBoolValueHandler handler(kSection, kKey, value, HANDLER_SUCCESS); 406 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 407 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 408 MockErrorCallback error_callback; 409 EXPECT_CALL(error_callback, Run()).Times(0); 410 411 // Call SetBoolValue. 412 client_->SetBoolValue(kKey, kSection, value, 413 base::Bind(&MockErrorCallback::Run, 414 base::Unretained(&error_callback))); 415} 416 417TEST_F(IBusConfigClientTest, SetBoolValueTest_Fail) { 418 // Set expectations 419 InitializeSync(); 420 const bool value = true; 421 SetBoolValueHandler handler(kSection, kKey, value, HANDLER_FAIL); 422 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 423 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 424 MockErrorCallback error_callback; 425 EXPECT_CALL(error_callback, Run()); 426 427 // Call SetBoolValue. 428 client_->SetBoolValue(kKey, kSection, value, 429 base::Bind(&MockErrorCallback::Run, 430 base::Unretained(&error_callback))); 431} 432 433TEST_F(IBusConfigClientTest, SetStringListValueTest) { 434 // Set expectations 435 InitializeSync(); 436 std::vector<std::string> value; 437 value.push_back("Sample value 1"); 438 value.push_back("Sample value 2"); 439 440 SetStringListValueHandler handler(kSection, kKey, value, HANDLER_SUCCESS); 441 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 442 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 443 MockErrorCallback error_callback; 444 EXPECT_CALL(error_callback, Run()).Times(0); 445 446 // Call SetStringListValue. 447 client_->SetStringListValue(kKey, kSection, value, 448 base::Bind(&MockErrorCallback::Run, 449 base::Unretained(&error_callback))); 450} 451 452TEST_F(IBusConfigClientTest, SetStringListValueTest_Fail) { 453 // Set expectations 454 InitializeSync(); 455 std::vector<std::string> value; 456 value.push_back("Sample value 1"); 457 value.push_back("Sample value 2"); 458 459 SetStringListValueHandler handler(kSection, kKey, value, HANDLER_FAIL); 460 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 461 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 462 MockErrorCallback error_callback; 463 EXPECT_CALL(error_callback, Run()); 464 465 // Call SetStringListValue. 466 client_->SetStringListValue(kKey, kSection, value, 467 base::Bind(&MockErrorCallback::Run, 468 base::Unretained(&error_callback))); 469} 470 471TEST_F(IBusConfigClientTest, IBusConfigDaemon_NotAvailableTest) { 472 MockGetNameOwnerMethodCallHandler mock_get_name_owner_method_call; 473 474 EXPECT_CALL(*mock_bus_.get(), 475 GetObjectProxy(ibus::kServiceName, 476 dbus::ObjectPath(ibus::config::kServicePath))) 477 .Times(0); 478 479 scoped_refptr<dbus::MockObjectProxy> mock_dbus_proxy 480 = new dbus::MockObjectProxy(mock_bus_.get(), 481 ibus::kDBusServiceName, 482 dbus::ObjectPath(ibus::kDBusObjectPath)); 483 EXPECT_CALL(*mock_bus_.get(), 484 GetObjectProxy(ibus::kDBusServiceName, 485 dbus::ObjectPath(ibus::kDBusObjectPath))) 486 .WillOnce(Return(mock_dbus_proxy.get())); 487 EXPECT_CALL(*mock_dbus_proxy.get(), CallMethodWithErrorCallback(_, _, _, _)) 488 .WillOnce(Invoke(&mock_get_name_owner_method_call, 489 &MockGetNameOwnerMethodCallHandler::Run)); 490 NameOwnerChangedHandler handler; 491 EXPECT_CALL(*mock_dbus_proxy.get(), 492 ConnectToSignal( 493 ibus::kDBusInterface, ibus::kNameOwnerChangedSignal, _, _)) 494 .WillOnce(Invoke(&handler, &NameOwnerChangedHandler::OnConnectToSignal)); 495 client_->InitializeAsync(base::Bind(&base::DoNothing)); 496 497 // Passing empty string means there is no owner, thus ibus-config daemon is 498 // not ready. 499 mock_get_name_owner_method_call.EmitReplyCallback(""); 500 501 // Make sure not crashing by function call without initialize. 502 const bool value = true; 503 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 504 .Times(0); 505 MockErrorCallback error_callback; 506 EXPECT_CALL(error_callback, Run()).Times(0); 507 client_->SetBoolValue(kKey, kSection, value, 508 base::Bind(&MockErrorCallback::Run, 509 base::Unretained(&error_callback))); 510} 511 512TEST_F(IBusConfigClientTest, IBusConfigDaemon_SlowInitializeTest) { 513 MockGetNameOwnerMethodCallHandler mock_get_name_owner_method_call; 514 515 EXPECT_CALL(*mock_bus_.get(), 516 GetObjectProxy(ibus::config::kServiceName, 517 dbus::ObjectPath(ibus::config::kServicePath))) 518 .WillOnce(Return(mock_proxy_.get())); 519 520 scoped_refptr<dbus::MockObjectProxy> mock_dbus_proxy 521 = new dbus::MockObjectProxy(mock_bus_.get(), 522 ibus::kDBusServiceName, 523 dbus::ObjectPath(ibus::kDBusObjectPath)); 524 EXPECT_CALL(*mock_bus_.get(), 525 GetObjectProxy(ibus::kDBusServiceName, 526 dbus::ObjectPath(ibus::kDBusObjectPath))) 527 .WillOnce(Return(mock_dbus_proxy.get())); 528 EXPECT_CALL(*mock_dbus_proxy.get(), CallMethodWithErrorCallback(_, _, _, _)) 529 .WillOnce(Invoke(&mock_get_name_owner_method_call, 530 &MockGetNameOwnerMethodCallHandler::Run)); 531 NameOwnerChangedHandler name_owner_changed_handler; 532 EXPECT_CALL(*mock_dbus_proxy.get(), 533 ConnectToSignal( 534 ibus::kDBusInterface, ibus::kNameOwnerChangedSignal, _, _)) 535 .WillOnce(Invoke(&name_owner_changed_handler, 536 &NameOwnerChangedHandler::OnConnectToSignal)); 537 client_->InitializeAsync(base::Bind(&base::DoNothing)); 538 539 // Passing empty string means there is no owner, thus ibus-config daemon is 540 // not ready. 541 mock_get_name_owner_method_call.EmitReplyCallback(""); 542 543 // Fire NameOwnerChanged signal to emulate ibus-config daemon was acquired 544 // well-known name. 545 name_owner_changed_handler.InvokeSignal(ibus::config::kServiceName, 546 "", 547 ":0.1"); 548 549 // Make sure it is possible to emit method calls. 550 const bool value = true; 551 SetBoolValueHandler handler(kSection, kKey, value, HANDLER_FAIL); 552 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 553 .WillOnce(Invoke(&handler, &SetValueVerifierBase::Run)); 554 MockErrorCallback error_callback; 555 EXPECT_CALL(error_callback, Run()); 556 557 // Call SetBoolValue. 558 client_->SetBoolValue(kKey, kSection, value, 559 base::Bind(&MockErrorCallback::Run, 560 base::Unretained(&error_callback))); 561} 562 563TEST_F(IBusConfigClientTest, IBusConfigDaemon_ShutdownTest) { 564 MockGetNameOwnerMethodCallHandler mock_get_name_owner_method_call; 565 566 EXPECT_CALL(*mock_bus_.get(), 567 GetObjectProxy(ibus::config::kServiceName, 568 dbus::ObjectPath(ibus::config::kServicePath))) 569 .WillRepeatedly(Return(mock_proxy_.get())); 570 571 scoped_refptr<dbus::MockObjectProxy> mock_dbus_proxy 572 = new dbus::MockObjectProxy(mock_bus_.get(), 573 ibus::kDBusServiceName, 574 dbus::ObjectPath(ibus::kDBusObjectPath)); 575 EXPECT_CALL(*mock_bus_.get(), 576 GetObjectProxy(ibus::kDBusServiceName, 577 dbus::ObjectPath(ibus::kDBusObjectPath))) 578 .WillOnce(Return(mock_dbus_proxy.get())); 579 EXPECT_CALL(*mock_dbus_proxy.get(), CallMethodWithErrorCallback(_, _, _, _)) 580 .WillOnce(Invoke(&mock_get_name_owner_method_call, 581 &MockGetNameOwnerMethodCallHandler::Run)); 582 NameOwnerChangedHandler name_owner_changed_handler; 583 EXPECT_CALL(*mock_dbus_proxy.get(), 584 ConnectToSignal( 585 ibus::kDBusInterface, ibus::kNameOwnerChangedSignal, _, _)) 586 .WillOnce(Invoke(&name_owner_changed_handler, 587 &NameOwnerChangedHandler::OnConnectToSignal)); 588 client_->InitializeAsync(base::Bind(&base::DoNothing)); 589 590 const bool value = true; 591 SetBoolValueHandler handler(kSection, kKey, value, HANDLER_FAIL); 592 EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _)) 593 .WillRepeatedly(Invoke(&handler, &SetValueVerifierBase::Run)); 594 MockErrorCallback error_callback; 595 EXPECT_CALL(error_callback, Run()).WillRepeatedly(Return()); 596 597 // Initialize succeeded sucessfully. 598 mock_get_name_owner_method_call.EmitReplyCallback(":0.2"); 599 600 // Call SetBoolValue. 601 client_->SetBoolValue(kKey, kSection, value, 602 base::Bind(&MockErrorCallback::Run, 603 base::Unretained(&error_callback))); 604 605 // Fire NameOwnerChanged signal to emulate shutting down the ibus-config 606 // daemon. 607 name_owner_changed_handler.InvokeSignal(ibus::config::kServiceName, 608 ":0.1", 609 ""); 610 611 // Make sure not crashing on emitting method call. 612 client_->SetBoolValue(kKey, kSection, value, 613 base::Bind(&MockErrorCallback::Run, 614 base::Unretained(&error_callback))); 615 616 // Fire NameOwnerChanged signal to emulate that ibus-daemon is revived. 617 name_owner_changed_handler.InvokeSignal(ibus::config::kServiceName, 618 "", 619 ":0.2"); 620 621 // Make sure it is possible to emit method calls. 622 client_->SetBoolValue(kKey, kSection, value, 623 base::Bind(&MockErrorCallback::Run, 624 base::Unretained(&error_callback))); 625} 626 627} // namespace chromeos 628