Clean Up: Gather ibus constants to ibus_constants.h

chromeos/dbus/ibus/ibus_input_context_client_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_input_context_client.h"
 
 #include <map>
 #include <string>
 #include "base/message_loop.h"
+#include "chromeos/dbus/ibus/ibus_constants.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::_;
 
 namespace chromeos {
 
 // TODO(nona): Remove after complete libibus removal.
 using chromeos::ibus::IBusText;
 
 namespace {
-const char kServiceName[] = "org.freedesktop.IBus";
-const char kInputContextInterface[] = "org.freedesktop.IBus.InputContext";
 const char kObjectPath[] = "/org/freedesktop/IBus/InputContext_1010";
 
-// Signal names.
-const char kCommitTextSignal[] = "CommitText";
-const char kForwardKeyEventSignal[] = "ForwardKeyEvent";
-const char kHidePreeditTextSignal[] = "HidePreeditText";
-const char kShowPreeditTextSignal[] = "ShowPreeditText";
-const char kUpdatePreeditTextSignal[] = "UpdatePreeditText";
-
-// Method names.
-const char kFocusInMethod[] = "FocusIn";
-const char kFocusOutMethod[] = "FocusOut";
-const char kResetMethod[] = "Reset";
-const char kSetCapabilitiesMethod[] = "SetCapabilities";
-const char kSetCursorLocationMethod[] = "SetCursorLocation";
-const char kProcessKeyEventMethod[] = "ProcessKeyEvent";
-
 // Following variables are used in callback expectations.
 const uint32 kCapabilities = 12345;
 const int32 kCursorX = 30;
 const int32 kCursorY = 31;
 const int32 kCursorWidth = 32;
 const int32 kCursorHeight = 33;
 const uint32 kKeyval = 34;
 const uint32 kKeycode = 35;
 const uint32 kState = 36;
 const bool kIsKeyHandled = false;
@@ skipping 46 matching lines @@
   IBusInputContextClientTest() : response_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     // Create a mock bus.
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SYSTEM;
     mock_bus_ = new dbus::MockBus(options);
 
     // Create a mock proxy.
     mock_proxy_ = new dbus::MockObjectProxy(mock_bus_.get(),
-                                            kServiceName,
+                                            ibus::kServiceName,
                                             dbus::ObjectPath(kObjectPath));
 
     // Create a client.
     client_.reset(IBusInputContextClient::Create(
         REAL_DBUS_CLIENT_IMPLEMENTATION));
 
     // Set an expectation so mock_bus's GetObjectProxy() for the given service
     // name and the object path will return mock_proxy_. The GetObjectProxy
     // function is called in Initialized function.
-    EXPECT_CALL(*mock_bus_, GetObjectProxy(kServiceName,
+    EXPECT_CALL(*mock_bus_, GetObjectProxy(ibus::kServiceName,
                                            dbus::ObjectPath(kObjectPath)))
         .WillOnce(Return(mock_proxy_.get()));
 
     // Set expectations so mock_proxy's ConnectToSignal will use
     // OnConnectToSignal() to run the callback. The ConnectToSignal is called in
     // Initialize function.
     EXPECT_CALL(*mock_proxy_, ConnectToSignal(
-        kInputContextInterface, kCommitTextSignal, _, _))
+        ibus::input_context::kServiceInterface,
+        ibus::input_context::kCommitTextSignal, _, _))
         .WillRepeatedly(
             Invoke(this, &IBusInputContextClientTest::OnConnectToSignal));
     EXPECT_CALL(*mock_proxy_, ConnectToSignal(
-        kInputContextInterface, kForwardKeyEventSignal, _, _))
+        ibus::input_context::kServiceInterface,
+        ibus::input_context::kForwardKeyEventSignal, _, _))
         .WillRepeatedly(
             Invoke(this, &IBusInputContextClientTest::OnConnectToSignal));
     EXPECT_CALL(*mock_proxy_, ConnectToSignal(
-        kInputContextInterface, kHidePreeditTextSignal, _, _))
+        ibus::input_context::kServiceInterface,
+        ibus::input_context::kHidePreeditTextSignal, _, _))
         .WillRepeatedly(
             Invoke(this, &IBusInputContextClientTest::OnConnectToSignal));
     EXPECT_CALL(*mock_proxy_, ConnectToSignal(
-        kInputContextInterface, kShowPreeditTextSignal, _, _))
+        ibus::input_context::kServiceInterface,
+        ibus::input_context::kShowPreeditTextSignal, _, _))
         .WillRepeatedly(
             Invoke(this, &IBusInputContextClientTest::OnConnectToSignal));
     EXPECT_CALL(*mock_proxy_, ConnectToSignal(
-        kInputContextInterface, kUpdatePreeditTextSignal, _, _))
+        ibus::input_context::kServiceInterface,
+        ibus::input_context::kUpdatePreeditTextSignal, _, _))
         .WillRepeatedly(
             Invoke(this, &IBusInputContextClientTest::OnConnectToSignal));
 
     // Call Initialize to create object proxy and connect signals.
     client_->Initialize(mock_bus_.get(), dbus::ObjectPath(kObjectPath));
   }
 
   virtual void TearDown() OVERRIDE {
     EXPECT_TRUE(client_->IsObjectProxyReady());
     client_->ResetObjectProxy();
     EXPECT_FALSE(client_->IsObjectProxyReady());
   }
 
   // Handles FocusIn method call.
   void OnFocusIn(dbus::MethodCall* method_call,
                  int timeout_ms,
                  const dbus::ObjectProxy::ResponseCallback& callback,
                  const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kFocusInMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kFocusInMethod, method_call->GetMember());
     dbus::MessageReader reader(method_call);
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
   }
 
   // Handles FocusOut method call.
   void OnFocusOut(dbus::MethodCall* method_call,
                   int timeout_ms,
                   const dbus::ObjectProxy::ResponseCallback& callback,
                   const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kFocusOutMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kFocusOutMethod, method_call->GetMember());
     dbus::MessageReader reader(method_call);
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
   }
 
   // Handles Reset method call.
   void OnReset(dbus::MethodCall* method_call,
                int timeout_ms,
                const dbus::ObjectProxy::ResponseCallback& callback,
                const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kResetMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kResetMethod, method_call->GetMember());
     dbus::MessageReader reader(method_call);
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
   }
 
   // Handles SetCursorLocation method call.
   void OnSetCursorLocation(
       dbus::MethodCall* method_call,
       int timeout_ms,
       const dbus::ObjectProxy::ResponseCallback& callback,
       const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kSetCursorLocationMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kSetCursorLocationMethod,
+              method_call->GetMember());
     dbus::MessageReader reader(method_call);
     int32 x, y, width, height;
     EXPECT_TRUE(reader.PopInt32(&x));
     EXPECT_TRUE(reader.PopInt32(&y));
     EXPECT_TRUE(reader.PopInt32(&width));
     EXPECT_TRUE(reader.PopInt32(&height));
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
   }
 
   // Handles SetCapabilities method call.
   void OnSetCapabilities(
       dbus::MethodCall* method_call,
       int timeout_ms,
       const dbus::ObjectProxy::ResponseCallback& callback,
       const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kSetCapabilitiesMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kSetCapabilitiesMethod,
+              method_call->GetMember());
     uint32 capabilities;
     dbus::MessageReader reader(method_call);
     EXPECT_TRUE(reader.PopUint32(&capabilities));
     EXPECT_EQ(kCapabilities, capabilities);
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
   }
 
   // Handles ProcessKeyEvent method call.
   void OnProcessKeyEvent(
       dbus::MethodCall* method_call,
       int timeout_ms,
       const dbus::ObjectProxy::ResponseCallback& callback,
       const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kProcessKeyEventMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kProcessKeyEventMethod,
+              method_call->GetMember());
     uint32 keyval, keycode, state;
     dbus::MessageReader reader(method_call);
     EXPECT_TRUE(reader.PopUint32(&keyval));
     EXPECT_TRUE(reader.PopUint32(&keycode));
     EXPECT_TRUE(reader.PopUint32(&state));
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
   }
 
   void OnProcessKeyEventFail(
       dbus::MethodCall* method_call,
       int timeout_ms,
       const dbus::ObjectProxy::ResponseCallback& callback,
       const dbus::ObjectProxy::ErrorCallback& error_callback) {
-    EXPECT_EQ(kInputContextInterface, method_call->GetInterface());
-    EXPECT_EQ(kProcessKeyEventMethod, method_call->GetMember());
+    EXPECT_EQ(ibus::input_context::kServiceInterface,
+              method_call->GetInterface());
+    EXPECT_EQ(ibus::input_context::kProcessKeyEventMethod,
+              method_call->GetMember());
     uint32 keyval, keycode, state;
     dbus::MessageReader reader(method_call);
     EXPECT_TRUE(reader.PopUint32(&keyval));
     EXPECT_TRUE(reader.PopUint32(&keycode));
     EXPECT_TRUE(reader.PopUint32(&state));
     EXPECT_FALSE(reader.HasMoreData());
 
     message_loop_.PostTask(FROM_HERE, base::Bind(error_callback,
                                                  error_response_));
   }
@@ skipping 35 matching lines @@
   ibus_text.set_text(kSampleText);
 
   // Set handler expectations.
   MockCommitTextHandler handler;
   EXPECT_CALL(handler, Run(IBusTextEq(&ibus_text)));
   client_->SetCommitTextHandler(base::Bind(&MockCommitTextHandler::Run,
                                            base::Unretained(&handler)));
   message_loop_.RunAllPending();
 
   // Emit signal.
-  dbus::Signal signal(kInputContextInterface, kCommitTextSignal);
+  dbus::Signal signal(ibus::input_context::kServiceInterface,
+                      ibus::input_context::kCommitTextSignal);
   dbus::MessageWriter writer(&signal);
   AppendIBusText(ibus_text, &writer);
-  ASSERT_FALSE(signal_callback_map_[kCommitTextSignal].is_null());
-  signal_callback_map_[kCommitTextSignal].Run(&signal);
+  ASSERT_FALSE(
+      signal_callback_map_[ibus::input_context::kCommitTextSignal].is_null());
+  signal_callback_map_[ibus::input_context::kCommitTextSignal].Run(&signal);
 
   // Unset the handler so expect not calling handler.
   client_->UnsetCommitTextHandler();
-  signal_callback_map_[kCommitTextSignal].Run(&signal);
+  signal_callback_map_[ibus::input_context::kCommitTextSignal].Run(&signal);
 }
 
 TEST_F(IBusInputContextClientTest, ForwardKeyEventHandlerTest) {
   // Set handler expectations.
   MockForwardKeyEventHandler handler;
   EXPECT_CALL(handler, Run(kKeyval, kKeycode, kState));
   client_->SetForwardKeyEventHandler(
       base::Bind(&MockForwardKeyEventHandler::Run,
                  base::Unretained(&handler)));
   message_loop_.RunAllPending();
 
   // Emit signal.
-  dbus::Signal signal(kInputContextInterface, kForwardKeyEventSignal);
+  dbus::Signal signal(ibus::input_context::kServiceInterface,
+                      ibus::input_context::kForwardKeyEventSignal);
   dbus::MessageWriter writer(&signal);
   writer.AppendUint32(kKeyval);
   writer.AppendUint32(kKeycode);
   writer.AppendUint32(kState);
-  ASSERT_FALSE(signal_callback_map_[kForwardKeyEventSignal].is_null());
-  signal_callback_map_[kForwardKeyEventSignal].Run(&signal);
+  ASSERT_FALSE(
+      signal_callback_map_[ibus::input_context::kForwardKeyEventSignal]
+          .is_null());
+  signal_callback_map_[ibus::input_context::kForwardKeyEventSignal].Run(
+      &signal);
 
   // Unset the handler so expect not calling handler.
   client_->UnsetForwardKeyEventHandler();
-  signal_callback_map_[kForwardKeyEventSignal].Run(&signal);
+  signal_callback_map_[ibus::input_context::kForwardKeyEventSignal].Run(
+      &signal);
 }
 
 TEST_F(IBusInputContextClientTest, HidePreeditTextHandlerTest) {
   // Set handler expectations.
   MockHidePreeditTextHandler handler;
   EXPECT_CALL(handler, Run());
   client_->SetHidePreeditTextHandler(
       base::Bind(&MockHidePreeditTextHandler::Run,
                  base::Unretained(&handler)));
   message_loop_.RunAllPending();
 
   // Emit signal.
-  dbus::Signal signal(kInputContextInterface, kHidePreeditTextSignal);
-  ASSERT_FALSE(signal_callback_map_[kHidePreeditTextSignal].is_null());
-  signal_callback_map_[kHidePreeditTextSignal].Run(&signal);
+  dbus::Signal signal(ibus::input_context::kServiceInterface,
+                      ibus::input_context::kHidePreeditTextSignal);
+  ASSERT_FALSE(
+      signal_callback_map_[ibus::input_context::kHidePreeditTextSignal]
+          .is_null());
+  signal_callback_map_[ibus::input_context::kHidePreeditTextSignal].Run(
+      &signal);
 
   // Unset the handler so expect not calling handler.
   client_->UnsetHidePreeditTextHandler();
-  signal_callback_map_[kHidePreeditTextSignal].Run(&signal);
+  signal_callback_map_[ibus::input_context::kHidePreeditTextSignal].Run(
+      &signal);
 }
 
 TEST_F(IBusInputContextClientTest, ShowPreeditTextHandlerTest) {
   // Set handler expectations.
   MockShowPreeditTextHandler handler;
   EXPECT_CALL(handler, Run());
   client_->SetShowPreeditTextHandler(
       base::Bind(&MockShowPreeditTextHandler::Run,
                  base::Unretained(&handler)));
   message_loop_.RunAllPending();
 
   // Emit signal.
-  dbus::Signal signal(kInputContextInterface, kShowPreeditTextSignal);
-  ASSERT_FALSE(signal_callback_map_[kShowPreeditTextSignal].is_null());
-  signal_callback_map_[kShowPreeditTextSignal].Run(&signal);
+  dbus::Signal signal(ibus::input_context::kServiceInterface,
+                      ibus::input_context::kShowPreeditTextSignal);
+  ASSERT_FALSE(
+      signal_callback_map_[ibus::input_context::kShowPreeditTextSignal]
+          .is_null());
+  signal_callback_map_[ibus::input_context::kShowPreeditTextSignal].Run(
+      &signal);
 
   // Unset the handler so expect not calling handler.
   client_->UnsetShowPreeditTextHandler();
-  signal_callback_map_[kShowPreeditTextSignal].Run(&signal);
+  signal_callback_map_[ibus::input_context::kShowPreeditTextSignal].Run(
+      &signal);
 }
 
 TEST_F(IBusInputContextClientTest, UpdatePreeditTextHandlerTest) {
   const uint32 kCursorPos = 20;
   const bool kVisible = false;
   const char kSampleText[] = "Sample Text";
   IBusText ibus_text;
   ibus_text.set_text(kSampleText);
 
   // Set handler expectations.
   MockUpdatePreeditTextHandler handler;
   EXPECT_CALL(handler, Run(IBusTextEq(&ibus_text), kCursorPos, kVisible));
   client_->SetUpdatePreeditTextHandler(
       base::Bind(&MockUpdatePreeditTextHandler::Run,
                  base::Unretained(&handler)));
   message_loop_.RunAllPending();
 
   // Emit signal.
-  dbus::Signal signal(kInputContextInterface, kUpdatePreeditTextSignal);
+  dbus::Signal signal(ibus::input_context::kServiceInterface,
+                      ibus::input_context::kUpdatePreeditTextSignal);
   dbus::MessageWriter writer(&signal);
   AppendIBusText(ibus_text, &writer);
   writer.AppendUint32(kCursorPos);
   writer.AppendBool(kVisible);
-  ASSERT_FALSE(signal_callback_map_[kUpdatePreeditTextSignal].is_null());
-  signal_callback_map_[kUpdatePreeditTextSignal].Run(&signal);
+  ASSERT_FALSE(
+      signal_callback_map_[ibus::input_context::kUpdatePreeditTextSignal]
+          .is_null());
+  signal_callback_map_[ibus::input_context::kUpdatePreeditTextSignal].Run(
+      &signal);
 
   // Unset the handler so expect not calling handler.
   client_->UnsetUpdatePreeditTextHandler();
-  signal_callback_map_[kUpdatePreeditTextSignal].Run(&signal);
+  signal_callback_map_[ibus::input_context::kUpdatePreeditTextSignal].Run(
+      &signal);
 }
 
 TEST_F(IBusInputContextClientTest, FocusInTest) {
   // Set expectations.
   EXPECT_CALL(*mock_proxy_, CallMethodWithErrorCallback(_, _, _, _))
       .WillOnce(Invoke(this, &IBusInputContextClientTest::OnFocusIn));
   // Create response.
   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   response_ = response.get();
 
@@ skipping 109 matching lines @@
                            kState,
                            base::Bind(&MockProcessKeyEventHandler::Run,
                                       base::Unretained(&callback)),
                            base::Bind(&MockProcessKeyEventErrorHandler::Run,
                                       base::Unretained(&error_callback)));
   // Run the message loop.
   message_loop_.RunAllPending();
 }
 
 }  // namespace chromeos