Fix memory leaks caused by chrome/browser/chromeos/input_method/*.cc (part 3)

- Removed the IdMaps singleton class from input_method_util.cc to remove Valgrind warnings (see the issue 48130).
- Put all free functions in input_method_util.cc in a newly created class InputMethodUtil. Moved all std::sets and std::maps in IdMaps to the new class.
- Add an instance of InputMethodUtil to InputMethodManagerImpl.
- Removed wide string and UTF-8 string versions of GetString function from input_method_util.h since using wstring is now highly discouraged and the UTF-8 version is unused.
- Replaced all IME related std::wstrings with string16.

BUG=chromium:48130
TEST=ran unit_tests under valgrind (without suppressions) and confirmed that no leaks were reported. 


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

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

1 files changed, 93 insertions, 80 deletions

diff --git a/chrome/browser/chromeos/input_method/input_method_util_unittest.cc b/chrome/browser/chromeos/input_method/input_method_util_unittest.cc
index c475b64..292abef 100644
--- a/chrome/browser/chromeos/input_method/input_method_util_unittest.cc
+++ b/chrome/browser/chromeos/input_method/input_method_util_unittest.cc
@@ -41,113 +41,124 @@ InputMethodDescriptor GetDesc(IBusController* controller,
   return controller->CreateInputMethodDescriptor(id, raw_layout, language_code);
 }
 
+class TestableInputMethodUtil : public InputMethodUtil {
+ public:
+  // Change access rights.
+  using InputMethodUtil::StringIsSupported;
+  using InputMethodUtil::GetInputMethodIdsFromLanguageCodeInternal;
+  using InputMethodUtil::ReloadInternalMaps;
+  using InputMethodUtil::SortLanguageCodesByNames;
+};
+
 }  // namespace
 
 class InputMethodUtilTest : public testing::Test {
  public:
   static void SetUpTestCase() {
-    ReloadInternalMaps();
   }
+  TestableInputMethodUtil util_;
 };
 
 TEST_F(InputMethodUtilTest, TestGetStringUTF8) {
-  EXPECT_EQ("Pinyin input method", GetStringUTF8("pinyin"));
+  EXPECT_EQ(UTF8ToUTF16("Pinyin input method"),
+            util_.TranslateString("pinyin"));
 #if !defined(GOOGLE_CHROME_BUILD)
-  EXPECT_EQ("Japanese input method (for US Dvorak keyboard)",
-            GetStringUTF8("mozc-dv"));
+  EXPECT_EQ(UTF8ToUTF16("Japanese input method (for US Dvorak keyboard)"),
+            util_.TranslateString("mozc-dv"));
 #endif
 }
 
 TEST_F(InputMethodUtilTest, TestStringIsSupported) {
-  EXPECT_TRUE(StringIsSupported("Hiragana"));
-  EXPECT_TRUE(StringIsSupported("Latin"));
-  EXPECT_TRUE(StringIsSupported("Direct input"));
-  EXPECT_FALSE(StringIsSupported("####THIS_STRING_IS_NOT_SUPPORTED####"));
-  EXPECT_TRUE(StringIsSupported("Chinese"));
-  EXPECT_TRUE(StringIsSupported("_Chinese"));
+  EXPECT_TRUE(util_.StringIsSupported("Hiragana"));
+  EXPECT_TRUE(util_.StringIsSupported("Latin"));
+  EXPECT_TRUE(util_.StringIsSupported("Direct input"));
+  EXPECT_FALSE(util_.StringIsSupported("####THIS_STRING_IS_NOT_SUPPORTED####"));
+  EXPECT_TRUE(util_.StringIsSupported("Chinese"));
+  EXPECT_TRUE(util_.StringIsSupported("_Chinese"));
 }
 
 TEST_F(InputMethodUtilTest, TestNormalizeLanguageCode) {
   // TODO(yusukes): test all language codes that IBus provides.
-  EXPECT_EQ("ja", NormalizeLanguageCode("ja"));
-  EXPECT_EQ("ja", NormalizeLanguageCode("jpn"));
+  EXPECT_EQ("ja", util_.NormalizeLanguageCode("ja"));
+  EXPECT_EQ("ja", util_.NormalizeLanguageCode("jpn"));
   // In the past "t" had a meaning of "other language" for some m17n latin
   // input methods for testing purpose, but it is no longer used. We test "t"
   // here as just an "unknown" language.
-  EXPECT_EQ("t", NormalizeLanguageCode("t"));
-  EXPECT_EQ("zh-CN", NormalizeLanguageCode("zh-CN"));
-  EXPECT_EQ("zh-CN", NormalizeLanguageCode("zh_CN"));
-  EXPECT_EQ("en-US", NormalizeLanguageCode("EN_us"));
-  // See app/l10n_util.cc for es-419.
-  EXPECT_EQ("es-419", NormalizeLanguageCode("es_419"));
+  EXPECT_EQ("t", util_.NormalizeLanguageCode("t"));
+  EXPECT_EQ("zh-CN", util_.NormalizeLanguageCode("zh-CN"));
+  EXPECT_EQ("zh-CN", util_.NormalizeLanguageCode("zh_CN"));
+  EXPECT_EQ("en-US", util_.NormalizeLanguageCode("EN_us"));
+  // See l10n_util.cc for es-419.
+  EXPECT_EQ("es-419", util_.NormalizeLanguageCode("es_419"));
 
   // Special three-letter language codes.
-  EXPECT_EQ("cs", NormalizeLanguageCode("cze"));
-  EXPECT_EQ("de", NormalizeLanguageCode("ger"));
-  EXPECT_EQ("el", NormalizeLanguageCode("gre"));
-  EXPECT_EQ("hr", NormalizeLanguageCode("scr"));
-  EXPECT_EQ("ro", NormalizeLanguageCode("rum"));
-  EXPECT_EQ("sk", NormalizeLanguageCode("slo"));
+  EXPECT_EQ("cs", util_.NormalizeLanguageCode("cze"));
+  EXPECT_EQ("de", util_.NormalizeLanguageCode("ger"));
+  EXPECT_EQ("el", util_.NormalizeLanguageCode("gre"));
+  EXPECT_EQ("hr", util_.NormalizeLanguageCode("scr"));
+  EXPECT_EQ("ro", util_.NormalizeLanguageCode("rum"));
+  EXPECT_EQ("sk", util_.NormalizeLanguageCode("slo"));
 }
 
 TEST_F(InputMethodUtilTest, TestIsKeyboardLayout) {
-  EXPECT_TRUE(IsKeyboardLayout("xkb:us::eng"));
-  EXPECT_FALSE(IsKeyboardLayout("mozc"));
+  EXPECT_TRUE(InputMethodUtil::IsKeyboardLayout("xkb:us::eng"));
+  EXPECT_FALSE(InputMethodUtil::IsKeyboardLayout("mozc"));
 }
 
 TEST_F(InputMethodUtilTest, TestGetLanguageCodeFromDescriptor) {
   scoped_ptr<IBusController> controller(IBusController::Create());
-  EXPECT_EQ("ja", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("ja", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "mozc", "us", "ja")));
-  EXPECT_EQ("zh-TW", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("zh-TW", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "mozc-chewing", "us", "zh")));
-  EXPECT_EQ("zh-TW", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("zh-TW", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "m17n:zh:cangjie", "us", "zh")));
-  EXPECT_EQ("zh-TW", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("zh-TW", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "m17n:zh:quick", "us", "zh")));
-  EXPECT_EQ("zh-CN", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("zh-CN", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "pinyin", "us", "zh")));
-  EXPECT_EQ("en-US", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("en-US", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "xkb:us::eng", "us", "eng")));
-  EXPECT_EQ("en-UK", GetLanguageCodeFromDescriptor(
+  EXPECT_EQ("en-UK", util_.GetLanguageCodeFromDescriptor(
       GetDesc(controller.get(), "xkb:uk::eng", "us", "eng")));
 }
 
 TEST_F(InputMethodUtilTest, TestGetKeyboardLayoutName) {
   // Unsupported case.
-  EXPECT_EQ("", GetKeyboardLayoutName("UNSUPPORTED_ID"));
+  EXPECT_EQ("", util_.GetKeyboardLayoutName("UNSUPPORTED_ID"));
 
   // Supported cases (samples).
-  EXPECT_EQ("jp", GetKeyboardLayoutName("mozc-jp"));
-  EXPECT_EQ("us", GetKeyboardLayoutName("pinyin"));
-  EXPECT_EQ("us(dvorak)", GetKeyboardLayoutName("pinyin-dv"));
-  EXPECT_EQ("us", GetKeyboardLayoutName("m17n:ar:kbd"));
-  EXPECT_EQ("es", GetKeyboardLayoutName("xkb:es::spa"));
-  EXPECT_EQ("es(cat)", GetKeyboardLayoutName("xkb:es:cat:cat"));
-  EXPECT_EQ("gb(extd)", GetKeyboardLayoutName("xkb:gb:extd:eng"));
-  EXPECT_EQ("us", GetKeyboardLayoutName("xkb:us::eng"));
-  EXPECT_EQ("us(dvorak)", GetKeyboardLayoutName("xkb:us:dvorak:eng"));
-  EXPECT_EQ("us(colemak)", GetKeyboardLayoutName("xkb:us:colemak:eng"));
-  EXPECT_EQ("de(neo)", GetKeyboardLayoutName("xkb:de:neo:ger"));
+  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"));
 }
 
 TEST_F(InputMethodUtilTest, TestGetLanguageCodeFromInputMethodId) {
   // Make sure that the -CN is added properly.
-  EXPECT_EQ("zh-CN", GetLanguageCodeFromInputMethodId("pinyin"));
+  EXPECT_EQ("zh-CN", util_.GetLanguageCodeFromInputMethodId("pinyin"));
 }
 
 TEST_F(InputMethodUtilTest, TestGetInputMethodDisplayNameFromId) {
-  EXPECT_EQ("Pinyin input method", GetInputMethodDisplayNameFromId("pinyin"));
+  EXPECT_EQ("Pinyin input method",
+            util_.GetInputMethodDisplayNameFromId("pinyin"));
   EXPECT_EQ("US keyboard",
-            GetInputMethodDisplayNameFromId("xkb:us::eng"));
-  EXPECT_EQ("", GetInputMethodDisplayNameFromId("nonexistent"));
+            util_.GetInputMethodDisplayNameFromId("xkb:us::eng"));
+  EXPECT_EQ("", util_.GetInputMethodDisplayNameFromId("nonexistent"));
 }
 
 TEST_F(InputMethodUtilTest, TestGetInputMethodDescriptorFromId) {
-  EXPECT_EQ(NULL, GetInputMethodDescriptorFromId("non_existent"));
+  EXPECT_EQ(NULL, util_.GetInputMethodDescriptorFromId("non_existent"));
 
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("pinyin");
+      util_.GetInputMethodDescriptorFromId("pinyin");
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   EXPECT_EQ("pinyin", descriptor->id());
   EXPECT_EQ("us", descriptor->keyboard_layout());
@@ -157,10 +168,10 @@ TEST_F(InputMethodUtilTest, TestGetInputMethodDescriptorFromId) {
 }
 
 TEST_F(InputMethodUtilTest, TestGetInputMethodDescriptorFromXkbId) {
-  EXPECT_EQ(NULL, GetInputMethodDescriptorFromXkbId("non_existent"));
+  EXPECT_EQ(NULL, util_.GetInputMethodDescriptorFromXkbId("non_existent"));
 
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromXkbId("us(dvorak)");
+      util_.GetInputMethodDescriptorFromXkbId("us(dvorak)");
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   EXPECT_EQ("xkb:us:dvorak:eng", descriptor->id());
   EXPECT_EQ("us(dvorak)", descriptor->keyboard_layout());
@@ -168,19 +179,20 @@ TEST_F(InputMethodUtilTest, TestGetInputMethodDescriptorFromXkbId) {
 }
 
 TEST_F(InputMethodUtilTest, TestGetLanguageNativeDisplayNameFromCode) {
-  EXPECT_EQ(UTF8ToUTF16("suomi"), GetLanguageNativeDisplayNameFromCode("fi"));
+  EXPECT_EQ(UTF8ToUTF16("suomi"),
+            InputMethodUtil::GetLanguageNativeDisplayNameFromCode("fi"));
 }
 
 TEST_F(InputMethodUtilTest, TestSortLanguageCodesByNames) {
   std::vector<std::string> language_codes;
   // Check if this function can handle an empty list.
-  SortLanguageCodesByNames(&language_codes);
+  TestableInputMethodUtil::SortLanguageCodesByNames(&language_codes);
 
   language_codes.push_back("ja");
   language_codes.push_back("fr");
   // For "t", see the comment in NormalizeLanguageCode test.
   language_codes.push_back("t");
-  SortLanguageCodesByNames(&language_codes);
+  TestableInputMethodUtil::SortLanguageCodesByNames(&language_codes);
   ASSERT_EQ(3U, language_codes.size());
   ASSERT_EQ("fr", language_codes[0]);  // French
   ASSERT_EQ("ja", language_codes[1]);  // Japanese
@@ -188,7 +200,7 @@ TEST_F(InputMethodUtilTest, TestSortLanguageCodesByNames) {
 
   // Add a duplicate entry and see if it works.
   language_codes.push_back("ja");
-  SortLanguageCodesByNames(&language_codes);
+  TestableInputMethodUtil::SortLanguageCodesByNames(&language_codes);
   ASSERT_EQ(4U, language_codes.size());
   ASSERT_EQ("fr", language_codes[0]);  // French
   ASSERT_EQ("ja", language_codes[1]);  // Japanese
@@ -204,36 +216,36 @@ TEST_F(InputMethodUtilTest, TestGetInputMethodIdsForLanguageCode) {
   language_code_to_ids_map.insert(std::make_pair("fr", "xkb:fr:fra"));
 
   std::vector<std::string> result;
-  EXPECT_TRUE(GetInputMethodIdsFromLanguageCodeInternal(
+  EXPECT_TRUE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "ja", kAllInputMethods, &result));
   EXPECT_EQ(3U, result.size());
-  EXPECT_TRUE(GetInputMethodIdsFromLanguageCodeInternal(
+  EXPECT_TRUE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "ja", kKeyboardLayoutsOnly, &result));
   ASSERT_EQ(1U, result.size());
   EXPECT_EQ("xkb:jp:jpn", result[0]);
 
-  EXPECT_TRUE(GetInputMethodIdsFromLanguageCodeInternal(
+  EXPECT_TRUE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "fr", kAllInputMethods, &result));
   ASSERT_EQ(1U, result.size());
   EXPECT_EQ("xkb:fr:fra", result[0]);
-  EXPECT_TRUE(GetInputMethodIdsFromLanguageCodeInternal(
+  EXPECT_TRUE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "fr", kKeyboardLayoutsOnly, &result));
   ASSERT_EQ(1U, result.size());
   EXPECT_EQ("xkb:fr:fra", result[0]);
 
-  EXPECT_FALSE(GetInputMethodIdsFromLanguageCodeInternal(
+  EXPECT_FALSE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "invalid_lang", kAllInputMethods, &result));
-  EXPECT_FALSE(GetInputMethodIdsFromLanguageCodeInternal(
+  EXPECT_FALSE(util_.GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_map, "invalid_lang", kKeyboardLayoutsOnly, &result));
 }
 
 // US keyboard + English US UI = US keyboard only.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_EnUs) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("en-US", *descriptor, &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]);
 }
@@ -241,10 +253,10 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_EnUs) {
 // US keyboard + Japanese UI = US keyboard + mozc.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Ja) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("ja", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("ja", *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.
@@ -253,10 +265,10 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Ja) {
 // JP keyboard + Japanese UI = JP keyboard + mozc-jp.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_JP_And_Ja) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:jp::jpn");  // Japanese keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:jp::jpn");  // Japanese keyboard
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("ja", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("ja", *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.
@@ -265,10 +277,11 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_JP_And_Ja) {
 // US dvorak keyboard + Japanese UI = US dvorak keyboard + mozc-dv.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Dvorak_And_Ja) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us:dvorak:eng");  // US Drovak keyboard.
+      // 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;
-  GetFirstLoginInputMethodIds("ja", *descriptor, &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.
@@ -277,10 +290,10 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Dvorak_And_Ja) {
 // US keyboard + Russian UI = US keyboard + Russsian keyboard
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Ru) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("ru", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("ru", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
   EXPECT_EQ("xkb:ru::rus", input_method_ids[1]);  // Russian keyboard.
@@ -289,10 +302,10 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Ru) {
 // US keyboard + Traditional Chinese = US keyboard + chewing.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_ZhTw) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("zh-TW", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("zh-TW", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
   EXPECT_EQ("mozc-chewing", input_method_ids[1]);  // Chewing.
@@ -301,10 +314,10 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_ZhTw) {
 // US keyboard + Thai = US keyboard + kesmanee.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Th) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("th", *descriptor, &input_method_ids);
+  util_.GetFirstLoginInputMethodIds("th", *descriptor, &input_method_ids);
   ASSERT_EQ(2U, input_method_ids.size());
   EXPECT_EQ("xkb:us::eng", input_method_ids[0]);
   EXPECT_EQ("m17n:th:kesmanee", input_method_ids[1]);  // Kesmanee.
@@ -313,10 +326,10 @@ TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Th) {
 // US keyboard + Vietnamese = US keyboard + TCVN6064.
 TEST_F(InputMethodUtilTest, TestGetFirstLoginInputMethodIds_Us_And_Vi) {
   const InputMethodDescriptor* descriptor =
-      GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
+      util_.GetInputMethodDescriptorFromId("xkb:us::eng");  // US keyboard.
   ASSERT_TRUE(NULL != descriptor);  // ASSERT_NE doesn't compile.
   std::vector<std::string> input_method_ids;
-  GetFirstLoginInputMethodIds("vi", *descriptor, &input_method_ids);
+  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.
@@ -329,7 +342,7 @@ TEST_F(InputMethodUtilTest, TestGetLanguageCodesFromInputMethodIds) {
   input_method_ids.push_back("mozc-jp");  // Japanese.
   input_method_ids.push_back("xkb:fr::fra");  // French France.
   std::vector<std::string> language_codes;
-  GetLanguageCodesFromInputMethodIds(input_method_ids, &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]);