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(&section));
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