Fix crash bug of IME extension API.

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 458 matching lines @@
     EXPECT_CALL(*mock_bus_.get(),
                 AssertOnOriginThread())
         .WillRepeatedly(Return());
 
     // Create a service
     service_.reset(IBusEngineService::Create(
         REAL_DBUS_CLIENT_IMPLEMENTATION,
         mock_bus_.get(),
         dbus::ObjectPath(kObjectPath)));
 
-    // Call Initialize to set engine handler.
-    engine_handler_ = new MockIBusEngineHandler();
-    service_->Initialize(engine_handler_);
+    // Set engine handler.
+    engine_handler_.reset(new MockIBusEngineHandler());
+    service_->SetEngine(engine_handler_.get());
   }
 
  protected:
   // The service to be tested.
   scoped_ptr<IBusEngineService> service_;
   // The mock engine handler. Do not free, this is owned by IBusEngineService.
-  MockIBusEngineHandler* engine_handler_;
+  scoped_ptr<MockIBusEngineHandler> engine_handler_;
   // The mock bus.
   scoped_refptr<dbus::MockBus> mock_bus_;
   // The mock exported object.
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
   // A message loop to emulate asynchronous behavior.
   MessageLoop message_loop_;
   // The map from method call to method call handler.
   std::map<std::string, dbus::ExportedObject::MethodCallCallback>
       method_callback_map_;
 
@@ skipping 28 matching lines @@
                                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);
+  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(_))
       .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);
+  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(_))
       .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);
+  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(_))
       .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);
+  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 IBusEngineHandlerInterface::IBusPropertyState kIBusPropertyState =
       IBusEngineHandlerInterface::IBUS_PROPERTY_STATE_UNCHECKED;
   EXPECT_CALL(*engine_handler_, PropertyActivate(kPropertyName,
                                                  kIBusPropertyState));
@@ skipping 11 matching lines @@
   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);
+  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(_))
       .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);
+  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(_))
       .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);
+  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(_))
       .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);
+  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(_))
       .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);
+  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;
 
@@ skipping 16 matching lines @@
   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);
+  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;
 
@@ skipping 19 matching lines @@
   // 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();
+
+  // Call exported function without engine.
+  service_->UnsetEngine();
+  EXPECT_CALL(*engine_handler_,
+              ProcessKeyEvent(kKeySym, kKeyCode, kState, _)).Times(0);
+  EXPECT_CALL(response_sender, Run(_)).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 IBusEngineHandlerInterface::IBusMouseButton kIBusMouseButton =
       IBusEngineHandlerInterface::IBUS_MOUSE_BUTTON_MIDDLE;
   const uint32 kState = 3;
   EXPECT_CALL(*engine_handler_, CandidateClicked(kIndex, kIBusMouseButton,
@@ skipping 13 matching lines @@
   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);
+  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));
@@ skipping 12 matching lines @@
   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);
+  method_callback_map_[ibus::engine::kSetSurroundingTextMethod].Run(
+      &method_call,
+      base::Bind(&MockResponseSender::Run,
+                 base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusEngineServiceTest, RegisterProperties) {
   // Set expetations.
   ibus::IBusPropertyList property_list;
   property_list.push_back(new ibus::IBusProperty());
   property_list[0]->set_key("Sample Key");
   property_list[0]->set_type(ibus::IBusProperty::IBUS_PROPERTY_TYPE_MENU);
   property_list[0]->set_label("Sample Label");
   property_list[0]->set_tooltip("Sample Tooltip");
@@ skipping 91 matching lines @@
 TEST_F(IBusEngineServiceTest, RequireSurroundingTextTest) {
   RequireSurroundingTextExpectation expectation;
   EXPECT_CALL(*mock_exported_object_, SendSignal(_))
       .WillOnce(Invoke(&expectation,
                        &RequireSurroundingTextExpectation::Evaluate));
 
   // Emit signal.
   service_->RequireSurroundingText();
 }
 
-
 }  // namespace chromeos