Refactoring for InputMethodEngine and InputMethodEventRouter.

chrome/browser/chromeos/input_method/input_method_engine.cc

 // Copyright 2013 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_engine.h"
 
 #undef FocusIn
 #undef FocusOut
 #undef RootWindow
 #include <map>
@@ skipping 94 matching lines @@
   ext_event->ctrl_key = event.IsControlDown();
   ext_event->shift_key = event.IsShiftDown();
   ext_event->caps_lock = event.IsCapsLockDown();
   ext_event->key = GetKeyFromEvent(event);
 }
 
 }  // namespace
 
 InputMethodEngine::InputMethodEngine()
     : current_input_type_(ui::TEXT_INPUT_TYPE_NONE),
-      active_(false),
       context_id_(0),
       next_context_id_(1),
       composition_text_(new CompositionText()),
       composition_cursor_(0),
       candidate_window_(new ui::CandidateWindow()),
       window_visible_(false),
       sent_key_event_(NULL) {}
 
 InputMethodEngine::~InputMethodEngine() {
   if (start_time_.ToInternalValue())
     RecordHistogram("WorkingTime", (end_time_ - start_time_).InSeconds());
-  input_method::InputMethodManager::Get()->RemoveInputMethodExtension(imm_id_);
 }
 
 void InputMethodEngine::Initialize(
     scoped_ptr<InputMethodEngineInterface::Observer> observer,
-    const char* engine_name,
-    const char* extension_id,
-    const char* engine_id,
-    const std::vector<std::string>& languages,
-    const std::vector<std::string>& layouts,
-    const GURL& options_page,
-    const GURL& input_view) {
+    const char* extension_id) {
   DCHECK(observer) << "Observer must not be null.";
 
   // TODO(komatsu): It is probably better to set observer out of Initialize.
   observer_ = observer.Pass();
-  engine_id_ = engine_id;
   extension_id_ = extension_id;
-
-  input_method::InputMethodManager* manager =
-      input_method::InputMethodManager::Get();
-  ComponentExtensionIMEManager* comp_ext_ime_manager =
-      manager->GetComponentExtensionIMEManager();
-
-  if (comp_ext_ime_manager->IsWhitelistedExtension(extension_id)) {
-    imm_id_ = comp_ext_ime_manager->GetId(extension_id, engine_id);
-  } else {
-    imm_id_ = extension_ime_util::GetInputMethodID(extension_id, engine_id);
-  }
-
-  input_view_url_ = input_view;
-  descriptor_ = input_method::InputMethodDescriptor(
-      imm_id_,
-      engine_name,
-      std::string(), // TODO(uekawa): Set short name.
-      layouts,
-      languages,
-      extension_ime_util::IsKeyboardLayoutExtension(
-          imm_id_), // is_login_keyboard
-      options_page,
-      input_view);
-
-  // TODO(komatsu): It is probably better to call AddInputMethodExtension
-  // out of Initialize.
-  manager->AddInputMethodExtension(imm_id_, this);
-}
-
-const input_method::InputMethodDescriptor& InputMethodEngine::GetDescriptor()
-    const {
-  return descriptor_;
 }
 
 void InputMethodEngine::RecordHistogram(const char* name, int count) {
   std::string histo_name =
-      base::StringPrintf("InputMethod.%s.%s", name, engine_id_.c_str());
+      base::StringPrintf("InputMethod.%s.%s", name, active_engine_id_.c_str());
   base::HistogramBase* counter = base::Histogram::FactoryGet(
       histo_name, 0, 1000000, 50, base::HistogramBase::kNoFlags);
   if (counter)
     counter->Add(count);
 }
 
-void InputMethodEngine::NotifyImeReady() {
-  input_method::InputMethodManager* manager =
-      input_method::InputMethodManager::Get();
-  if (manager && imm_id_ == manager->GetCurrentInputMethod().id())
-    Enable();
+const std::string& InputMethodEngine::GetActiveEngineId() const {
+  return active_engine_id_;
 }
 
 bool InputMethodEngine::SetComposition(
     int context_id,
     const char* text,
     int selection_start,
     int selection_end,
     int cursor,
     const std::vector<SegmentInfo>& segments,
     std::string* error) {
-  if (!active_) {
+  if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   composition_cursor_ = cursor;
   composition_text_.reset(new CompositionText());
@@ skipping 23 matching lines @@
     composition_text_->mutable_underline_attributes()->push_back(underline);
   }
 
   // TODO(nona): Makes focus out mode configuable, if necessary.
   UpdateComposition(*composition_text_, composition_cursor_, true);
   return true;
 }
 
 bool InputMethodEngine::ClearComposition(int context_id,
                                          std::string* error)  {
-  if (!active_) {
+  if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   composition_cursor_ = 0;
   composition_text_.reset(new CompositionText());
   UpdateComposition(*composition_text_, composition_cursor_, false);
   return true;
 }
 
 bool InputMethodEngine::CommitText(int context_id, const char* text,
                                    std::string* error) {
-  if (!active_) {
+  if (!IsActive()) {
     // TODO: Commit the text anyways.
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   IMEBridge::Get()->GetInputContextHandler()->CommitText(text);
 
   // Records times for using input method.
   if (!start_time_.ToInternalValue())
     start_time_ = base::Time::Now();
   end_time_ = base::Time::Now();
   // Records histograms for counts of commits and committed characters.
   RecordHistogram("Commit", 1);
   RecordHistogram("CommitCharacter", GetUtf8StringLength(text));
   return true;
 }
 
 bool InputMethodEngine::SendKeyEvents(
     int context_id,
     const std::vector<KeyboardEvent>& events) {
-  if (!active_) {
+  if (!IsActive()) {
     return false;
   }
   // context_id  ==  0, means sending key events to non-input field.
   // context_id_ == -1, means the focus is not in an input field.
   if (context_id != 0 && (context_id != context_id_ || context_id_ == -1)) {
     return false;
   }
 
   ui::EventProcessor* dispatcher =
       ash::Shell::GetPrimaryRootWindow()->GetHost()->event_processor();
@@ skipping 48 matching lines @@
   dest_property.show_window_at_composition =
       property.show_window_at_composition;
   dest_property.cursor_position =
       candidate_window_->GetProperty().cursor_position;
   dest_property.auxiliary_text = property.auxiliary_text;
   dest_property.is_auxiliary_text_visible = property.is_auxiliary_text_visible;
 
   candidate_window_->SetProperty(dest_property);
   candidate_window_property_ = property;
 
-  if (active_) {
+  if (IsActive()) {
     IMECandidateWindowHandlerInterface* cw_handler =
         IMEBridge::Get()->GetCandidateWindowHandler();
     if (cw_handler)
       cw_handler->UpdateLookupTable(*candidate_window_, window_visible_);
   }
 }
 
 bool InputMethodEngine::SetCandidateWindowVisible(bool visible,
                                                   std::string* error) {
-  if (!active_) {
+  if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
   }
 
   window_visible_ = visible;
   IMECandidateWindowHandlerInterface* cw_handler =
       IMEBridge::Get()->GetCandidateWindowHandler();
   if (cw_handler)
     cw_handler->UpdateLookupTable(*candidate_window_, window_visible_);
   return true;
 }
 
 bool InputMethodEngine::SetCandidates(
     int context_id,
     const std::vector<Candidate>& candidates,
     std::string* error) {
-  if (!active_) {
+  if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   // TODO: Nested candidates
   candidate_ids_.clear();
   candidate_indexes_.clear();
   candidate_window_->mutable_candidates()->clear();
   for (std::vector<Candidate>::const_iterator ix = candidates.begin();
        ix != candidates.end(); ++ix) {
     ui::CandidateWindow::Entry entry;
     entry.value = base::UTF8ToUTF16(ix->value);
     entry.label = base::UTF8ToUTF16(ix->label);
     entry.annotation = base::UTF8ToUTF16(ix->annotation);
     entry.description_title = base::UTF8ToUTF16(ix->usage.title);
     entry.description_body = base::UTF8ToUTF16(ix->usage.body);
 
     // Store a mapping from the user defined ID to the candidate index.
     candidate_indexes_[ix->id] = candidate_ids_.size();
     candidate_ids_.push_back(ix->id);
 
     candidate_window_->mutable_candidates()->push_back(entry);
   }
-  if (active_) {
+  if (IsActive()) {
     IMECandidateWindowHandlerInterface* cw_handler =
         IMEBridge::Get()->GetCandidateWindowHandler();
     if (cw_handler)
       cw_handler->UpdateLookupTable(*candidate_window_, window_visible_);
   }
   return true;
 }
 
 bool InputMethodEngine::SetCursorPosition(int context_id, int candidate_id,
                                           std::string* error) {
-  if (!active_) {
+  if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   std::map<int, int>::const_iterator position =
       candidate_indexes_.find(candidate_id);
   if (position == candidate_indexes_.end()) {
     *error = kCandidateNotFound;
     return false;
   }
 
   candidate_window_->set_cursor_position(position->second);
   IMECandidateWindowHandlerInterface* cw_handler =
       IMEBridge::Get()->GetCandidateWindowHandler();
   if (cw_handler)
     cw_handler->UpdateLookupTable(*candidate_window_, window_visible_);
   return true;
 }
 
 bool InputMethodEngine::SetMenuItems(const std::vector<MenuItem>& items) {
   return UpdateMenuItems(items);
 }
 
 bool InputMethodEngine::UpdateMenuItems(
     const std::vector<MenuItem>& items) {
-  if (!active_)
+  if (!IsActive())
     return false;
 
   ash::ime::InputMethodMenuItemList menu_item_list;
   for (std::vector<MenuItem>::const_iterator item = items.begin();
        item != items.end(); ++item) {
     ash::ime::InputMethodMenuItem property;
     MenuItemToProperty(*item, &property);
     menu_item_list.push_back(property);
   }
 
   ash::ime::InputMethodMenuManager::GetInstance()->
       SetCurrentInputMethodMenuItemList(
           menu_item_list);
   return true;
 }
 
 bool InputMethodEngine::IsActive() const {
-  return active_;
+  return !active_engine_id_.empty();
 }
 
 bool InputMethodEngine::DeleteSurroundingText(int context_id,
                                               int offset,
                                               size_t number_of_chars,
                                               std::string* error) {
-  if (!active_) {
+  if (!IsActive()) {
     *error = kErrorNotActive;
     return false;
   }
   if (context_id != context_id_ || context_id_ == -1) {
     *error = kErrorWrongContext;
     return false;
   }
 
   if (offset < 0 && static_cast<size_t>(-1 * offset) != size_t(number_of_chars))
     return false;  // Currently we can only support preceding text.
@@ skipping 11 matching lines @@
 void InputMethodEngine::HideInputView() {
   keyboard::KeyboardController* keyboard_controller =
     keyboard::KeyboardController::GetInstance();
   if (keyboard_controller) {
     keyboard_controller->HideKeyboard(
         keyboard::KeyboardController::HIDE_REASON_MANUAL);
   }
 }
 
 void InputMethodEngine::EnableInputView(bool enabled) {
-  const GURL& url = enabled ? input_view_url_ : GURL();
+  const GURL& url = enabled && GetCurrentInputMethod() ?
+      GetCurrentInputMethod()->input_view_url() : GURL();
   keyboard::SetOverrideContentUrl(url);
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller)
     keyboard_controller->Reload();
 }
 
+const input_method::InputMethodDescriptor*
+InputMethodEngine::GetCurrentInputMethod() {
+  input_method::InputMethodManager* manager =
+      input_method::InputMethodManager::Get();

[Shu Chen, 2014/08/04 15:59:31]

Here could just use
input_method::InputMethodManager::Get()->GetCurrentInputMethod().

[Seigo Nonaka, 2014/08/04 23:29:47]

Seems yes.

On 2014/08/04 15:59:31, Shu Chen wrote:

[Shu Chen, 2014/08/05 01:23:09]

Done.

[Shu Chen, 2014/08/05 01:59:03]

Changed and found a bug. Enable() method is called in
InputMethodManagerImpl::ChangeInputMethodInternal() before its
current_input_method_ is set to new input method.

I've fixed it by moving the  Enable() call after current_input_method_ is set to
new input method.
Do you think it's a reasonable fix?

+  ComponentExtensionIMEManager* comp_manager =
+      manager->GetComponentExtensionIMEManager();
+  std::string input_method_id;
+  if (comp_manager->IsWhitelistedExtension(extension_id_))
+    input_method_id = extension_ime_util::GetComponentInputMethodID(
+        extension_id_, active_engine_id_);
+  else
+    input_method_id = extension_ime_util::GetInputMethodID(
+        extension_id_, active_engine_id_);
+  return manager->GetInputMethodFromId(input_method_id);
+}
+
 void InputMethodEngine::FocusIn(
     const IMEEngineHandlerInterface::InputContext& input_context) {
   current_input_type_ = input_context.type;
 
-  if (!active_ || current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
+  if (!IsActive() || current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   context_id_ = next_context_id_;
   ++next_context_id_;
 
   InputMethodEngineInterface::InputContext context;
   context.id = context_id_;
   switch (current_input_type_) {
     case ui::TEXT_INPUT_TYPE_SEARCH:
       context.type = "search";
@@ skipping 15 matching lines @@
       break;
     default:
       context.type = "text";
       break;
   }
 
   observer_->OnFocus(context);
 }
 
 void InputMethodEngine::FocusOut() {
-  if (!active_ || current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
+  if (!IsActive() || current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   current_input_type_ = ui::TEXT_INPUT_TYPE_NONE;
 
   int context_id = context_id_;
   context_id_ = -1;
   observer_->OnBlur(context_id);
 }
 
-void InputMethodEngine::Enable() {
-  active_ = true;
-  observer_->OnActivate(engine_id_);
+void InputMethodEngine::Enable(const std::string& engine_id) {
+  DCHECK(!engine_id.empty());
+  active_engine_id_ = engine_id;
+  observer_->OnActivate(engine_id);
   current_input_type_ = IMEBridge::Get()->GetCurrentTextInputType();
   FocusIn(IMEEngineHandlerInterface::InputContext(
       current_input_type_, ui::TEXT_INPUT_MODE_DEFAULT));
   EnableInputView(true);
 
   start_time_ = base::Time();
   end_time_ = base::Time();
   RecordHistogram("Enable", 1);
 }
 
 void InputMethodEngine::Disable() {
-  active_ = false;
-  observer_->OnDeactivated(engine_id_);
+  active_engine_id_ = "";
+  observer_->OnDeactivated(active_engine_id_);
 
   if (start_time_.ToInternalValue())
     RecordHistogram("WorkingTime", (end_time_ - start_time_).InSeconds());
 }
 
 void InputMethodEngine::PropertyActivate(const std::string& property_name) {
-  observer_->OnMenuItemActivated(engine_id_, property_name);
+  observer_->OnMenuItemActivated(active_engine_id_, property_name);
 }
 
 void InputMethodEngine::Reset() {
-  observer_->OnReset(engine_id_);
+  observer_->OnReset(active_engine_id_);
 }
 
 void InputMethodEngine::ProcessKeyEvent(
     const ui::KeyEvent& key_event,
     const KeyEventDoneCallback& callback) {
 
   KeyEventDoneCallback *handler = new KeyEventDoneCallback();
   *handler = callback;
 
   KeyboardEvent ext_event;
   GetExtensionKeyboardEventFromKeyEvent(key_event, &ext_event);
 
   // If the given key event is equal to the key event sent by
   // SendKeyEvents, this engine ID is propagated to the extension IME.
   // Note, this check relies on that ui::KeyEvent is propagated as
   // reference without copying.
   if (&key_event == sent_key_event_)
     ext_event.extension_id = extension_id_;
 
   observer_->OnKeyEvent(
-      engine_id_,
+      active_engine_id_,
       ext_event,
       reinterpret_cast<input_method::KeyEventHandle*>(handler));
 }
 
 void InputMethodEngine::CandidateClicked(uint32 index) {
   if (index > candidate_ids_.size()) {
     return;
   }
 
   // Only left button click is supported at this moment.
   observer_->OnCandidateClicked(
-      engine_id_, candidate_ids_.at(index), MOUSE_BUTTON_LEFT);
+      active_engine_id_, candidate_ids_.at(index), MOUSE_BUTTON_LEFT);
 }
 
 void InputMethodEngine::SetSurroundingText(const std::string& text,
                                            uint32 cursor_pos,
                                            uint32 anchor_pos) {
-  observer_->OnSurroundingTextChanged(engine_id_,
+  observer_->OnSurroundingTextChanged(active_engine_id_,
                                       text,
                                       static_cast<int>(cursor_pos),
                                       static_cast<int>(anchor_pos));
 }
 
 // TODO(uekawa): rename this method to a more reasonable name.
 void InputMethodEngine::MenuItemToProperty(
     const MenuItem& item,
     ash::ime::InputMethodMenuItem* property) {
   property->key = item.id;
@@ skipping 28 matching lines @@
           // TODO(nona): Implement it.
           break;
       }
     }
   }
 
   // TODO(nona): Support item.children.
 }
 
 }  // namespace chromeos