Code cleaning: Uses scoped_ptr<> to express ownership rather than writing ownership in comments.

chromeos/dbus/ibus/ibus_engine_service_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/dbus/ibus/ibus_engine_service.h"
 
 #include <map>
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 38 matching lines @@
   MOCK_METHOD3(CandidateClicked, void(uint32 index,
                                       ibus::IBusMouseButton button,
                                       uint32 state));
   MOCK_METHOD3(SetSurroundingText, void(const std::string& text,
                                         uint32 cursor_pos,
                                         uint32 anchor_pos));
 };
 
 class MockResponseSender {
  public:
-  MOCK_METHOD1(Run, void(dbus::Response* reponse));
+  // GMock doesn't support mocking methods which take scoped_ptr<>.
+  MOCK_METHOD1(MockRun, void(dbus::Response* reponse));
+  void Run(scoped_ptr<dbus::Response> response) {
+    MockRun(response.get());
+  }
 };
 
 // Used for method call empty response evaluation.
 class EmptyResponseExpectation {
  public:
   explicit EmptyResponseExpectation(const uint32 serial_no)
       : serial_no_(serial_no) {}
 
   // Evaluates the given |response| has no argument.
   void Evaluate(dbus::Response* response) {
-    scoped_ptr<dbus::Response> response_deleter(response);
     EXPECT_EQ(serial_no_, response->GetReplySerial());
     dbus::MessageReader reader(response);
     EXPECT_FALSE(reader.HasMoreData());
   }
 
  private:
   const uint32 serial_no_;
 
   DISALLOW_COPY_AND_ASSIGN(EmptyResponseExpectation);
 };
 
 // Used for method call a boolean response evaluation.
 class BoolResponseExpectation {
  public:
   explicit BoolResponseExpectation(uint32 serial_no, bool result)
       : serial_no_(serial_no),
         result_(result) {}
 
   // Evaluates the given |response| has only one boolean and which is equals to
   // |result_| which is given in ctor.
   void Evaluate(dbus::Response* response) {
-    scoped_ptr<dbus::Response> response_deleter(response);
     EXPECT_EQ(serial_no_, response->GetReplySerial());
     dbus::MessageReader reader(response);
     bool result = false;
     EXPECT_TRUE(reader.PopBool(&result));
     EXPECT_EQ(result_, result);
     EXPECT_FALSE(reader.HasMoreData());
   }
 
  private:
   uint32 serial_no_;
@@ skipping 409 matching lines @@
                                                  success));
   }
 };
 
 TEST_F(IBusEngineServiceTest, FocusInTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*engine_handler_, FocusIn());
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kFocusInMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kFocusInMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kFocusInMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, FocusIn()).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kFocusInMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, FocusOutTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*engine_handler_, FocusOut());
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kFocusOutMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kFocusOutMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kFocusOutMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, FocusOut()).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kFocusOutMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, EnableTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*engine_handler_, Enable());
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kEnableMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kEnableMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kEnableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, Enable()).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kEnableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, DisableTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*engine_handler_, Disable());
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kDisableMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kDisableMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kDisableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, Disable()).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kDisableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, PropertyActivateTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string kPropertyName = "Property Name";
   const ibus::IBusPropertyState kIBusPropertyState =
       ibus::IBUS_PROPERTY_STATE_UNCHECKED;
   EXPECT_CALL(*engine_handler_, PropertyActivate(kPropertyName,
                                                  kIBusPropertyState));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kPropertyActivateMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kPropertyName);
   writer.AppendUint32(static_cast<uint32>(kIBusPropertyState));
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kPropertyActivateMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kPropertyActivateMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, PropertyActivate(kPropertyName,
                                                  kIBusPropertyState)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kPropertyActivateMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, ResetTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*engine_handler_, Reset());
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kResetMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kResetMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kResetMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, Reset()).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kResetMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, PropertyShowTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string kPropertyName = "Property Name";
   EXPECT_CALL(*engine_handler_, PropertyShow(kPropertyName));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kPropertyShowMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kPropertyName);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kPropertyShowMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kPropertyShowMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, PropertyShow(kPropertyName)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kPropertyShowMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, PropertyHideTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string kPropertyName = "Property Name";
   EXPECT_CALL(*engine_handler_, PropertyHide(kPropertyName));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kPropertyHideMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kPropertyName);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kPropertyHideMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kPropertyHideMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, PropertyHide(kPropertyName)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kPropertyHideMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, SetCapabilityTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const IBusEngineHandlerInterface::IBusCapability kIBusCapability =
       IBusEngineHandlerInterface::IBUS_CAPABILITY_PREEDIT_TEXT;
   EXPECT_CALL(*engine_handler_, SetCapability(kIBusCapability));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kSetCapabilityMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendUint32(static_cast<uint32>(kIBusCapability));
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kSetCapabilityMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kSetCapabilityMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, SetCapability(kIBusCapability)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kSetCapabilityMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, ProcessKeyEventTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const uint32 kKeySym = 0x64;
   const uint32 kKeyCode = 0x20;
   const uint32 kState = 0x00;
   const bool kResult = true;
 
   ProcessKeyEventHandler handler(kResult);
   EXPECT_CALL(*engine_handler_, ProcessKeyEvent(kKeySym, kKeyCode, kState, _))
       .WillOnce(Invoke(&handler,
                        &ProcessKeyEventHandler::ProcessKeyEvent));
   MockResponseSender response_sender;
   BoolResponseExpectation response_expectation(kSerialNo, kResult);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &BoolResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kProcessKeyEventMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendUint32(kKeySym);
   writer.AppendUint32(kKeyCode);
   writer.AppendUint32(kState);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kProcessKeyEventMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kProcessKeyEventMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_,
               ProcessKeyEvent(kKeySym, kKeyCode, kState, _)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kProcessKeyEventMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, DelayProcessKeyEventTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const uint32 kKeySym = 0x64;
   const uint32 kKeyCode = 0x20;
   const uint32 kState = 0x00;
   const bool kResult = true;
 
   DelayProcessKeyEventHandler handler(kResult, &message_loop_);
   EXPECT_CALL(*engine_handler_, ProcessKeyEvent(kKeySym, kKeyCode, kState, _))
       .WillOnce(Invoke(&handler,
                        &DelayProcessKeyEventHandler::ProcessKeyEvent));
   MockResponseSender response_sender;
   BoolResponseExpectation response_expectation(kSerialNo, kResult);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &BoolResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kProcessKeyEventMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendUint32(kKeySym);
   writer.AppendUint32(kKeyCode);
   writer.AppendUint32(kState);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kProcessKeyEventMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kProcessKeyEventMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call KeyEventDone callback.
   message_loop_.RunUntilIdle();
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_,
               ProcessKeyEvent(kKeySym, kKeyCode, kState, _)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kProcessKeyEventMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, CandidateClickedTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const uint32 kIndex = 4;
   const ibus::IBusMouseButton kIBusMouseButton = ibus::IBUS_MOUSE_BUTTON_MIDDLE;
   const uint32 kState = 3;
   EXPECT_CALL(*engine_handler_, CandidateClicked(kIndex, kIBusMouseButton,
                                                  kState));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kCandidateClickedMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendUint32(kIndex);
   writer.AppendUint32(static_cast<uint32>(kIBusMouseButton));
   writer.AppendUint32(kState);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kCandidateClickedMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kCandidateClickedMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, CandidateClicked(kIndex, kIBusMouseButton,
                                                  kState)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kCandidateClickedMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, SetSurroundingTextTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string kText = "Sample Text";
   const uint32 kCursorPos = 3;
   const uint32 kAnchorPos = 4;
   EXPECT_CALL(*engine_handler_, SetSurroundingText(kText, kCursorPos,
                                                    kAnchorPos));
   MockResponseSender response_sender;
   EmptyResponseExpectation response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseExpectation::Evaluate));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::engine::kServiceInterface,
                                ibus::engine::kSetSurroundingTextMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kText);
   writer.AppendUint32(kCursorPos);
   writer.AppendUint32(kAnchorPos);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::engine::kSetSurroundingTextMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::engine::kSetSurroundingTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Call exported function without engine.
   service_->UnsetEngine();
   EXPECT_CALL(*engine_handler_, SetSurroundingText(kText, kCursorPos,
                                                    kAnchorPos)).Times(0);
-  EXPECT_CALL(response_sender, Run(_)).Times(0);
+  EXPECT_CALL(response_sender, MockRun(_)).Times(0);
   method_callback_map_[ibus::engine::kSetSurroundingTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, RegisterProperties) {
   // Set expectations.
   IBusPropertyList property_list;
   property_list.push_back(new IBusProperty());
@@ skipping 96 matching lines @@
   RequireSurroundingTextExpectation expectation;
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &RequireSurroundingTextExpectation::Evaluate));
 
   // Emit signal.
   service_->RequireSurroundingText();
 }
 
 }  // namespace chromeos