Extract a delegate interface from c/b/input_method to permit decoupling from c/b.

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/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/input_method/input_method_whitelist.h"
+#include "chrome/browser/chromeos/input_method/mock_input_method_delegate.h"
 #include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 
 extern const char* kExtensionImePrefix;
 
 namespace input_method {
 
 namespace {
 
 class TestableInputMethodUtil : public InputMethodUtil {
  public:
-  explicit TestableInputMethodUtil(scoped_ptr<InputMethodDescriptors> methods)
-      : InputMethodUtil(methods.Pass()) {
+  explicit TestableInputMethodUtil(InputMethodDelegate* delegate,
+                                   scoped_ptr<InputMethodDescriptors> methods)
+      : InputMethodUtil(delegate, methods.Pass()) {
   }
   // Change access rights.
   using InputMethodUtil::StringIsSupported;
   using InputMethodUtil::GetInputMethodIdsFromLanguageCodeInternal;
   using InputMethodUtil::ReloadInternalMaps;
   using InputMethodUtil::SortLanguageCodesByNames;
   using InputMethodUtil::supported_input_methods_;
 };
 
 }  // namespace
 
 class InputMethodUtilTest : public testing::Test {
  public:
-  InputMethodUtilTest() : util_(whitelist_.GetSupportedInputMethods()) {
+  InputMethodUtilTest()
+      : util_(&delegate_, whitelist_.GetSupportedInputMethods()) {
   }
 
   InputMethodDescriptor GetDesc(const std::string& id,
                                 const std::string& raw_layout,
                                 const std::string& language_code) {
     return InputMethodDescriptor(id,
                                  "",
                                  raw_layout,
                                  language_code,
                                  false);
   }
 
+  MockInputMethodDelegate delegate_;
   InputMethodWhitelist whitelist_;
   TestableInputMethodUtil util_;
 };
 
 TEST_F(InputMethodUtilTest, GetInputMethodShortNameTest) {
   // Test normal cases. Two-letter language code should be returned.
   {
     InputMethodDescriptor desc = GetDesc("m17n:fa:isiri",  // input method id
                                          "us",  // keyboard layout name
                                          "fa");  // language name
@@ skipping 301 matching lines @@
 }
 
 TEST_F(InputMethodUtilTest, TestGetLanguageNativeDisplayNameFromCode) {
   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.
-  TestableInputMethodUtil::SortLanguageCodesByNames(&language_codes);
+  util_.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");
-  TestableInputMethodUtil::SortLanguageCodesByNames(&language_codes);
+  util_.SortLanguageCodesByNames(&language_codes);
   ASSERT_EQ(3U, language_codes.size());
   ASSERT_EQ("fr", language_codes[0]);  // French
   ASSERT_EQ("ja", language_codes[1]);  // Japanese
   ASSERT_EQ("t",  language_codes[2]);  // Others
 
   // Add a duplicate entry and see if it works.
   language_codes.push_back("ja");
-  TestableInputMethodUtil::SortLanguageCodesByNames(&language_codes);
+  util_.SortLanguageCodesByNames(&language_codes);
   ASSERT_EQ(4U, language_codes.size());
   ASSERT_EQ("fr", language_codes[0]);  // French
   ASSERT_EQ("ja", language_codes[1]);  // Japanese
   ASSERT_EQ("ja", language_codes[2]);  // Japanese
   ASSERT_EQ("t",  language_codes[3]);  // Others
 }
 
 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"));
@@ skipping 128 matching lines @@
   input_method_ids.push_back("mozc-jp");  // Japanese.
   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("fr", language_codes[2]);
 }
 
-TEST_F(InputMethodUtilTest, TestSetHardwareInputMethodId) {
-  util_.SetHardwareInputMethodIdForTesting("xkb:fr::fra");
-  EXPECT_EQ("xkb:fr::fra", util_.GetHardwareInputMethodId());
-  // Reset to the default behavior just in case.
-  util_.SetHardwareInputMethodIdForTesting("");
-}
-
 // 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