Copy ibus_input_methods.h and keyboard_overlay_map.h to Chrome tree.

The change is to fix the implicit build dependency to libcros, described at
crosbug.com/16629. Instead of copying files, we should move the generation
process to Chrome, but that will be done in a separate patch.

BUG=chromium-os:16629,chromium-os:16330,chromium-os:16238
TEST=chrome builds both inside and outside the chroot

Review URL: http://codereview.chromium.org/7192005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@89303 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 218 insertions, 60 deletions

diff --git a/chrome/browser/chromeos/input_method/ibus_controller.cc b/chrome/browser/chromeos/input_method/ibus_controller.cc
index 8fa3c38..771b417 100644
--- a/chrome/browser/chromeos/input_method/ibus_controller.cc
+++ b/chrome/browser/chromeos/input_method/ibus_controller.cc
@@ -16,22 +16,10 @@
 #include <stack>
 #include <utility>
 
-#if defined(HAVE_IBUS)
-// TODO(satorux): Move these to Chrome tree.
-#include <cros/chromeos_input_method_whitelist.h>
-#include <cros/ibus_input_methods.h>
-#else
-const char* kInputMethodIdsWhitelist[] = {
-  "xkb:us::eng",
-};
-const char* kXkbLayoutsWhitelist[] = {
-  "us",
-};
-#endif  // defined(HAVE_IBUS)
-
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
+#include "chrome/browser/chromeos/input_method/ibus_input_methods.h"
 
 namespace chromeos {
 namespace input_method {
@@ -93,17 +81,15 @@ ImeConfigValue::~ImeConfigValue() {
 // refactor the two functions.
 InputMethodDescriptors* GetSupportedInputMethodDescriptors() {
   InputMethodDescriptors* input_methods = new InputMethodDescriptors;
-#if defined(HAVE_IBUS)
-  for (size_t i = 0; i < arraysize(chromeos::kIBusEngines); ++i) {
-    if (InputMethodIdIsWhitelisted(chromeos::kIBusEngines[i].name)) {
+  for (size_t i = 0; i < arraysize(kIBusEngines); ++i) {
+    if (InputMethodIdIsWhitelisted(kIBusEngines[i].id)) {
       input_methods->push_back(CreateInputMethodDescriptor(
-          chromeos::kIBusEngines[i].name,
-          chromeos::kIBusEngines[i].longname,
-          chromeos::kIBusEngines[i].layout,
-          chromeos::kIBusEngines[i].language));
+          kIBusEngines[i].id,
+          kIBusEngines[i].longname,
+          kIBusEngines[i].layout,
+          kIBusEngines[i].language));
     }
   }
-#endif  // defined(HAVE_IBUS)
   return input_methods;
 }
 
@@ -112,8 +98,8 @@ bool InputMethodIdIsWhitelisted(const std::string& input_method_id) {
   static std::set<std::string>* g_supported_input_methods = NULL;
   if (!g_supported_input_methods) {
     g_supported_input_methods = new std::set<std::string>;
-    for (size_t i = 0; i < arraysize(kInputMethodIdsWhitelist); ++i) {
-      g_supported_input_methods->insert(kInputMethodIdsWhitelist[i]);
+    for (size_t i = 0; i < arraysize(kIBusEngines); ++i) {
+      g_supported_input_methods->insert(kIBusEngines[i].id);
     }
   }
   return (g_supported_input_methods->count(input_method_id) > 0);
@@ -124,8 +110,8 @@ bool XkbLayoutIsSupported(const std::string& xkb_layout) {
   static std::set<std::string>* g_supported_layouts = NULL;
   if (!g_supported_layouts) {
     g_supported_layouts = new std::set<std::string>;
-    for (size_t i = 0; i < arraysize(kXkbLayoutsWhitelist); ++i) {
-      g_supported_layouts->insert(kXkbLayoutsWhitelist[i]);
+    for (size_t i = 0; i < arraysize(kIBusEngines); ++i) {
+      g_supported_layouts->insert(kIBusEngines[i].layout);
     }
   }
   return (g_supported_layouts->count(xkb_layout) > 0);
@@ -961,7 +947,7 @@ class IBusControllerImpl : public IBusController {
 
     const IBusEngineInfo* engine_info = NULL;
     for (size_t i = 0; i < arraysize(kIBusEngines); ++i) {
-      if (kIBusEngines[i].name == std::string(current_global_engine_id)) {
+      if (kIBusEngines[i].id == std::string(current_global_engine_id)) {
         engine_info = &kIBusEngines[i];
         break;
       }
@@ -974,7 +960,7 @@ class IBusControllerImpl : public IBusController {
     }
 
     InputMethodDescriptor current_input_method =
-        CreateInputMethodDescriptor(engine_info->name,
+        CreateInputMethodDescriptor(engine_info->id,
                                     engine_info->longname,
                                     engine_info->layout,
                                     engine_info->language);
diff --git a/chrome/browser/chromeos/input_method/ibus_controller.h b/chrome/browser/chromeos/input_method/ibus_controller.h
index b990abd..b177811 100644
--- a/chrome/browser/chromeos/input_method/ibus_controller.h
+++ b/chrome/browser/chromeos/input_method/ibus_controller.h
@@ -17,9 +17,7 @@
 namespace chromeos {
 namespace input_method {
 
-// A structure which represents an input method. All methods in this class have
-// to be in chromeos_input_method.h since Chrome also creates an instance of
-// the class.
+// A structure which represents an input method.
 struct InputMethodDescriptor {
   InputMethodDescriptor();
 
diff --git a/chrome/browser/chromeos/input_method/ibus_controller_unittest.cc b/chrome/browser/chromeos/input_method/ibus_controller_unittest.cc
index ffea1ac..a4a991a 100644
--- a/chrome/browser/chromeos/input_method/ibus_controller_unittest.cc
+++ b/chrome/browser/chromeos/input_method/ibus_controller_unittest.cc
@@ -17,10 +17,7 @@ InputMethodDescriptor GetDesc(const std::string& raw_layout) {
 }
 }  // namespace
 
-// Tests InputMethodIdIsWhitelisted function.
-// TODO(satorux): Enable this test once InputMethodIdIsWhitelisted() is
-// functional outside the chroot.
-TEST(IBusControllerTest, DISABLED_TestInputMethodIdIsWhitelisted) {
+TEST(IBusControllerTest, InputMethodIdIsWhitelisted) {
   EXPECT_TRUE(InputMethodIdIsWhitelisted("mozc"));
   EXPECT_TRUE(InputMethodIdIsWhitelisted("xkb:us:dvorak:eng"));
   EXPECT_FALSE(InputMethodIdIsWhitelisted("mozc,"));
@@ -30,10 +27,7 @@ TEST(IBusControllerTest, DISABLED_TestInputMethodIdIsWhitelisted) {
   EXPECT_FALSE(InputMethodIdIsWhitelisted(""));
 }
 
-// Tests XkbLayoutIsSupported function.
-// TODO(satorux): Enable this test once XkbLayoutIsSupported() is
-// functional outside the chroot.
-TEST(IBusControllerTest, DISABLED_TestXkbLayoutIsSupported) {
+TEST(IBusControllerTest, XkbLayoutIsSupported) {
   EXPECT_TRUE(XkbLayoutIsSupported("us"));
   EXPECT_TRUE(XkbLayoutIsSupported("us(dvorak)"));
   EXPECT_TRUE(XkbLayoutIsSupported("fr"));
@@ -45,25 +39,22 @@ TEST(IBusControllerTest, DISABLED_TestXkbLayoutIsSupported) {
   EXPECT_FALSE(XkbLayoutIsSupported(""));
 }
 
-// Tests CreateInputMethodDescriptor function.
-// TODO(satorux): Enable this test once CreateInputMethodDescriptor() is
-// functional outside the chroot.
-TEST(IBusControllerTest, DISABLED_TestCreateInputMethodDescriptor) {
-  EXPECT_EQ(GetDesc("us").keyboard_layout, "us");
-  EXPECT_EQ(GetDesc("us,us(dvorak)").keyboard_layout, "us");
-  EXPECT_EQ(GetDesc("us(dvorak),us").keyboard_layout, "us(dvorak)");
+TEST(IBusControllerTest, CreateInputMethodDescriptor) {
+  EXPECT_EQ("us", GetDesc("us").keyboard_layout);
+  EXPECT_EQ("us", GetDesc("us,us(dvorak)").keyboard_layout);
+  EXPECT_EQ("us(dvorak)", GetDesc("us(dvorak),us").keyboard_layout);
 
-  EXPECT_EQ(GetDesc("fr").keyboard_layout, "fr");
-  EXPECT_EQ(GetDesc("fr,us(dvorak)").keyboard_layout, "fr");
-  EXPECT_EQ(GetDesc("us(dvorak),fr").keyboard_layout, "us(dvorak)");
+  EXPECT_EQ("fr", GetDesc("fr").keyboard_layout);
+  EXPECT_EQ("fr", GetDesc("fr,us(dvorak)").keyboard_layout);
+  EXPECT_EQ("us(dvorak)", GetDesc("us(dvorak),fr").keyboard_layout);
 
-  EXPECT_EQ(GetDesc("not-supported,fr").keyboard_layout, "fr");
-  EXPECT_EQ(GetDesc("fr,not-supported").keyboard_layout, "fr");
+  EXPECT_EQ("fr", GetDesc("not-supported,fr").keyboard_layout);
+  EXPECT_EQ("fr", GetDesc("fr,not-supported").keyboard_layout);
 
   static const char kFallbackLayout[] = "us";
-  EXPECT_EQ(GetDesc("not-supported").keyboard_layout, kFallbackLayout);
-  EXPECT_EQ(GetDesc(",").keyboard_layout, kFallbackLayout);
-  EXPECT_EQ(GetDesc("").keyboard_layout, kFallbackLayout);
+  EXPECT_EQ(kFallbackLayout, GetDesc("not-supported").keyboard_layout);
+  EXPECT_EQ(kFallbackLayout, GetDesc(",").keyboard_layout);
+  EXPECT_EQ(kFallbackLayout, GetDesc("").keyboard_layout);
 
   // TODO(yusukes): Add tests for |virtual_keyboard_layout| member.
 }
diff --git a/chrome/browser/chromeos/input_method/ibus_input_methods.h b/chrome/browser/chromeos/input_method/ibus_input_methods.h
new file mode 100644
index 0000000..e3c1c27
--- /dev/null
+++ b/chrome/browser/chromeos/input_method/ibus_input_methods.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2011 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.
+//
+// This file is automatically generated by gen_engines.py in libcros.
+// TODO(satorux): Move the generation process to Chrome. crosbug.com/16630.
+
+#ifndef CHROME_BROWSER_CHROMEOS_INPUT_METHOD_IBUS_INPUT_METHODS_H_
+#define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_IBUS_INPUT_METHODS_H_
+#pragma once
+
+namespace chromeos {
+namespace input_method {
+
+struct IBusEngineInfo {
+  const char* id;
+  const char* longname;
+  const char* layout;
+  const char* language;
+};
+const IBusEngineInfo kIBusEngines[] = {
+{"xkb:nl::nld", "Netherlands", "nl", "nld"},
+{"xkb:be::nld", "Belgium", "be", "nld"},
+{"xkb:fr::fra", "France", "fr", "fra"},
+{"xkb:be::fra", "Belgium", "be", "fra"},
+{"xkb:ca::fra", "Canada", "ca", "fra"},
+{"xkb:ch:fr:fra", "Switzerland - French", "ch(fr)", "fra"},
+{"xkb:de::ger", "Germany", "de", "ger"},
+{"xkb:de:neo:ger", "Germany - Neo 2", "de(neo)", "ger"},
+{"xkb:be::ger", "Belgium", "be", "ger"},
+{"xkb:ch::ger", "Switzerland", "ch", "ger"},
+{"mozc", "Mozc (US keyboard layout)", "us", "ja"},
+{"mozc-jp", "Mozc (Japanese keyboard layout)", "jp", "ja"},
+{"mozc-dv", "Mozc (US Dvorak keyboard layout)", "us(dvorak)", "ja"},
+{"xkb:jp::jpn", "Japan", "jp", "jpn"},
+{"xkb:ru::rus", "Russia", "ru", "rus"},
+{"xkb:ru:phonetic:rus", "Russia - Phonetic", "ru(phonetic)", "rus"},
+{"m17n:th:kesmanee", "kesmanee (m17n)", "us", "th"},
+{"m17n:th:pattachote", "pattachote (m17n)", "us", "th"},
+{"m17n:th:tis820", "tis820 (m17n)", "us", "th"},
+{"pinyin", "Pinyin", "us", "zh-CN"},
+{"pinyin-dv", "Pinyin (for US Dvorak keyboard)", "us(dvorak)", "zh-CN"},
+{"mozc-chewing", "Mozc Chewing (Chewing)", "us", "zh_TW"},
+{"m17n:zh:cangjie", "cangjie (m17n)", "us", "zh"},
+{"m17n:zh:quick", "quick (m17n)", "us", "zh"},
+{"m17n:vi:tcvn", "tcvn (m17n)", "us", "vi"},
+{"m17n:vi:telex", "telex (m17n)", "us", "vi"},
+{"m17n:vi:viqr", "viqr (m17n)", "us", "vi"},
+{"m17n:vi:vni", "vni (m17n)", "us", "vi"},
+{"xkb:us::eng", "USA", "us", "eng"},
+{"xkb:us:intl:eng", "USA - International (with dead keys)", "us(intl)", "eng"},
+{"xkb:us:altgr-intl:eng", "USA - International (AltGr dead keys)", "us(altgr-intl)", "eng"},
+{"xkb:us:dvorak:eng", "USA - Dvorak", "us(dvorak)", "eng"},
+{"xkb:us:colemak:eng", "USA - Colemak", "us(colemak)", "eng"},
+{"hangul", "Korean", "kr(kr104)", "ko"},
+{"m17n:ar:kbd", "kbd (m17n)", "us", "ar"},
+{"m17n:hi:itrans", "itrans (m17n)", "us", "hi"},
+{"m17n:fa:isiri", "isiri (m17n)", "us", "fa"},
+{"xkb:br::por", "Brazil", "br", "por"},
+{"xkb:bg::bul", "Bulgaria", "bg", "bul"},
+{"xkb:bg:phonetic:bul", "Bulgaria - Traditional phonetic", "bg(phonetic)", "bul"},
+{"xkb:ca:eng:eng", "Canada - English", "ca(eng)", "eng"},
+{"xkb:cz::cze", "Czechia", "cz", "cze"},
+{"xkb:ee::est", "Estonia", "ee", "est"},
+{"xkb:es::spa", "Spain", "es", "spa"},
+{"xkb:es:cat:cat", "Spain - Catalan variant with middle-dot L", "es(cat)", "cat"},
+{"xkb:dk::dan", "Denmark", "dk", "dan"},
+{"xkb:gr::gre", "Greece", "gr", "gre"},
+{"xkb:il::heb", "Israel", "il", "heb"},
+{"xkb:kr:kr104:kor", "Korea, Republic of - 101/104 key Compatible", "kr(kr104)", "kor"},
+{"xkb:latam::spa", "Latin American", "latam", "spa"},
+{"xkb:lt::lit", "Lithuania", "lt", "lit"},
+{"xkb:lv:apostrophe:lav", "Latvia - Apostrophe (') variant", "lv(apostrophe)", "lav"},
+{"xkb:hr::scr", "Croatia", "hr", "scr"},
+{"xkb:gb:extd:eng", "United Kingdom - Extended - Winkeys", "gb(extd)", "eng"},
+{"xkb:gb:dvorak:eng", "United Kingdom - Dvorak", "gb(dvorak)", "eng"},
+{"xkb:fi::fin", "Finland", "fi", "fin"},
+{"xkb:hu::hun", "Hungary", "hu", "hun"},
+{"xkb:it::ita", "Italy", "it", "ita"},
+{"xkb:no::nob", "Norway", "no", "nob"},
+{"xkb:pl::pol", "Poland", "pl", "pol"},
+{"xkb:pt::por", "Portugal", "pt", "por"},
+{"xkb:ro::rum", "Romania", "ro", "rum"},
+{"xkb:se::swe", "Sweden", "se", "swe"},
+{"xkb:sk::slo", "Slovakia", "sk", "slo"},
+{"xkb:si::slv", "Slovenia", "si", "slv"},
+{"xkb:rs::srp", "Serbia", "rs", "srp"},
+{"xkb:tr::tur", "Turkey", "tr", "tur"},
+{"xkb:ua::ukr", "Ukraine", "ua", "ukr"},
+
+};
+
+}  // namespace input_method
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_IBUS_INPUT_METHODS_H_
diff --git a/chrome/browser/chromeos/input_method/input_method_util.cc b/chrome/browser/chromeos/input_method/input_method_util.cc
index 9054905..f973ddc 100644
--- a/chrome/browser/chromeos/input_method/input_method_util.cc
+++ b/chrome/browser/chromeos/input_method/input_method_util.cc
@@ -20,6 +20,7 @@
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/input_method/keyboard_overlay_map.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
@@ -27,11 +28,6 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_collator.h"
 
-#if defined(HAVE_IBUS)
-// TODO(satorux): Move these to Chrome tree.
-#include <cros/chromeos_keyboard_overlay_map.h>
-#endif
-
 namespace chromeos {
 namespace input_method {
 
@@ -500,13 +496,11 @@ std::string GetKeyboardLayoutName(const std::string& input_method_id) {
 }
 
 std::string GetKeyboardOverlayId(const std::string& input_method_id) {
-#if defined(HAVE_IBUS)
   for (size_t i = 0; i < arraysize(kKeyboardOverlayMap); ++i) {
     if (kKeyboardOverlayMap[i].input_method_id == input_method_id) {
       return kKeyboardOverlayMap[i].keyboard_overlay_id;
     }
   }
-#endif  // defined(HAVE_IBUS)
   return "";
 }
 
diff --git a/chrome/browser/chromeos/input_method/keyboard_overlay_map.h b/chrome/browser/chromeos/input_method/keyboard_overlay_map.h
new file mode 100644
index 0000000..a590db7
--- /dev/null
+++ b/chrome/browser/chromeos/input_method/keyboard_overlay_map.h
@@ -0,0 +1,93 @@
+// Copyright (c) 2011 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.
+//
+// This file is automatically generated by gen_keyboard_overlay_map.py in
+// libcros.
+// TODO(satorux): Move the generation process to Chrome. crosbug.com/16630.
+
+#ifndef CHROME_BROWSER_CHROMEOS_INPUT_METHOD_KEYBOARD_OVERLAY_MAP_H_
+#define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_KEYBOARD_OVERLAY_MAP_H_
+#pragma once
+
+namespace chromeos {
+namespace input_method {
+
+const struct KeyboardOverlayMap {
+  std::string input_method_id;
+  std::string keyboard_overlay_id;
+} kKeyboardOverlayMap[] = {
+  { "xkb:nl::nld", "nl" },
+  { "xkb:be::nld", "nl" },
+  { "xkb:fr::fra", "fr" },
+  { "xkb:be::fra", "fr" },
+  { "xkb:ca::fra", "fr_CA" },
+  { "xkb:ch:fr:fra", "fr" },
+  { "xkb:de::ger", "de" },
+  { "xkb:de:neo:ger", "de_neo" },
+  { "xkb:be::ger", "de" },
+  { "xkb:ch::ger", "de" },
+  { "mozc", "en_US" },
+  { "mozc-jp", "ja" },
+  { "mozc-dv", "en_US_dvorak" },
+  { "xkb:jp::jpn", "ja" },
+  { "xkb:ru::rus", "ru" },
+  { "xkb:ru:phonetic:rus", "ru" },
+  { "m17n:th:kesmanee", "th" },
+  { "m17n:th:pattachote", "th" },
+  { "m17n:th:tis820", "th" },
+  { "pinyin", "zh_CN" },
+  { "pinyin-dv", "en_US_dvorak" },
+  { "mozc-chewing", "zh_TW" },
+  { "m17n:zh:cangjie", "zh_TW" },
+  { "m17n:zh:quick", "zh_TW" },
+  { "m17n:vi:tcvn", "vi" },
+  { "m17n:vi:telex", "vi" },
+  { "m17n:vi:viqr", "vi" },
+  { "m17n:vi:vni", "vi" },
+  { "xkb:us::eng", "en_US" },
+  { "xkb:us:intl:eng", "en_US_intl" },
+  { "xkb:us:altgr-intl:eng", "en_US_altgr_intl" },
+  { "xkb:us:dvorak:eng", "en_US_dvorak" },
+  { "xkb:us:colemak:eng", "en_US_colemak" },
+  { "hangul", "ko" },
+  { "m17n:ar:kbd", "ar" },
+  { "m17n:hi:itrans", "hi" },
+  { "m17n:fa:isiri", "ar" },
+  { "xkb:br::por", "pt_BR" },
+  { "xkb:bg::bul", "bg" },
+  { "xkb:bg:phonetic:bul", "bg" },
+  { "xkb:ca:eng:eng", "ca" },
+  { "xkb:cz::cze", "cs" },
+  { "xkb:ee::est", "et" },
+  { "xkb:es::spa", "es" },
+  { "xkb:es:cat:cat", "ca" },
+  { "xkb:dk::dan", "da" },
+  { "xkb:gr::gre", "el" },
+  { "xkb:il::heb", "iw" },
+  { "xkb:kr:kr104:kor", "ko" },
+  { "xkb:latam::spa", "es_419" },
+  { "xkb:lt::lit", "lt" },
+  { "xkb:lv:apostrophe:lav", "lv" },
+  { "xkb:hr::scr", "hr" },
+  { "xkb:gb:extd:eng", "en_GB" },
+  { "xkb:gb:dvorak:eng", "en_GB_dvorak" },
+  { "xkb:fi::fin", "fi" },
+  { "xkb:hu::hun", "hu" },
+  { "xkb:it::ita", "it" },
+  { "xkb:no::nob", "no" },
+  { "xkb:pl::pol", "pl" },
+  { "xkb:pt::por", "pt_PT" },
+  { "xkb:ro::rum", "ro" },
+  { "xkb:se::swe", "sv" },
+  { "xkb:sk::slo", "sk" },
+  { "xkb:si::slv", "sl" },
+  { "xkb:rs::srp", "sr" },
+  { "xkb:tr::tur", "tr" },
+  { "xkb:ua::ukr", "uk" },
+};
+
+}  // namespace input_method
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_KEYBOARD_OVERLAY_MAP_H_