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

chrome/browser/chromeos/input_method/input_method_util.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_UTIL_H_
 #define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_UTIL_H_
 
 #include <cstddef>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/string16.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/input_method/input_method_descriptor.h"
 
 namespace chromeos {
 namespace input_method {
 
+class InputMethodDelegate;
+
 // The list of language that do not have associated input methods in IBus.
 // For these languages, we associate input methods here.
 struct ExtraLanguage {
   const char* language_code;
   const char* input_method_id;
 };
 extern const ExtraLanguage kExtraLanguages[];
 extern const size_t kExtraLanguagesLength;
 
 enum InputMethodType {
   kKeyboardLayoutsOnly,
   kAllInputMethods,
 };
 
 // A class which provides miscellaneous input method utility functions.
 class InputMethodUtil {
  public:
   // |supported_input_methods| is a list of all input methods supported,
   // including ones not active. The list is used to initialize member variables
   // in this class.
-  explicit InputMethodUtil(
-      scoped_ptr<InputMethodDescriptors> supported_input_methods);
+  InputMethodUtil(InputMethodDelegate* delegate,
+                  scoped_ptr<InputMethodDescriptors> supported_input_methods);
   ~InputMethodUtil();
 
   // Converts a string sent from IBus IME engines, which is written in English,
   // into Chrome's string ID, then pulls internationalized resource string from
   // the resource bundle and returns it. These functions are not thread-safe.
   // Non-UI threads are not allowed to call them.
   string16 TranslateString(const std::string& english_string) const;
 
   // Gets the keyboard layout name from the given input method ID.
   // If the ID is invalid, an empty string will be returned.
@@ skipping 69 matching lines @@
       std::vector<std::string>* out_language_codes) const;
 
   // Returns the input method ID of the hardware keyboard. e.g. "xkb:us::eng"
   // for the US Qwerty keyboard.
   std::string GetHardwareInputMethodId() const;
 
   // This function should be called when Chrome's application locale is
   // changed, so that the internal maps of this library is reloaded.
   void OnLocaleChanged();
 
-  // Sets an input method ID of the hardware keyboard for testing.
-  void SetHardwareInputMethodIdForTesting(const std::string& input_method_id);
-
   // Returns true if the given input method id is supported.
   bool IsValidInputMethodId(const std::string& input_method_id) const;
 
   // Returns true if the given input method id is for a keyboard layout.
   static bool IsKeyboardLayout(const std::string& input_method_id);
 
   // Returns true if the given input method id is for an extension input method.
   static bool IsExtensionInputMethod(const std::string& input_method_id);
 
   // Converts a language code to a language display name, using the
   // current application locale. MaybeRewriteLanguageName() is called
   // internally.
   // Examples: "fi"    => "Finnish"
   //           "en-US" => "English (United States)"
-  static string16 GetLanguageDisplayNameFromCode(
+  string16 GetLanguageDisplayNameFromCode(
       const std::string& language_code);
 
   // Converts a language code to a language native display name.
   // MaybeRewriteLanguageName() is called internally.
   // Examples: "fi"    => "suomi" (rather than Finnish)
   //           "en-US" => "English (United States)"
   static string16 GetLanguageNativeDisplayNameFromCode(
       const std::string& language_code);
 
  protected:
   // This method is ONLY for unit testing. Returns true if the given string is
   // supported (i.e. the string is associated with a resource ID). protected:
   // for testability.
   bool StringIsSupported(const std::string& english_string) const;
 
   // protected: for unit testing as well.
   bool GetInputMethodIdsFromLanguageCodeInternal(
       const std::multimap<std::string, std::string>& language_code_to_ids,
       const std::string& normalized_language_code,
       InputMethodType type,
       std::vector<std::string>* out_input_method_ids) const;
 
   // protected: for unit testing as well.
   void ReloadInternalMaps();
 
   // Sorts the given language codes by their corresponding language names, using
   // the unicode string comparator. Uses unstable sorting. protected: for unit
   // testing as well.
-  static void SortLanguageCodesByNames(
+  void SortLanguageCodesByNames(
       std::vector<std::string>* language_codes);
 
   // All input methods that are supported, including ones not active.
   // protected: for testing.
   scoped_ptr<InputMethodDescriptors> supported_input_methods_;
 
  private:
   bool TranslateStringInternal(const std::string& english_string,
                                string16 *out_string) const;
 
   // Map from language code to associated input method IDs, etc.
   typedef std::multimap<std::string, std::string> LanguageCodeToIdsMap;
   // Map from input method ID to associated input method descriptor.
   typedef std::map<
     std::string, InputMethodDescriptor> InputMethodIdToDescriptorMap;
   // Map from XKB layout ID to associated input method descriptor.
   typedef std::map<std::string, InputMethodDescriptor> XkbIdToDescriptorMap;
 
   LanguageCodeToIdsMap language_code_to_ids_;
   std::map<std::string, std::string> id_to_language_code_;
   InputMethodIdToDescriptorMap id_to_descriptor_;
   XkbIdToDescriptorMap xkb_id_to_descriptor_;
 
   typedef base::hash_map<std::string, int> HashType;
   HashType english_to_resource_id_;
 
-  std::string hardware_input_method_id_for_testing_;
+  InputMethodDelegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(InputMethodUtil);
 };
 
 }  // namespace input_method
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_UTIL_H_