Supports unicode composition(Ctrl+Shift+U) with C-S pressed.

ui/base/ime/character_composer_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 "ui/base/ime/character_composer.h"
 
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/gtk+/gdk/gdkkeysyms.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/glib/glib_integers.h"
 
 namespace ui {
 
 namespace {
 
 // Expects key is not filtered and no character is composed.
 void ExpectKeyNotFiltered(CharacterComposer* character_composer,
                           uint key,
-                          uint flags) {
-  EXPECT_FALSE(character_composer->FilterKeyPress(key, flags));
+                          int flags) {
+  EXPECT_FALSE(character_composer->FilterKeyPress(key, 0, flags));
   EXPECT_TRUE(character_composer->composed_character().empty());
 }
 
 // Expects key is filtered and no character is composed.
 void ExpectKeyFiltered(CharacterComposer* character_composer,
                        uint key,
-                       uint flags) {
-  EXPECT_TRUE(character_composer->FilterKeyPress(key, flags));
+                       int flags) {
+  EXPECT_TRUE(character_composer->FilterKeyPress(key, 0, flags));
   EXPECT_TRUE(character_composer->composed_character().empty());
 }
 
+// Expects key is filtered and no character is composed.
+void ExpectKeyFilteredWithKeycode(CharacterComposer* character_composer,
+                                  uint key,
+                                  uint keycode,
+                                  int flags) {
+  EXPECT_TRUE(character_composer->FilterKeyPress(key, keycode, flags));
+  EXPECT_TRUE(character_composer->composed_character().empty());
+}
+
 // Expects |expected_character| is composed after sequence [key1, key2].
 void ExpectCharacterComposed(CharacterComposer* character_composer,
                              uint key1,
                              uint key2,
-                             uint flags,
+                             int flags,
                              const string16& expected_character) {
   ExpectKeyFiltered(character_composer, key1, flags);
-  EXPECT_TRUE(character_composer->FilterKeyPress(key2, flags));
+  EXPECT_TRUE(character_composer->FilterKeyPress(key2, 0, flags));
   EXPECT_EQ(expected_character, character_composer->composed_character());
 }
 
 // Expects |expected_character| is composed after sequence [key1, key2, key3].
 void ExpectCharacterComposed(CharacterComposer* character_composer,
                              uint key1,
                              uint key2,
                              uint key3,
-                             uint flags,
+                             int flags,
                              const string16& expected_character) {
   ExpectKeyFiltered(character_composer, key1, flags);
   ExpectCharacterComposed(character_composer, key2, key3, flags,
                           expected_character);
 }
 
 // Expects |expected_character| is composed after sequence [key1, key2, key3,
 // key 4].
 void ExpectCharacterComposed(CharacterComposer* character_composer,
                              uint key1,
                              uint key2,
                              uint key3,
                              uint key4,
-                             uint flags,
+                             int flags,
                              const string16& expected_character) {
   ExpectKeyFiltered(character_composer, key1, flags);
   ExpectCharacterComposed(character_composer, key2, key3, key4, flags,
                           expected_character);
 }
 
 // Expects |expected_character| is composed after sequence [key1, key2, key3,
 // key 4, key5].
 void ExpectCharacterComposed(CharacterComposer* character_composer,
                              uint key1,
                              uint key2,
                              uint key3,
                              uint key4,
                              uint key5,
-                             uint flags,
+                             int flags,
                              const string16& expected_character) {
   ExpectKeyFiltered(character_composer, key1, flags);
   ExpectCharacterComposed(character_composer, key2, key3, key4, key5, flags,
                           expected_character);
 }
 
 // Expects |expected_character| is composed after sequence [key1, key2, key3,
 // key 4, key5, key6].
 void ExpectCharacterComposed(CharacterComposer* character_composer,
                              uint key1,
                              uint key2,
                              uint key3,
                              uint key4,
                              uint key5,
                              uint key6,
-                             uint flags,
+                             int flags,
                              const string16& expected_character) {
   ExpectKeyFiltered(character_composer, key1, flags);
   ExpectCharacterComposed(character_composer, key2, key3, key4, key5, key6,
                           flags, expected_character);
 }
 
+// Expects |expected_character| is composed after sequence [{key1, keycode1}].
+void ExpectCharacterComposedWithKeyCode(CharacterComposer* character_composer,
+                                        uint key1, uint keycode1,
+                                        int flags,
+                                        const string16& expected_character) {
+  EXPECT_TRUE(character_composer->FilterKeyPress(key1, keycode1, flags));
+  EXPECT_EQ(expected_character, character_composer->composed_character());
+}
+
 } // namespace
 
 TEST(CharacterComposerTest, InitialState) {
   CharacterComposer character_composer;
   EXPECT_TRUE(character_composer.composed_character().empty());
 }
 
 TEST(CharacterComposerTest, NormalKeyIsNotFiltered) {
   CharacterComposer character_composer;
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_B, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_Z, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_c, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_m, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_0, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_1, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_8, 0);
 }
 
 TEST(CharacterComposerTest, PartiallyMatchingSequence) {
   CharacterComposer character_composer;
 
   // Composition with sequence ['dead acute', '1'] will fail.
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_1, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_1, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 
   // Composition with sequence ['dead acute', 'dead circumflex', '1'] will fail.
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0);
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_circumflex, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_1, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_1, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 }
 
 TEST(CharacterComposerTest, FullyMatchingSequences) {
   CharacterComposer character_composer;
   // LATIN SMALL LETTER A WITH ACUTE
   ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_a, 0,
                           string16(1, 0x00E1));
   // LATIN CAPITAL LETTER A WITH ACUTE
   ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_A, 0,
@@ skipping 14 matching lines @@
   // LATIN SMALL LETTER C WITH CEDILLA
   ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_c, 0,
                           string16(1, 0x00E7));
 }
 
 TEST(CharacterComposerTest, FullyMatchingSequencesAfterMatchingFailure) {
   CharacterComposer character_composer;
   // Composition with sequence ['dead acute', 'dead circumflex', '1'] will fail.
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0);
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_circumflex, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_1, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_1, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
   // LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE
   ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute,
                           GDK_KEY_dead_circumflex, GDK_KEY_a, 0,
                           string16(1, 0x1EA5));
 }
 
 TEST(CharacterComposerTest, ComposedCharacterIsClearedAfterReset) {
   CharacterComposer character_composer;
   ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_a, 0,
                           string16(1, 0x00E1));
   character_composer.Reset();
   EXPECT_TRUE(character_composer.composed_character().empty());
 }
 
 TEST(CharacterComposerTest, CompositionStateIsClearedAfterReset) {
   CharacterComposer character_composer;
   // Even though sequence ['dead acute', 'a'] will compose 'a with acute',
   // no character is composed here because of reset.
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0);
   character_composer.Reset();
-  EXPECT_FALSE(character_composer.FilterKeyPress(GDK_KEY_a, 0));
+  EXPECT_FALSE(character_composer.FilterKeyPress(GDK_KEY_a, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 }
 
 TEST(CharacterComposerTest, KeySequenceCompositionPreedit) {
   CharacterComposer character_composer;
   // LATIN SMALL LETTER A WITH ACUTE
   // preedit_string() is always empty in key sequence composition mode.
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0);
   EXPECT_TRUE(character_composer.preedit_string().empty());
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_a, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_a, 0, 0));
   EXPECT_EQ(string16(1, 0x00E1), character_composer.composed_character());
   EXPECT_TRUE(character_composer.preedit_string().empty());
 }
 
 // ComposeCheckerWithCompactTable in character_composer.cc is depending on the
 // assumption that the data in gtkimcontextsimpleseqs.h is correctly ordered.
 TEST(CharacterComposerTest, MainTableIsCorrectlyOrdered) {
   // This file is included here intentionally, instead of the top of the file,
   // because including this file at the top of the file will define a
   // global constant and contaminate the global namespace.
@@ skipping 167 matching lines @@
 
   // Backspace twice after Ctrl+Shift+U and 3.
   ExpectKeyFiltered(&character_composer, GDK_KEY_U,
                     EF_SHIFT_DOWN | EF_CONTROL_DOWN);
   ExpectKeyFiltered(&character_composer, GDK_KEY_3, 0);
   ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0);
   ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0);
   ExpectKeyNotFiltered(&character_composer, GDK_KEY_3, 0);
 }
 
+TEST(CharacterComposerTest, HexadecimalCompositionPreeditWithModifierPressed) {
+  // This test case supposes X Window System uses 101 keyboard layout.
+  CharacterComposer character_composer;
+  const int control_shift =  EF_CONTROL_DOWN | EF_SHIFT_DOWN;
+  // HIRAGANA LETTER A (U+3042)
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_U, 30, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_numbersign, 12, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u3"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_parenright, 19, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_dollar, 13, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_A, 38, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u304a"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_BackSpace, 22, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_at, 11, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u3042"), character_composer.preedit_string());
+  ExpectCharacterComposedWithKeyCode(&character_composer,
+                                     GDK_KEY_Return, 36,
+                                     control_shift,
+                                     string16(1, 0x3042));
+  EXPECT_EQ(ASCIIToUTF16(""), character_composer.preedit_string());
+
+  // Sequence with an ignored character (control + shift + 'x') and Escape.
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_U, 30, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_numbersign, 12, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u3"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_parenright, 19, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_X, 53, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_dollar, 13, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_at, 11, control_shift);
+  EXPECT_EQ(ASCIIToUTF16("u3042"), character_composer.preedit_string());
+  ExpectKeyFilteredWithKeycode(&character_composer,
+                               GDK_KEY_Escape, 9, control_shift);
+  EXPECT_EQ(ASCIIToUTF16(""), character_composer.preedit_string());
+}
+
 TEST(CharacterComposerTest, InvalidHexadecimalSequence) {
   CharacterComposer character_composer;
   // U+FFFFFFFF
   ExpectKeyFiltered(&character_composer, GDK_KEY_U,
                     EF_SHIFT_DOWN | EF_CONTROL_DOWN);
   for (int i = 0; i < 8; ++i)
     ExpectKeyFiltered(&character_composer, GDK_KEY_f, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 
   // U+0000 (Actually, this is a valid unicode character, but we don't
   // compose a string with a character '\0')
   ExpectKeyFiltered(&character_composer, GDK_KEY_U,
                     EF_SHIFT_DOWN | EF_CONTROL_DOWN);
   for (int i = 0; i < 4; ++i)
     ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 
   // U+10FFFF
   ExpectKeyFiltered(&character_composer, GDK_KEY_U,
                     EF_SHIFT_DOWN | EF_CONTROL_DOWN);
   ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0);
   ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0);
   for (int i = 0; i < 4; ++i)
     ExpectKeyFiltered(&character_composer, GDK_KEY_f, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 
   // U+110000
   ExpectKeyFiltered(&character_composer, GDK_KEY_U,
                     EF_SHIFT_DOWN | EF_CONTROL_DOWN);
   ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0);
   ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0);
   for (int i = 0; i < 4; ++i)
     ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0);
-  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0));
+  EXPECT_TRUE(character_composer.FilterKeyPress(GDK_KEY_space, 0, 0));
   EXPECT_TRUE(character_composer.composed_character().empty());
 }
 
 TEST(CharacterComposerTest, HexadecimalSequenceAndDeadKey) {
   CharacterComposer character_composer;
   // LATIN SMALL LETTER A WITH ACUTE
   ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_a, 0,
                           string16(1, 0x00E1));
   // HIRAGANA LETTER A (U+3042) with dead_acute ignored.
   ExpectKeyFiltered(&character_composer, GDK_KEY_U,
                     EF_SHIFT_DOWN | EF_CONTROL_DOWN);
   ExpectCharacterComposed(&character_composer, GDK_KEY_3, GDK_KEY_0,
                           GDK_KEY_dead_acute, GDK_KEY_4,  GDK_KEY_2,
                           GDK_KEY_space, 0, string16(1, 0x3042));
   // LATIN CAPITAL LETTER U WITH ACUTE while 'U' is pressed with Ctrl+Shift.
   ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0);
   EXPECT_TRUE(character_composer.FilterKeyPress(
-      GDK_KEY_U, EF_SHIFT_DOWN | EF_CONTROL_DOWN));
+      GDK_KEY_U, 0, EF_SHIFT_DOWN | EF_CONTROL_DOWN));
   EXPECT_EQ(string16(1, 0x00DA), character_composer.composed_character());
 }
 
 }  // namespace ui