Split out InputMethodMenuManager from InputMethodManager

chrome/browser/chromeos/input_method/input_method_manager_impl.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_impl.h"
 
 #include <algorithm>  // std::find
 
+#include "ash/ime/input_method_menu_item.h"
+#include "ash/ime/input_method_menu_manager.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/input_method/candidate_window_controller.h"
 #include "chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.h"
@@ skipping 27 matching lines @@
   return util_.IsLoginKeyboard(layout);
 }
 
 InputMethodManagerImpl::InputMethodManagerImpl(
     scoped_ptr<InputMethodDelegate> delegate)
     : delegate_(delegate.Pass()),
       state_(STATE_LOGIN_SCREEN),
       util_(delegate_.get(), GetSupportedInputMethods()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
       weak_ptr_factory_(this) {
+  ash::ime::InputMethodMenuManager::Initialize();
 }
 
 InputMethodManagerImpl::~InputMethodManagerImpl() {
   if (candidate_window_controller_.get())
     candidate_window_controller_->RemoveObserver(this);
+  ash::ime::InputMethodMenuManager::Shutdown();
 }
 
 void InputMethodManagerImpl::AddObserver(
     InputMethodManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void InputMethodManagerImpl::AddCandidateWindowObserver(
     InputMethodManager::CandidateWindowObserver* observer) {
   candidate_window_observers_.AddObserver(observer);
@@ skipping 270 matching lines @@
       next_engine->Enable();
   }
 
   // TODO(komatsu): Check if it is necessary to perform the above routine
   // when the current input method is equal to |input_method_id_to_swich|.
   if (current_input_method_.id() != input_method_id_to_switch) {
     // Clear property list.  Property list would be updated by
     // extension IMEs via InputMethodEngine::(Set|Update)MenuItems.
     // If the current input method is a keyboard layout, empty
     // properties are sufficient.
-    const InputMethodPropertyList empty_property_list;
-    SetCurrentInputMethodProperties(empty_property_list);
+    const ash::ime::InputMethodMenuItemList empty_menu_item_list;
+    ash::ime::InputMethodMenuManager* input_method_menu_manager =
+        ash::ime::InputMethodMenuManager::Get();
+    input_method_menu_manager->SetCurrentInputMethodMenuItemList(
+            empty_menu_item_list);
 
     const InputMethodDescriptor* descriptor = NULL;
     if (extension_ime_util::IsExtensionIME(input_method_id_to_switch)) {
       DCHECK(extra_input_methods_.find(input_method_id_to_switch) !=
              extra_input_methods_.end());
       descriptor = &(extra_input_methods_[input_method_id_to_switch]);
     } else {
       descriptor =
           util_.GetInputMethodDescriptorFromId(input_method_id_to_switch);
     }
@@ skipping 47 matching lines @@
       active_input_method_ids_.push_back(unfiltered_input_method_ids[i]);
     } else if (component_extension_ime_manager_->IsWhitelisted(
         unfiltered_input_method_ids[i])) {
       component_extension_ime_manager_->LoadComponentExtensionIME(
           unfiltered_input_method_ids[i]);
       active_input_method_ids_.push_back(unfiltered_input_method_ids[i]);
     }
   }
 }
 
-void InputMethodManagerImpl::ActivateInputMethodProperty(
+void InputMethodManagerImpl::ActivateInputMethodMenuItem(
     const std::string& key) {
   DCHECK(!key.empty());
 
-  for (size_t i = 0; i < property_list_.size(); ++i) {
-    if (property_list_[i].key == key) {
-      IMEEngineHandlerInterface* engine =
-          IMEBridge::Get()->GetCurrentEngineHandler();
-      if (engine)
-        engine->PropertyActivate(key);
-      return;
-    }
+  if (ash::ime::InputMethodMenuManager::Get()->
+      HasInputMethodMenuItemForKey(key)) {
+    IMEEngineHandlerInterface* engine =
+        IMEBridge::Get()->GetCurrentEngineHandler();
+    if (engine)
+      engine->PropertyActivate(key);
+    return;
   }
 
-  DVLOG(1) << "ActivateInputMethodProperty: unknown key: " << key;
+  DVLOG(1) << "ActivateInputMethodMenuItem: unknown key: " << key;
 }
 
 void InputMethodManagerImpl::AddInputMethodExtension(
     const std::string& id,
     InputMethodEngineInterface* engine) {
   if (state_ == STATE_TERMINATING)
     return;
 
   if (!extension_ime_util::IsExtensionIME(id) &&
       !extension_ime_util::IsComponentExtensionIME(id)) {
@@ skipping 233 matching lines @@
   ChangeInputMethodInternal(*iter, true);
 }
 
 InputMethodDescriptor InputMethodManagerImpl::GetCurrentInputMethod() const {
   if (current_input_method_.id().empty())
     return InputMethodUtil::GetFallbackInputMethodDescriptor();
 
   return current_input_method_;
 }
 
-InputMethodPropertyList
-InputMethodManagerImpl::GetCurrentInputMethodProperties() const {
-  // This check is necessary since an IME property (e.g. for Pinyin) might be
-  // sent from ibus-daemon AFTER the current input method is switched to XKB.
-  if (InputMethodUtil::IsKeyboardLayout(GetCurrentInputMethod().id()))
-    return InputMethodPropertyList();  // Empty list.
-  return property_list_;
-}
-
-void InputMethodManagerImpl::SetCurrentInputMethodProperties(
-    const InputMethodPropertyList& property_list) {
-  property_list_ = property_list;
-  PropertyChanged();
-}
-
 XKeyboard* InputMethodManagerImpl::GetXKeyboard() {
   return xkeyboard_.get();
 }
 
 InputMethodUtil* InputMethodManagerImpl::GetInputMethodUtil() {
   return &util_;
 }
 
 ComponentExtensionIMEManager*
     InputMethodManagerImpl::GetComponentExtensionIMEManager() {
@@ skipping 32 matching lines @@
 
 void InputMethodManagerImpl::SetXKeyboardForTesting(XKeyboard* xkeyboard) {
   xkeyboard_.reset(xkeyboard);
 }
 
 void InputMethodManagerImpl::InitializeComponentExtensionForTesting(
     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
   OnComponentExtensionInitialized(delegate.Pass());
 }
 
-void InputMethodManagerImpl::PropertyChanged() {
-  FOR_EACH_OBSERVER(InputMethodManager::Observer,
-                    observers_,
-                    InputMethodPropertyChanged(this));
-}
-
 void InputMethodManagerImpl::CandidateClicked(int index) {
   IMEEngineHandlerInterface* engine =
       IMEBridge::Get()->GetCurrentEngineHandler();
   if (engine)
     engine->CandidateClicked(index);
 }
 
 void InputMethodManagerImpl::CandidateWindowOpened() {
   FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
                     candidate_window_observers_,
@@ skipping 60 matching lines @@
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos