Revise IBusEngineService.

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 23 matching lines @@
   MOCK_METHOD0(FocusIn, void());
   MOCK_METHOD0(FocusOut, void());
   MOCK_METHOD0(Enable, void());
   MOCK_METHOD0(Disable, void());
   MOCK_METHOD2(PropertyActivate, void(const std::string& property_name,
                                       IBusPropertyState property_state));
   MOCK_METHOD1(PropertyShow, void(const std::string& property_name));
   MOCK_METHOD1(PropertyHide, void(const std::string& property_name));
   MOCK_METHOD1(SetCapability, void(IBusCapability capability));
   MOCK_METHOD0(Reset, void());
-  MOCK_METHOD3(ProcessKeyEvent, bool(uint32 keysym, uint32 keycode,
-                                     uint32 state));
+  MOCK_METHOD4(ProcessKeyEvent, void(
+      uint32 keysym,
+      uint32 keycode,
+      uint32 state,
+      const KeyEventDoneCallback& callback));
   MOCK_METHOD3(CandidateClicked, void(uint32 index, 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));
@@ skipping 72 matching lines @@
       EXPECT_EQ(property_list_[i]->checked(), property_list[i]->checked());
     }
   }
 
  private:
   const ibus::IBusPropertyList& property_list_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterPropertiesExpectation);
 };
 
+// Used for mocking ProcessKeyEventHandler.
+class ProcessKeyEventHandler {
+ public:
+  explicit ProcessKeyEventHandler(bool expected_value)
+      : expected_value_(expected_value) {
+  }
+
+  void ProcessKeyEvent(
+      uint32 keysym,
+      uint32 keycode,
+      uint32 state,
+      const IBusEngineHandlerInterface::KeyEventDoneCallback& callback) {
+    callback.Run(expected_value_);
+  }
+
+ private:
+  bool expected_value_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProcessKeyEventHandler);
+};
+
+// Used for mocking asynchronous ProcessKeyEventHandler.
+class DelayProcessKeyEventHandler {
+ public:
+  DelayProcessKeyEventHandler(bool expected_value,
+                              MessageLoop* message_loop)
+      : expected_value_(expected_value),
+        message_loop_(message_loop) {
+  }
+
+  void ProcessKeyEvent(
+      uint32 keysym,
+      uint32 keycode,
+      uint32 state,
+      const IBusEngineHandlerInterface::KeyEventDoneCallback& callback) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(callback, expected_value_));
+  }
+
+ private:
+  bool expected_value_;
+  MessageLoop* message_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelayProcessKeyEventHandler);
+};
+
 // Used for UpdatePreedit signal message evaluation.
 class UpdatePreeditExpectation {
  public:
   UpdatePreeditExpectation(
       const ibus::IBusText& ibus_text,
       uint32 cursor_pos,
       bool is_visible,
       IBusEngineService::IBusEnginePreeditFocusOutMode mode)
       : ibus_text_(ibus_text),
         cursor_pos_(cursor_pos),
@@ skipping 550 matching lines @@
 }
 
 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;
 
-  EXPECT_CALL(*engine_handler_, ProcessKeyEvent(kKeySym, kKeyCode, kState))
-      .WillOnce(Return(kResult));
+  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(_))
+      .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)));
+}
+
+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(_))
       .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_.RunAllPending();
 }
 
 TEST_F(IBusEngineServiceTest, CandidateClickedTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const uint32 kIndex = 4;
   const IBusEngineHandlerInterface::IBusMouseButton kIBusMouseButton =
       IBusEngineHandlerInterface::IBUS_MOUSE_BUTTON_MIDDLE;
   const uint32 kState = 3;
   EXPECT_CALL(*engine_handler_, CandidateClicked(kIndex, kIBusMouseButton,
@@ skipping 158 matching lines @@
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &RequireSurroundingTextExpectation::Evaluate));
 
   // Emit signal.
   service_->RequireSurroundingText();
 }
 
 
 }  // namespace chromeos