Rename InputMethodManager::current_input_method() to InputMethodManager::GetCurrentInputMethod().

chrome/browser/chromeos/status/input_method_menu.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/status/input_method_menu.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_split.h"
@@ skipping 192 matching lines @@
 }
 
 bool InputMethodMenu::IsItemCheckedAt(int index) const {
   DCHECK_GE(index, 0);
   DCHECK(input_method_descriptors_.get());
 
   if (IndexIsInInputMethodList(index)) {
     const input_method::InputMethodDescriptor& input_method
         = input_method_descriptors_->at(index);
     return input_method == InputMethodManager::GetInstance()->
-          current_input_method();
+          GetCurrentInputMethod();
   }
 
   if (GetPropertyIndex(index, &index)) {
-    const input_method::ImePropertyList& property_list
-        = InputMethodManager::GetInstance()->current_ime_properties();
+    const input_method::InputMethodPropertyList& property_list
+        = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     return property_list.at(index).is_selection_item_checked;
   }
 
   // Separator(s) or the "Customize language and input..." button.
   return false;
 }
 
 int InputMethodMenu::GetGroupIdAt(int index) const {
   DCHECK_GE(index, 0);
 
   if (IndexIsInInputMethodList(index)) {
     return for_out_of_box_experience_dialog_ ?
         kRadioGroupNone : kRadioGroupLanguage;
   }
 
   if (GetPropertyIndex(index, &index)) {
-    const input_method::ImePropertyList& property_list
-        = InputMethodManager::GetInstance()->current_ime_properties();
+    const input_method::InputMethodPropertyList& property_list
+        = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     return property_list.at(index).selection_item_id;
   }
 
   return kRadioGroupNone;
 }
 
 bool InputMethodMenu::HasIcons() const  {
   // We don't support icons on Chrome OS.
   return false;
 }
@@ skipping 45 matching lines @@
   if (IndexPointsToConfigureImeMenuItem(index)) {
     return ui::MenuModel::TYPE_COMMAND;  // "Customize language and input"
   }
 
   if (IndexIsInInputMethodList(index)) {
     return for_out_of_box_experience_dialog_ ?
         ui::MenuModel::TYPE_COMMAND : ui::MenuModel::TYPE_RADIO;
   }
 
   if (GetPropertyIndex(index, &index)) {
-    const input_method::ImePropertyList& property_list
-        = InputMethodManager::GetInstance()->current_ime_properties();
+    const input_method::InputMethodPropertyList& property_list
+        = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     if (property_list.at(index).is_selection_item) {
       return ui::MenuModel::TYPE_RADIO;
     }
     return ui::MenuModel::TYPE_COMMAND;
   }
 
   return ui::MenuModel::TYPE_SEPARATOR;
 }
 
 string16 InputMethodMenu::GetLabelAt(int index) const {
   DCHECK_GE(index, 0);
   DCHECK(input_method_descriptors_.get());
 
   // We use IDS_OPTIONS_SETTINGS_LANGUAGES_CUSTOMIZE here as the button
   // opens the same dialog that is opened from the main options dialog.
   if (IndexPointsToConfigureImeMenuItem(index)) {
     return l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_LANGUAGES_CUSTOMIZE);
   }
 
   string16 name;
   if (IndexIsInInputMethodList(index)) {
     name = GetTextForMenu(input_method_descriptors_->at(index));
   } else if (GetPropertyIndex(index, &index)) {
     InputMethodManager* manager = InputMethodManager::GetInstance();
-    const input_method::ImePropertyList& property_list =
-        manager->current_ime_properties();
+    const input_method::InputMethodPropertyList& property_list =
+        manager->GetCurrentInputMethodProperties();
     return manager->GetInputMethodUtil()->TranslateString(
         property_list.at(index).label);
   }
 
   return name;
 }
 
 void InputMethodMenu::ActivatedAt(int index) {
   DCHECK_GE(index, 0);
   DCHECK(input_method_descriptors_.get());
 
   if (IndexPointsToConfigureImeMenuItem(index)) {
     OpenConfigUI();
     return;
   }
 
   if (IndexIsInInputMethodList(index)) {
     // Inter-IME switching.
     const input_method::InputMethodDescriptor& input_method
         = input_method_descriptors_->at(index);
     InputMethodManager::GetInstance()->ChangeInputMethod(
         input_method.id());
     content::RecordAction(
         UserMetricsAction("LanguageMenuButton_InputMethodChanged"));
     return;
   }
 
   if (GetPropertyIndex(index, &index)) {
     // Intra-IME switching (e.g. Japanese-Hiragana to Japanese-Katakana).
-    const input_method::ImePropertyList& property_list
-        = InputMethodManager::GetInstance()->current_ime_properties();
+    const input_method::InputMethodPropertyList& property_list
+        = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     const std::string key = property_list.at(index).key;
     if (property_list.at(index).is_selection_item) {
       // Radio button is clicked.
       const int id = property_list.at(index).selection_item_id;
       // First, deactivate all other properties in the same radio group.
       for (int i = 0; i < static_cast<int>(property_list.size()); ++i) {
         if (i != index && id == property_list.at(i).selection_item_id) {
           InputMethodManager::GetInstance()->SetImePropertyActivated(
               property_list.at(i).key, false);
         }
@@ skipping 59 matching lines @@
   } else if (StatusAreaViewChromeos::IsLoginMode()) {
     if (g_browser_process && g_browser_process->local_state()) {
       g_browser_process->local_state()->SetString(
           language_prefs::kPreferredKeyboardLayout, current_input_method.id());
     }
   }
 }
 
 void InputMethodMenu::PropertyListChanged(
     InputMethodManager* manager,
-    const input_method::ImePropertyList& current_ime_properties) {
+    const input_method::InputMethodPropertyList& current_ime_properties) {
   // Usual order of notifications of input method change is:
   // 1. RegisterProperties(empty)
   // 2. RegisterProperties(list-of-new-properties)
   // 3. GlobalInputMethodChanged
   // However, due to the asynchronicity, we occasionally (but rarely) face to
   // 1. RegisterProperties(empty)
   // 2. GlobalInputMethodChanged
   // 3. RegisterProperties(list-of-new-properties)
   // this order. On this unusual case, we must rebuild the menu after the last
   // RegisterProperties. For the other cases, no rebuild is needed. Actually
   // it is better to be avoided. Otherwise users can sometimes observe the
   // awkward clear-then-register behavior.
   if (!current_ime_properties.empty()) {
     const input_method::InputMethodDescriptor& input_method =
-        manager->current_input_method();
+        manager->GetCurrentInputMethod();
     size_t num_active_input_methods = manager->GetNumActiveInputMethods();
     UpdateUIFromInputMethod(input_method, num_active_input_methods);
   }
 }
 
 void InputMethodMenu::FirstObserverIsAdded(InputMethodManager* manager) {
   // NOTICE: Since this function might be called from the constructor of this
   // class, it's better to avoid calling virtual functions.
 
   if (pref_service_ && (StatusAreaViewChromeos::IsBrowserMode())) {
@@ skipping 53 matching lines @@
     // We "abuse" the command_id and group_id arguments of AddRadioItem method.
     // A COMMAND_ID_XXX enum value is passed as command_id, and array index of
     // |input_method_descriptors_| or |property_list| is passed as group_id.
     for (size_t i = 0; i < input_method_descriptors_->size(); ++i) {
       model_->AddRadioItem(COMMAND_ID_INPUT_METHODS, dummy_label, i);
     }
 
     need_separator = true;
   }
 
-  const input_method::ImePropertyList& property_list
-      = InputMethodManager::GetInstance()->current_ime_properties();
+  const input_method::InputMethodPropertyList& property_list
+      = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
   if (!property_list.empty()) {
     if (need_separator) {
       model_->AddSeparator();
     }
     for (size_t i = 0; i < property_list.size(); ++i) {
       model_->AddRadioItem(COMMAND_ID_IME_PROPERTIES, dummy_label, i);
     }
     need_separator = true;
   }
 
@@ skipping 28 matching lines @@
   DCHECK_GE(index, 0);
   DCHECK(property_index);
   DCHECK(model_.get());
   if (index >= model_->GetItemCount()) {
     return false;
   }
 
   if ((model_->GetTypeAt(index) == ui::MenuModel::TYPE_RADIO) &&
       (model_->GetCommandIdAt(index) == COMMAND_ID_IME_PROPERTIES)) {
     const int tmp_property_index = model_->GetGroupIdAt(index);
-    const input_method::ImePropertyList& property_list
-        = InputMethodManager::GetInstance()->current_ime_properties();
+    const input_method::InputMethodPropertyList& property_list
+        = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     if (tmp_property_index < static_cast<int>(property_list.size())) {
       *property_index = tmp_property_index;
       return true;
     }
   }
   return false;
 }
 
 bool InputMethodMenu::IndexPointsToConfigureImeMenuItem(int index) const {
   DCHECK_GE(index, 0);
@@ skipping 101 matching lines @@
     // When a user logs in, we should remove |this| object from the observer
     // list so that PreferenceUpdateNeeded() does not update the local state
     // anymore.
     RemoveObservers();
   }
 #if defined(USE_AURA)
   if (type == chrome::NOTIFICATION_SESSION_STARTED) {
     InitializePrefMembers();
     AddObservers();
     InputMethodManager* manager = InputMethodManager::GetInstance();
-    UpdateUIFromInputMethod(manager->current_input_method(),
+    UpdateUIFromInputMethod(manager->GetCurrentInputMethod(),
                             manager->GetNumActiveInputMethods());
   }
 #endif
 }
 
 void InputMethodMenu::SetMinimumWidth(int width) {
   // On the OOBE network selection screen, fixed width menu would be preferable.
   minimum_input_method_menu_width_ = width;
 }
 
@@ skipping 31 matching lines @@
   if (!initialized_prefs_) {
     initialized_prefs_ = true;
     previous_input_method_pref_.Init(
         prefs::kLanguagePreviousInputMethod, pref_service_, this);
     current_input_method_pref_.Init(
         prefs::kLanguageCurrentInputMethod, pref_service_, this);
   }
 }
 
 }  // namespace chromeos