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

chrome/browser/chromeos/input_method/input_method_manager.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_manager.h"
 
 #include <algorithm>
 
 #include <glib.h>
 
@@ skipping 95 matching lines @@
   },
 };
 
 const size_t kInputMethodSpecificHotkeySettingsLen =
     arraysize(kInputMethodSpecificHotkeySettings);
 #endif
 
 // Finds a property which has |new_prop.key| from |prop_list|, and replaces the
 // property with |new_prop|. Returns true if such a property is found.
 bool FindAndUpdateProperty(
-    const chromeos::input_method::ImeProperty& new_prop,
-    chromeos::input_method::ImePropertyList* prop_list) {
+    const chromeos::input_method::InputMethodProperty& new_prop,
+    chromeos::input_method::InputMethodPropertyList* prop_list) {
   for (size_t i = 0; i < prop_list->size(); ++i) {
-    chromeos::input_method::ImeProperty& prop = prop_list->at(i);
+    chromeos::input_method::InputMethodProperty& prop = prop_list->at(i);
     if (prop.key == new_prop.key) {
       const int saved_id = prop.selection_item_id;
       // Update the list except the radio id. As written in
       // chromeos_input_method.h, |prop.selection_item_id| is dummy.
       prop = new_prop;
       prop.selection_item_id = saved_id;
       return true;
     }
   }
   return false;
@@ skipping 178 matching lines @@
     if (InputMethodUtil::IsKeyboardLayout(input_method_id)
 #if !defined(USE_AURA)
         // TODO(yusukes): Remove this code when R18 stable is shipped.
         // crosbug.com/26245
         && ibus_daemon_process_handle_ == base::kNullProcessHandle
 #endif
     ) {
       // We shouldn't use SetCurrentKeyboardLayoutByName() here. See
       // comments at ChangeCurrentInputMethod() for details.
       ChangeCurrentInputMethodFromId(input_method_id);
-      OnRegisterImeProperties(ImePropertyList());  // notify the button.
+      OnRegisterImeProperties(InputMethodPropertyList());  // notify the button.
     } else {
       // Otherwise, start the input method daemon, and change the input
       // method via the daemon.
       StartInputMethodDaemon();
       // ChangeInputMethodViaIBus() fails if the IBus daemon is not
       // ready yet. In this case, we'll defer the input method change
       // until the daemon is ready.
       if (!ChangeInputMethodViaIBus(input_method_id)) {
         VLOG(1) << "Failed to change the input method to " << input_method_id
                 << " (deferring)";
@@ skipping 141 matching lines @@
     std::map<std::string, InputMethodDescriptor>::const_iterator ix =
         extra_input_method_ids_.find(id);
     if (ix != extra_input_method_ids_.end()) {
       *descriptor = ix->second;
       return true;
     } else {
       return false;
     }
   }
 
-  virtual InputMethodDescriptor previous_input_method() const {
+  virtual InputMethodDescriptor GetPreviousInputMethod() const {
     if (previous_input_method_.id().empty()) {
       return InputMethodDescriptor::GetFallbackInputMethodDescriptor();
     }
     return previous_input_method_;
   }
 
-  virtual InputMethodDescriptor current_input_method() const {
+  virtual InputMethodDescriptor GetCurrentInputMethod() const {
     if (current_input_method_.id().empty()) {
       return InputMethodDescriptor::GetFallbackInputMethodDescriptor();
     }
     return current_input_method_;
   }
 
-  virtual ImePropertyList current_ime_properties() const {
+  virtual InputMethodPropertyList GetCurrentInputMethodProperties() const {
     if (should_hide_properties_ ||
-        InputMethodUtil::IsKeyboardLayout(current_input_method().id())) {
-      return ImePropertyList();
+        InputMethodUtil::IsKeyboardLayout(GetCurrentInputMethod().id())) {
+      return InputMethodPropertyList();
     }
     return current_ime_properties_;
   }
 
   virtual void SendHandwritingStroke(const HandwritingStroke& stroke) {
     ibus_controller_->SendHandwritingStroke(stroke);
   }
 
   virtual void CancelHandwritingStrokes(int stroke_count) {
     // TODO(yusukes): Rename the function to CancelHandwritingStrokes.
@@ skipping 361 matching lines @@
         ChangeCurrentInputMethodFromId(value.string_list_value[0]);
       }
       DCHECK(!current_input_method_.id().empty());
 
       // Update the indicator.
       // TODO(yusukes): Remove ActiveInputMethodsChanged notification in
       // FlushImeConfig().
       const size_t num_active_input_methods = GetNumActiveInputMethods();
       FOR_EACH_OBSERVER(InputMethodManager::Observer, observers_,
                         ActiveInputMethodsChanged(this,
-                                                  current_input_method(),
+                                                  GetCurrentInputMethod(),
                                                   num_active_input_methods));
     }
   }
 
   // Changes the current input method to |input_method_id| via IBus
   // daemon. If the id is not in the preload_engine list, this function
   // changes the current method to the first preloaded engine. Returns
   // true if the current engine is switched to |input_method_id| or the
   // first one.
   bool ChangeInputMethodViaIBus(const std::string& input_method_id) {
@@ skipping 125 matching lines @@
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       LOG(ERROR) << "Not on UI thread";
       return;
     }
 
     ChangeCurrentInputMethod(current_input_method);
   }
 
   // IBusController override.
   virtual void OnRegisterImeProperties(
-      const ImePropertyList& prop_list) {
+      const InputMethodPropertyList& prop_list) {
     // See comments in InputMethodChangedHandler.
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       LOG(ERROR) << "Not on UI thread";
       return;
     }
 
     RegisterProperties(prop_list);
   }
 
   // IBusController override.
   virtual void OnUpdateImeProperty(
-      const ImePropertyList& prop_list) {
+      const InputMethodPropertyList& prop_list) {
     // See comments in InputMethodChangedHandler.
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       LOG(ERROR) << "Not on UI thread";
       return;
     }
 
     UpdateProperty(prop_list);
   }
 
   // IBusController override.
@@ skipping 144 matching lines @@
     const InputMethodDescriptor* descriptor =
         util_.GetInputMethodDescriptorFromId(input_method_id);
     if (descriptor) {
       ChangeCurrentInputMethod(*descriptor);
     } else {
       LOG(ERROR) << "Descriptor is not found for: " << input_method_id;
     }
   }
 
   // Registers the properties used by the current input method.
-  void RegisterProperties(const ImePropertyList& prop_list) {
+  void RegisterProperties(const InputMethodPropertyList& prop_list) {
     // |prop_list| might be empty. This means "hide properties."
     if (prop_list.empty()) {
       should_hide_properties_ = true;
     } else {
       should_hide_properties_ = false;
       current_ime_properties_ = prop_list;
     }
     // Update input method menu
     FOR_EACH_OBSERVER(InputMethodManager::Observer, observers_,
-                      PropertyListChanged(this, current_ime_properties()));
+                      PropertyListChanged(this,
+                                          GetCurrentInputMethodProperties()));
   }
 
   // Starts the input method daemon. Unlike MaybeStopInputMethodDaemon(),
   // this function always starts the daemon. Returns true if the daemon is
   // started. Otherwise, e.g. the daemon is already started, returns false.
   bool StartInputMethodDaemon() {
     should_launch_ime_ = true;
     return MaybeLaunchInputMethodDaemon();
   }
 
   // Updates the properties used by the current input method.
-  void UpdateProperty(const ImePropertyList& prop_list) {
+  void UpdateProperty(const InputMethodPropertyList& prop_list) {
     for (size_t i = 0; i < prop_list.size(); ++i) {
       FindAndUpdateProperty(prop_list[i], &current_ime_properties_);
     }
 
     // Update input method menu
     FOR_EACH_OBSERVER(InputMethodManager::Observer, observers_,
-                      PropertyListChanged(this, current_ime_properties()));
+                      PropertyListChanged(this,
+                                          GetCurrentInputMethodProperties()));
   }
 
   // Launches an input method procsess specified by the given command
   // line. On success, returns true and stores the process handle in
   // |process_handle|. Otherwise, returns false, and the contents of
   // |process_handle| is untouched. OnImeShutdown will be called when the
   // process terminates.
   bool LaunchInputMethodProcess(const std::string& command_line,
                                 base::ProcessHandle* process_handle) {
     std::vector<std::string> argv;
@@ skipping 212 matching lines @@
   ObserverList<PreferenceObserver> pre_login_preference_observers_;
   ObserverList<PreferenceObserver> post_login_preference_observers_;
   ObserverList<VirtualKeyboardObserver> virtual_keyboard_observers_;
 
   // The input method which was/is selected.
   InputMethodDescriptor previous_input_method_;
   InputMethodDescriptor current_input_method_;
 
   // The input method properties which the current input method uses. The list
   // might be empty when no input method is used.
-  ImePropertyList current_ime_properties_;
+  InputMethodPropertyList current_ime_properties_;
   bool should_hide_properties_;
 
   typedef std::pair<std::string, std::string> ConfigKeyType;
   typedef std::map<
     ConfigKeyType, InputMethodConfigValue> InputMethodConfigRequests;
   // SetInputMethodConfig requests that are not yet completed.
   // Use a map to queue config requests, so we only send the last request for
   // the same config key (i.e. we'll discard ealier requests for the same
   // config key). As we discard old requests for the same config key, the order
   // of requests doesn't matter, so it's safe to use a map.
@@ skipping 69 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImpl);
 };
 
 // static
 InputMethodManager* InputMethodManager::GetInstance() {
   return InputMethodManagerImpl::GetInstance();
 }
 
 }  // namespace input_method
 }  // namespace chromeos