sk6_charactercomposer: Merged DispatchKeyEvent and its fabricated version.

chrome/browser/chromeos/input_method/input_method_engine_ibus_browserttests.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 "base/bind_helpers.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
@@ skipping 11 matching lines @@
 namespace input_method {
 namespace {
 
 const char kIdentityIMEID[] =
     "_ext_ime_iafoklpfplgfnoimmaejoeondnjnlcfpIdentityIME";
 const char kToUpperIMEID[] =
     "_ext_ime_iafoklpfplgfnoimmaejoeondnjnlcfpToUpperIME";
 const char kAPIArgumentIMEID[] =
     "_ext_ime_iafoklpfplgfnoimmaejoeondnjnlcfpAPIArgumentIME";
 
-const uint32 kAltKeyMask = 1 << 3;
-const uint32 kCtrlKeyMask = 1 << 2;
-const uint32 kShiftKeyMask = 1 << 0;
-const uint32 kCapsLockMask = 1 << 1;
-
 // InputMethod extension should work on 1)normal extension, 2)normal extension
 // in incognito mode 3)component extension.
 enum TestType {
   kTestTypeNormal = 0,
   kTestTypeIncognito = 1,
   kTestTypeComponent = 2,
 };
 
 class InputMethodEngineIBusBrowserTest
     : public ExtensionBrowserTest,
@@ skipping 135 matching lines @@
 
   // onFocus event should be fired if FocusIn function is called.
   ExtensionTestMessageListener focus_listener("onFocus", false);;
   engine_handler->FocusIn(ibus::TEXT_INPUT_TYPE_TEXT);
   ASSERT_TRUE(focus_listener.WaitUntilSatisfied());
   ASSERT_TRUE(focus_listener.was_satisfied());
 
   // onKeyEvent should be fired if ProcessKeyEvent is called.
   KeyEventDoneCallback callback(false);  // EchoBackIME doesn't consume keys.
   ExtensionTestMessageListener keyevent_listener("onKeyEvent", false);
+  /*
   engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
                                   0x26,  // KeyCode for 'a'.
                                   0,  // No modifiers.
                                   base::Bind(&KeyEventDoneCallback::Run,
                                              base::Unretained(&callback)));
+  */
+  engine_handler->ProcessKeyEvent("a",     // KeySym
+                                  "KeyA",  // KeyCode for 'a'
+                                  true,    // is_key_down
+                                  false,   // is_alt_down
+                                  false,   // is_ctrl_down
+                                  false,   // is_shift_down
+                                  false,   // is_caps_lock_down
+                                  base::Bind(&KeyEventDoneCallback::Run,
+                                             base::Unretained(&callback)));
+
   ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
   ASSERT_TRUE(keyevent_listener.was_satisfied());
   callback.WaitUntilCalled();
 
   // onSurroundingTextChange should be fired if SetSurroundingText is called.
   ExtensionTestMessageListener surrounding_text_listener(
       "onSurroundingTextChanged", false);
   engine_handler->SetSurroundingText("text",  // Surrounding text.
                                      0,  // focused position.
                                      1);  // anchor position.
@@ skipping 58 matching lines @@
   engine_handler->Enable();
   engine_handler->FocusIn(ibus::TEXT_INPUT_TYPE_TEXT);
 
   {
     SCOPED_TRACE("KeyDown, Ctrl:No, alt:No, Shift:No, Caps:No");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:false:false:false:false";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    0,  // No modifiers.
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    false,   // is_alt_down
+                                    false,   // is_ctrl_down
+                                    false,   // is_shift_down
+                                    false,   // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   {
     SCOPED_TRACE("KeyDown, Ctrl:Yes, alt:No, Shift:No, Caps:No");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:true:false:false:false";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    kCtrlKeyMask,
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    false,   // is_alt_down
+                                    true,    // is_ctrl_down
+                                    false,   // is_shift_down
+                                    false,   // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   {
     SCOPED_TRACE("KeyDown, Ctrl:No, alt:Yes, Shift:No, Caps:No");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:false:true:false:false";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    kAltKeyMask,
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    true,    // is_alt_down
+                                    false,   // is_ctrl_down
+                                    false,   // is_shift_down
+                                    false,   // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   {
     SCOPED_TRACE("KeyDown, Ctrl:No, alt:No, Shift:Yes, Caps:No");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:false:false:true:false";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    kShiftKeyMask,
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    false,   // is_alt_down
+                                    false,   // is_ctrl_down
+                                    true,    // is_shift_down
+                                    false,   // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   {
     SCOPED_TRACE("KeyDown, Ctrl:No, alt:No, Shift:No, Caps:Yes");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:false:false:false:true";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    kCapsLockMask,
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    false,   // is_alt_down
+                                    false,   // is_ctrl_down
+                                    false,   // is_shift_down
+                                    true,    // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   {
     SCOPED_TRACE("KeyDown, Ctrl:Yes, alt:Yes, Shift:No, Caps:No");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:true:true:false:false";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    kAltKeyMask | kCtrlKeyMask,
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    true,    // is_alt_down
+                                    true,    // is_ctrl_down
+                                    false,   // is_shift_down
+                                    false,   // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   {
     SCOPED_TRACE("KeyDown, Ctrl:No, alt:No, Shift:Yes, Caps:Yes");
     KeyEventDoneCallback callback(false);
     const std::string expected_value =
         "onKeyEvent:keydown:a:KeyA:false:false:true:true";
     ExtensionTestMessageListener keyevent_listener(expected_value, false);
 
-    engine_handler->ProcessKeyEvent(0x61,  // KeySym for 'a'.
-                                    0x26,  // KeyCode for 'a'.
-                                    kShiftKeyMask | kCapsLockMask,
+    engine_handler->ProcessKeyEvent("a",     // KeySym
+                                    "KeyA",  // KeyCode for 'a'
+                                    true,    // is_key_down
+                                    false,   // is_alt_down
+                                    false,   // is_ctrl_down
+                                    true,    // is_shift_down
+                                    true,    // is_caps_lock_down
                                     base::Bind(&KeyEventDoneCallback::Run,
                                                base::Unretained(&callback)));
     ASSERT_TRUE(keyevent_listener.WaitUntilSatisfied());
     EXPECT_TRUE(keyevent_listener.was_satisfied());
     callback.WaitUntilCalled();
   }
   // TODO(nona): Add browser tests for other API as well.
   {
     SCOPED_TRACE("commitText test");
     mock_input_context->Reset();
@@ skipping 411 matching lines @@
               mock_input_context->last_delete_surrounding_text_arg().length);
   }
   IBusBridge::Get()->SetInputContextHandler(NULL);
   IBusBridge::Get()->SetCandidateWindowHandler(NULL);
   IBusBridge::Get()->SetPropertyHandler(NULL);
 }
 
 }  // namespace
 }  // namespace input_method
 }  // namespace chromeos