Revert 251164 "Split out InputMethodMenuManager from InputMethod..."

trunk/src/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 "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/input_method/candidate_window_controller.h"
@@ skipping 29 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 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 InputMethodPropertyList empty_property_list;
+    SetCurrentInputMethodProperties(empty_property_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::ActivateInputMethodMenuItem(
+void InputMethodManagerImpl::ActivateInputMethodProperty(
     const std::string& key) {
   DCHECK(!key.empty());
 
-  if (ash::ime::InputMethodMenuManager::Get()->
-      HasInputMethodMenuItemForKey(key)) {
-    IMEEngineHandlerInterface* engine =
-        IMEBridge::Get()->GetCurrentEngineHandler();
-    if (engine)
-      engine->PropertyActivate(key);
-    return;
+  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;
+    }
   }
 
-  DVLOG(1) << "ActivateInputMethodMenuItem: unknown key: " << key;
+  DVLOG(1) << "ActivateInputMethodProperty: 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 35 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