Revise IBus related DBus module.

chromeos/dbus/ibus/ibus_engine_factory_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_factory_service.h"
 
+#include <map>
+#include <string>
 #include "base/message_loop.h"
 #include "chromeos/dbus/ibus/ibus_constants.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_exported_object.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrEq;
 using ::testing::_;
 
 namespace chromeos {
 
-class MockCreateEngineHandler {
+class SynchronousCreateEngineHandler {
  public:
-  MOCK_METHOD1(Run, dbus::ObjectPath(const std::string& engine_name));
+  explicit SynchronousCreateEngineHandler(const dbus::ObjectPath& path)
+      : path_(path) {}
+
+  void Run(const IBusEngineFactoryService::CreateEngineResponseSender& sender) {
+    sender.Run(path_);
+  }
+
+ private:
+  dbus::ObjectPath path_;
+
+  DISALLOW_COPY_AND_ASSIGN(SynchronousCreateEngineHandler);
+};
+
+class AsynchronousCreateEngineHandler {
+ public:
+  AsynchronousCreateEngineHandler(const dbus::ObjectPath& path,
+                                  MessageLoop* message_loop)
+      : path_(path),
+        message_loop_(message_loop) {}
+
+  void Run(const IBusEngineFactoryService::CreateEngineResponseSender& sender) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(sender, path_));
+  }
+
+ private:
+  dbus::ObjectPath path_;
+  MessageLoop* message_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(AsynchronousCreateEngineHandler);
 };
 
 class MockCreateEngineResponseSender {
  public:
-  MockCreateEngineResponseSender(const dbus::ObjectPath expected_path)
+  explicit MockCreateEngineResponseSender(const dbus::ObjectPath& expected_path)
       : expected_path_(expected_path) {}
   MOCK_METHOD1(Run, void(dbus::Response*));
 
   // Checks the given |response| meets expectation for the CreateEngine method.
   void CheckCreateEngineResponse(dbus::Response* response) {
     scoped_ptr<dbus::Response> response_deleter(response);
     dbus::MessageReader reader(response);
     dbus::ObjectPath actual_path;
     ASSERT_TRUE(reader.PopObjectPath(&actual_path));
     EXPECT_EQ(expected_path_, actual_path);
@@ skipping 61 matching lines @@
       const dbus::ExportedObject::OnExportedCallback& on_exported_callback) {
     method_exported_map_[method_name] = method_callback;
     const bool success = true;
     message_loop_.PostTask(FROM_HERE, base::Bind(on_exported_callback,
                                                  interface_name,
                                                  method_name,
                                                  success));
   }
 };
 
-TEST_F(IBusEngineFactoryServiceTest, CreateEngineTest) {
+TEST_F(IBusEngineFactoryServiceTest, SyncCreateEngineTest) {
   // Set expectations.
   const char kSampleEngine[] = "Sample Engine";
   const dbus::ObjectPath kObjectPath("/org/freedesktop/IBus/Engine/10");
   MockCreateEngineResponseSender response_sender(kObjectPath);
   EXPECT_CALL(response_sender, Run(_))
       .WillOnce(
           Invoke(&response_sender,
                  &MockCreateEngineResponseSender::CheckCreateEngineResponse));
 
+  SynchronousCreateEngineHandler handler(kObjectPath);
   // Set handler expectations.
-  MockCreateEngineHandler handler;
-  EXPECT_CALL(handler, Run(StrEq(kSampleEngine)))
-      .WillOnce(Return(kObjectPath));
-  service_->SetCreateEngineHandler(base::Bind(&MockCreateEngineHandler::Run,
-                                             base::Unretained(&handler)));
+  service_->SetCreateEngineHandler(
+      kSampleEngine,
+      base::Bind(&SynchronousCreateEngineHandler::Run,
+                 base::Unretained(&handler)));
   message_loop_.RunAllPending();
 
   // Invoke method call.
   dbus::MethodCall method_call(
       ibus::engine_factory::kServiceInterface,
       ibus::engine_factory::kCreateEngineMethod);
   method_call.SetSerial(10);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kSampleEngine);
   ASSERT_FALSE(
       method_exported_map_[ibus::engine_factory::kCreateEngineMethod]
           .is_null());
   method_exported_map_[ibus::engine_factory::kCreateEngineMethod].Run(
       &method_call,
       base::Bind(&MockCreateEngineResponseSender::Run,
                  base::Unretained(&response_sender)));
 
   // Unset the handler so expect not calling handler.
-  service_->UnsetCreateEngineHandler();
+  service_->UnsetCreateEngineHandler(kSampleEngine);
   method_exported_map_[ibus::engine_factory::kCreateEngineMethod].Run(
       &method_call,
       base::Bind(&MockCreateEngineResponseSender::CheckCreateEngineResponse,
                  base::Unretained(&response_sender)));
-
   message_loop_.RunAllPending();
 }
 
+TEST_F(IBusEngineFactoryServiceTest, AsyncCreateEngineTest) {
+  // Set expectations.
+  const char kSampleEngine[] = "Sample Engine";
+  const dbus::ObjectPath kObjectPath("/org/freedesktop/IBus/Engine/10");
+  MockCreateEngineResponseSender response_sender(kObjectPath);
+  EXPECT_CALL(response_sender, Run(_))
+      .WillOnce(
+          Invoke(&response_sender,
+                 &MockCreateEngineResponseSender::CheckCreateEngineResponse));
+
+  AsynchronousCreateEngineHandler handler(kObjectPath, &message_loop_);
+  // Set handler expectations.
+  service_->SetCreateEngineHandler(
+      kSampleEngine,
+      base::Bind(&AsynchronousCreateEngineHandler::Run,
+                 base::Unretained(&handler)));
+  message_loop_.RunAllPending();
+
+  // Invoke method call.
+  dbus::MethodCall method_call(
+      ibus::engine_factory::kServiceInterface,
+      ibus::engine_factory::kCreateEngineMethod);
+  method_call.SetSerial(10);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendString(kSampleEngine);
+  ASSERT_FALSE(
+      method_exported_map_[ibus::engine_factory::kCreateEngineMethod]
+          .is_null());
+  method_exported_map_[ibus::engine_factory::kCreateEngineMethod].Run(
+      &method_call,
+      base::Bind(&MockCreateEngineResponseSender::Run,
+                 base::Unretained(&response_sender)));
+
+  // Unset the handler so expect not calling handler.
+  service_->UnsetCreateEngineHandler(kSampleEngine);
+  method_exported_map_[ibus::engine_factory::kCreateEngineMethod].Run(
+      &method_call,
+      base::Bind(&MockCreateEngineResponseSender::CheckCreateEngineResponse,
+                 base::Unretained(&response_sender)));
+  message_loop_.RunAllPending();
+}
+
 }  // namespace chromeos