Remove mozc from whitelist.

chrome/browser/chromeos/input_method/input_method_util_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 "chrome/browser/chromeos/input_method/input_method_util.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 98 matching lines @@
   }
   {
     InputMethodDescriptor desc = GetDesc("xkb:de:neo:ger", "de(neo)", "de");
     EXPECT_EQ(ASCIIToUTF16("NEO"), util_.GetInputMethodShortName(desc));
   }
   {
     InputMethodDescriptor desc = GetDesc("xkb:es:cat:cat", "es(cat)", "ca");
     EXPECT_EQ(ASCIIToUTF16("CAS"), util_.GetInputMethodShortName(desc));
   }
   {
-    InputMethodDescriptor desc = GetDesc("mozc", "us", "ja");
-    EXPECT_EQ(UTF8ToUTF16("\xe3\x81\x82"),
-              util_.GetInputMethodShortName(desc));
-  }
-  {
-    InputMethodDescriptor desc = GetDesc("mozc-jp", "jp", "ja");
-    EXPECT_EQ(UTF8ToUTF16("\xe3\x81\x82"),
-              util_.GetInputMethodShortName(desc));
-  }
-  {
     InputMethodDescriptor desc = GetDesc("pinyin", "us", "zh-CN");
     EXPECT_EQ(UTF8ToUTF16("\xe6\x8b\xbc"),
               util_.GetInputMethodShortName(desc));
   }
   {
     InputMethodDescriptor desc = GetDesc("pinyin-dv", "us(dvorak)", "zh-CN");
     EXPECT_EQ(UTF8ToUTF16("\xe6\x8b\xbc"),
               util_.GetInputMethodShortName(desc));
   }
   {
@@ skipping 32 matching lines @@
       string16 medium_name = util_.GetInputMethodMediumName(desc);
       string16 short_name = util_.GetInputMethodShortName(desc);
       EXPECT_EQ(medium_name,short_name);
     }
   }
   {
     // input methods with medium name not equal to short name
     const char * input_method_id[] = {
       "m17n:zh:cangjie",
       "m17n:zh:quick",
-      "mozc",
+      "pinyin",
       "mozc-chewing",
-      "mozc-dv",
       "mozc-hangul",
-      "mozc-jp",
+      "pinyin",
       "pinyin",
       "pinyin-dv",
     };
     const int len = ARRAYSIZE_UNSAFE(input_method_id);
     for (int i=0; i<len; ++i) {
       InputMethodDescriptor desc = GetDesc(input_method_id[i], "", "");
       string16 medium_name = util_.GetInputMethodMediumName(desc);
       string16 short_name = util_.GetInputMethodShortName(desc);
       EXPECT_NE(medium_name,short_name);
     }
@@ skipping 12 matching lines @@
     InputMethodDescriptor desc = GetDesc("mozc-hangul", "us", "ko");
     EXPECT_EQ(ASCIIToUTF16("Korean input method"),
               util_.GetInputMethodLongName(desc));
   }
   {
     InputMethodDescriptor desc = GetDesc("m17n:vi:tcvn", "us", "vi");
     EXPECT_EQ(ASCIIToUTF16("Vietnamese input method (TCVN6064)"),
               util_.GetInputMethodLongName(desc));
   }
   {
-    InputMethodDescriptor desc = GetDesc("mozc", "us", "ja");
-#if !defined(GOOGLE_CHROME_BUILD)
-    EXPECT_EQ(ASCIIToUTF16("Japanese input method (for US keyboard)"),
-#else
-    EXPECT_EQ(ASCIIToUTF16("Google Japanese Input (for US keyboard)"),
-#endif  // defined(GOOGLE_CHROME_BUILD)
+    InputMethodDescriptor desc = GetDesc("pinyin", "us", "ja");
+    EXPECT_EQ(ASCIIToUTF16("Pinyin input method"),
               util_.GetInputMethodLongName(desc));
   }
   {
     InputMethodDescriptor desc = GetDesc("xkb:jp::jpn", "jp", "ja");
     EXPECT_EQ(ASCIIToUTF16("Japanese keyboard"),
               util_.GetInputMethodLongName(desc));
   }
   {
     InputMethodDescriptor desc =
         GetDesc("xkb:us:dvorak:eng", "us(dvorak)", "en-US");
@@ skipping 50 matching lines @@
     // You can safely ignore the "Resouce ID is not found for: invalid-id"
     // error.
     EXPECT_EQ(ASCIIToUTF16("invalid-id"),
               util_.GetInputMethodLongName(desc));
   }
 }
 
 TEST_F(InputMethodUtilTest, TestGetStringUTF8) {
   EXPECT_EQ(UTF8ToUTF16("Pinyin input method"),
             util_.TranslateString("pinyin"));
-#if !defined(GOOGLE_CHROME_BUILD)
-  EXPECT_EQ(UTF8ToUTF16("Japanese input method (for US Dvorak keyboard)"),
-            util_.TranslateString("mozc-dv"));
-#endif
 }
 
 TEST_F(InputMethodUtilTest, TestIsValidInputMethodId) {
   EXPECT_TRUE(util_.IsValidInputMethodId("xkb:us:colemak:eng"));
-  EXPECT_TRUE(util_.IsValidInputMethodId("mozc"));
+  EXPECT_TRUE(util_.IsValidInputMethodId("pinyin"));
   EXPECT_FALSE(util_.IsValidInputMethodId("unsupported-input-method"));
 }
 
 TEST_F(InputMethodUtilTest, TestIsKeyboardLayout) {
   EXPECT_TRUE(InputMethodUtil::IsKeyboardLayout("xkb:us::eng"));
-  EXPECT_FALSE(InputMethodUtil::IsKeyboardLayout("mozc"));
+  EXPECT_FALSE(InputMethodUtil::IsKeyboardLayout("pinyin"));
 }
 
 TEST_F(InputMethodUtilTest, TestGetKeyboardLayoutName) {
   // Unsupported case.
   EXPECT_EQ("", util_.GetKeyboardLayoutName("UNSUPPORTED_ID"));
 
   // Supported cases (samples).
-  EXPECT_EQ("jp", util_.GetKeyboardLayoutName("mozc-jp"));
   EXPECT_EQ("us", util_.GetKeyboardLayoutName("pinyin"));
   EXPECT_EQ("us(dvorak)", util_.GetKeyboardLayoutName("pinyin-dv"));
   EXPECT_EQ("us", util_.GetKeyboardLayoutName("m17n:ar:kbd"));
   EXPECT_EQ("es", util_.GetKeyboardLayoutName("xkb:es::spa"));
   EXPECT_EQ("es(cat)", util_.GetKeyboardLayoutName("xkb:es:cat:cat"));
   EXPECT_EQ("gb(extd)", util_.GetKeyboardLayoutName("xkb:gb:extd:eng"));
   EXPECT_EQ("us", util_.GetKeyboardLayoutName("xkb:us::eng"));
   EXPECT_EQ("us(dvorak)", util_.GetKeyboardLayoutName("xkb:us:dvorak:eng"));
   EXPECT_EQ("us(colemak)", util_.GetKeyboardLayoutName("xkb:us:colemak:eng"));
   EXPECT_EQ("de(neo)", util_.GetKeyboardLayoutName("xkb:de:neo:ger"));
@@ skipping 20 matching lines @@
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   EXPECT_EQ("pinyin", descriptor->id());
   EXPECT_EQ("us", descriptor->GetPreferredKeyboardLayout());
   // This used to be "zh" but now we have "zh-CN" in input_methods.h,
   // hence this should be zh-CN now.
   EXPECT_EQ("zh-CN", descriptor->language_code());
 }
 
 TEST_F(InputMethodUtilTest, TestGetInputMethodIdsForLanguageCode) {
   std::multimap<std::string, std::string> language_code_to_ids_map;
-  language_code_to_ids_map.insert(std::make_pair("ja", "mozc"));
-  language_code_to_ids_map.insert(std::make_pair("ja", "mozc-jp"));
+  language_code_to_ids_map.insert(std::make_pair("ja", "pinyin"));
+  language_code_to_ids_map.insert(std::make_pair("ja", "pinyin"));
   language_code_to_ids_map.insert(std::make_pair("ja", "xkb:jp:jpn"));
   language_code_to_ids_map.insert(std::make_pair("fr", "xkb:fr:fra"));
 
   std::vector<std::string> result;
   EXPECT_TRUE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "ja", kAllInputMethods, &result));
   EXPECT_EQ(3U, result.size());
   EXPECT_TRUE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "ja", kKeyboardLayoutsOnly, &result));
   ASSERT_EQ(1U, result.size());
@@ skipping 18 matching lines @@
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_EnUs) {
   const InputMethodDescriptor* descriptor =
       util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
   util_.GetFirstLoginInputMethodIds("en-US", *descriptor, &input_method_ids);
   ASSERT_EQ(1U, input_method_ids.size());
   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
 }
 
-// US keyboard + Japanese UI = US keyboard + mozc.
-TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Ja) {
+// US keyboard + Chinese UI = US keyboard + Pinyin IME.
+TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Zh) {
   const InputMethodDescriptor* descriptor =
       util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  util_.GetFirstLoginInputMethodIds("ja", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("zh-CN", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
-  EXPECT_EQ("mozc", input_method_ids[1]);  // Mozc for US keybaord.
+  EXPECT_EQ("pinyin", input_method_ids[1]);  // Pinyin for US keybaord.
 }
 
-// JP keyboard + Japanese UI = JP keyboard + mozc-jp.
-TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_JP_And_Ja) {
+// Korean keyboard + Korean UI = Korean keyboard + mozc-hangul.
+TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_KR_And_Ko) {
+  // Korean keyboard
   const InputMethodDescriptor* descriptor =
-      util_.GetInputMethodDescriptorFromId("xkb:jp::jpn");  // Japanese keyboard
+      util_.GetInputMethodDescriptorFromId("xkb:kr:kr104:kor");
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  util_.GetFirstLoginInputMethodIds("ja", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("ko", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
-  EXPECT_EQ("xkb:jp::jpn", input_method_ids[0]);
-  EXPECT_EQ("mozc-jp", input_method_ids[1]);  // Mozc for JP keybaord.
-}
-
-// US dvorak keyboard + Japanese UI = US dvorak keyboard + mozc-dv.
-TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Dvorak_And_Ja) {
-  const InputMethodDescriptor* descriptor =
-      // US Drovak keyboard.
-      util_.GetInputMethodDescriptorFromId("xkb:us:dvorak:eng");
-  ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
-  std::vector<std::string> input_method_ids;
-  util_.GetFirstLoginInputMethodIds("ja", *descriptor, &input_method_ids);
-  ASSERT_EQ(2U, input_method_ids.size());
-  EXPECT_EQ("xkb:us:dvorak:eng", input_method_ids[0]);
-  EXPECT_EQ("mozc-dv", input_method_ids[1]);  // Mozc for US Dvorak keybaord.
+  EXPECT_EQ("xkb:kr:kr104:kor", input_method_ids[0]);
+  EXPECT_EQ("mozc-hangul", input_method_ids[1]);  // Mozc for JP keybaord.
 }
 
 // US keyboard + Russian UI = US keyboard + Russsian keyboard
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Ru) {
   const InputMethodDescriptor* descriptor =
       util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
   util_.GetFirstLoginInputMethodIds("ru", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
@@ skipping 34 matching lines @@
   util_.GetFirstLoginInputMethodIds("vi", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
   EXPECT_EQ("m17n:vi:tcvn", input_method_ids[1]);  // TCVN6064.
 }
 
 TEST_F(InputMethodUtilTest, TestGetLanguageCodesFromInputMethodIds) {
   std::vector<std::string> input_method_ids;
   input_method_ids.push_back("xkb:us::eng");  // English US.
   input_method_ids.push_back("xkb:us:dvorak:eng");  // English US Dvorak.
-  input_method_ids.push_back("mozc-jp");  // Japanese.
+  input_method_ids.push_back("pinyin");  // Pinyin
   input_method_ids.push_back("xkb:fr::fra");  // French France.
   std::vector<std::string> language_codes;
   util_.GetLanguageCodesFromInputMethodIds(input_method_ids, &language_codes);
   ASSERT_EQ(3U, language_codes.size());
   EXPECT_EQ("en-US", language_codes[0]);
-  EXPECT_EQ("ja", language_codes[1]);
+  EXPECT_EQ("zh-CN", language_codes[1]);
   EXPECT_EQ("fr", language_codes[2]);
 }
 
 // Test all supported descriptors to detect a typo in ibus_input_methods.txt.
 TEST_F(InputMethodUtilTest, TestIBusInputMethodText) {
   for (size_t i = 0; i < util_.supported_input_methods_->size(); ++i) {
     const std::string language_code =
         util_.supported_input_methods_->at(i).language_code();
     const string16 display_name =
         l10n_util::GetDisplayNameForLocale(language_code, "en", false);
     // Only two formats, like "fr" (lower case) and "en-US" (lower-upper), are
     // allowed. See the text file for details.
     EXPECT_TRUE(language_code.length() == 2 ||
                 (language_code.length() == 5 && language_code[2] == '-'))
         << "Invalid language code " << language_code;
     EXPECT_TRUE(l10n_util::IsValidLocaleSyntax(language_code))
         << "Invalid language code " << language_code;
     EXPECT_FALSE(display_name.empty())
         << "Invalid language code " << language_code;
     // On error, GetDisplayNameForLocale() returns the |language_code| as-is.
     EXPECT_NE(language_code, UTF16ToUTF8(display_name))
         << "Invalid language code " << language_code;
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos