Moving IME manifests to chrome resources.

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"
@@ skipping 42 matching lines @@
 
 bool InputMethodManagerImpl::MigrateInputMethods(
     std::vector<std::string>* input_method_ids) {
   return util_.MigrateInputMethods(input_method_ids);
 }
 
 InputMethodManagerImpl::InputMethodManagerImpl(
     scoped_ptr<InputMethodDelegate> delegate)
     : delegate_(delegate.Pass()),
       state_(STATE_LOGIN_SCREEN),
-      util_(delegate_.get(), whitelist_.GetSupportedInputMethods()),
+      util_(delegate_.get()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
       weak_ptr_factory_(this) {
+  if (base::SysInfo::IsRunningOnChromeOS())
+    keyboard_.reset(ImeKeyboard::Create());
+  else
+    keyboard_.reset(new FakeImeKeyboard());
 }
 
 InputMethodManagerImpl::~InputMethodManagerImpl() {
   if (candidate_window_controller_.get())
     candidate_window_controller_->RemoveObserver(this);
 }
 
 void InputMethodManagerImpl::AddObserver(
     InputMethodManager::Observer* observer) {
   observers_.AddObserver(observer);
@@ skipping 30 matching lines @@
     case STATE_TERMINATING: {
       if (candidate_window_controller_.get())
         candidate_window_controller_.reset();
       break;
     }
   }
 }
 
 scoped_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetSupportedInputMethods() const {
-  if (!IsXkbComponentExtensionAvailable())
-    return whitelist_.GetSupportedInputMethods().Pass();
   return scoped_ptr<InputMethodDescriptors>(new InputMethodDescriptors).Pass();
 }
 
 scoped_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetActiveInputMethods() const {
   scoped_ptr<InputMethodDescriptors> result(new InputMethodDescriptors);
   // Build the active input method descriptors from the active input
   // methods cache |active_input_method_ids_|.
   for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
     const std::string& input_method_id = active_input_method_ids_[i];
@@ skipping 190 matching lines @@
     scoped_ptr<InputMethodDescriptors> input_methods(GetActiveInputMethods());
     DCHECK(!input_methods->empty());
     input_method_id_to_switch = input_methods->at(0).id();
     if (!input_method_id.empty()) {
       DVLOG(1) << "Can't change the current input method to "
                << input_method_id << " since the engine is not enabled. "
                << "Switch to " << input_method_id_to_switch << " instead.";
     }
   }
 
-  if (!component_extension_ime_manager_->IsInitialized() &&
-      !InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch)) {
-    // We can't change input method before the initialization of
-    // component extension ime manager.  ChangeInputMethod will be
-    // called with |pending_input_method_| when the initialization is
-    // done.
-    pending_input_method_ = input_method_id_to_switch;
-    return false;
-  }
-  pending_input_method_.clear();
-
   // Hide candidate window and info list.
   if (candidate_window_controller_.get())
     candidate_window_controller_->Hide();
 
   // Disable the current engine handler.
   IMEEngineHandlerInterface* engine =
       IMEBridge::Get()->GetCurrentEngineHandler();
   if (engine)
     engine->Disable();
 
@@ skipping 48 matching lines @@
                << current_input_method_.GetPreferredKeyboardLayout();
   }
 
   // Update input method indicators (e.g. "US", "DV") in Chrome windows.
   FOR_EACH_OBSERVER(InputMethodManager::Observer,
                     observers_,
                     InputMethodChanged(this, show_message));
   return true;
 }
 
-bool InputMethodManagerImpl::IsXkbComponentExtensionAvailable() const {
-  if (!component_extension_ime_manager_->IsInitialized())
-    return false;
-  InputMethodDescriptors imes =
-      component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
-  for (size_t i = 0; i < imes.size(); ++i) {
-    if (StartsWithASCII(extension_ime_util::MaybeGetLegacyXkbId(
-        imes[i].id()), "xkb:", true))
-      return true;
-  }
-  return false;
-}
-
-void InputMethodManagerImpl::OnComponentExtensionInitialized(
-    scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  component_extension_ime_manager_->Initialize(delegate.Pass());
-  InputMethodDescriptors imes =
-      component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
-  // In case of XKB extension is not available (e.g. linux_chromeos), don't
-  // reset the input methods in InputMethodUtil, Instead append input methods.
-  if (IsXkbComponentExtensionAvailable())
-    util_.ResetInputMethods(imes);
-  else
-    util_.AppendInputMethods(imes);
-
-  LoadNecessaryComponentExtensions();
-
-  if (!pending_input_method_.empty())
-    ChangeInputMethodInternal(pending_input_method_, false);
-}
-
 void InputMethodManagerImpl::LoadNecessaryComponentExtensions() {
-  if (!component_extension_ime_manager_->IsInitialized())
-    return;
   // Load component extensions but also update |active_input_method_ids_| as
   // some component extension IMEs may have been removed from the Chrome OS
   // image. If specified component extension IME no longer exists, falling back
   // to an existing IME.
   std::vector<std::string> unfiltered_input_method_ids;
   unfiltered_input_method_ids.swap(active_input_method_ids_);
   for (size_t i = 0; i < unfiltered_input_method_ids.size(); ++i) {
     if (!extension_ime_util::IsComponentExtensionIME(
         unfiltered_input_method_ids[i])) {
       // Legacy IMEs or xkb layouts are alwayes active.
       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]);
     }
   }
-  // TODO(shuchen): move this call in ComponentExtensionIMEManager.
-  component_extension_ime_manager_->NotifyInitialized();
 }
 
 void InputMethodManagerImpl::ActivateInputMethodMenuItem(
     const std::string& key) {
   DCHECK(!key.empty());
 
   if (ash::ime::InputMethodMenuManager::GetInstance()->
       HasInputMethodMenuItemForKey(key)) {
     IMEEngineHandlerInterface* engine =
         IMEBridge::Get()->GetCurrentEngineHandler();
@@ skipping 151 matching lines @@
 
   // This asks the file thread to save the prefs (i.e. doesn't block).
   // The latest values of Local State reside in memory so we can safely
   // get the value of kHardwareKeyboardLayout even if the data is not
   // yet saved to disk.
   prefs->CommitPendingWrite();
 
   util_.UpdateHardwareLayoutCache();
 
   EnableLoginLayouts(locale, layouts);
+  LoadNecessaryComponentExtensions();
 }
 
 void InputMethodManagerImpl::SetInputMethodLoginDefault() {
   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
   // and US dvorak keyboard layouts.
   if (g_browser_process && g_browser_process->local_state()) {
     const std::string locale = g_browser_process->GetApplicationLocale();
     // If the preferred keyboard for the login screen has been saved, use it.
     PrefService* prefs = g_browser_process->local_state();
     std::string initial_input_method_id =
         prefs->GetString(chromeos::language_prefs::kPreferredKeyboardLayout);
     std::vector<std::string> input_methods_to_be_enabled;
     if (initial_input_method_id.empty()) {
       // If kPreferredKeyboardLayout is not specified, use the hardware layout.
       input_methods_to_be_enabled = util_.GetHardwareLoginInputMethodIds();
     } else {
       input_methods_to_be_enabled.push_back(initial_input_method_id);
     }
     EnableLoginLayouts(locale, input_methods_to_be_enabled);
+    LoadNecessaryComponentExtensions();
   }
 }
 
 bool InputMethodManagerImpl::SwitchToNextInputMethod() {
   // Sanity checks.
   if (active_input_method_ids_.empty()) {
     DVLOG(1) << "active input method is empty";
     return false;
   }
 
@@ skipping 138 matching lines @@
   return &util_;
 }
 
 ComponentExtensionIMEManager*
     InputMethodManagerImpl::GetComponentExtensionIMEManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return component_extension_ime_manager_.get();
 }
 
 void InputMethodManagerImpl::InitializeComponentExtension() {
-  ComponentExtensionIMEManagerImpl* impl =
-      new ComponentExtensionIMEManagerImpl();
-  scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(impl);
-  impl->InitializeAsync(base::Bind(
-                       &InputMethodManagerImpl::OnComponentExtensionInitialized,
-                       weak_ptr_factory_.GetWeakPtr(),
-                       base::Passed(&delegate)));
-}
+  scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(
+      new ComponentExtensionIMEManagerImpl());
+  component_extension_ime_manager_->Initialize(delegate.Pass());
 
-void InputMethodManagerImpl::Init(base::SequencedTaskRunner* ui_task_runner) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (base::SysInfo::IsRunningOnChromeOS())
-    keyboard_.reset(ImeKeyboard::Create());
-  else
-    keyboard_.reset(new FakeImeKeyboard());
-
-  // We can't call impl->Initialize here, because file thread is not available
-  // at this moment.
-  ui_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&InputMethodManagerImpl::InitializeComponentExtension,
-                 weak_ptr_factory_.GetWeakPtr()));
+  util_.ResetInputMethods(
+      component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor());
 }
 
 void InputMethodManagerImpl::SetCandidateWindowControllerForTesting(
     CandidateWindowController* candidate_window_controller) {
   candidate_window_controller_.reset(candidate_window_controller);
   candidate_window_controller_->AddObserver(this);
 }
 
 void InputMethodManagerImpl::SetImeKeyboardForTesting(ImeKeyboard* keyboard) {
   keyboard_.reset(keyboard);
 }
 
 void InputMethodManagerImpl::InitializeComponentExtensionForTesting(
     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
-  OnComponentExtensionInitialized(delegate.Pass());
+  component_extension_ime_manager_->Initialize(delegate.Pass());
+  util_.ResetInputMethods(
+      component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor());
 }
 
 void InputMethodManagerImpl::CandidateClicked(int index) {
   IMEEngineHandlerInterface* engine =
       IMEBridge::Get()->GetCurrentEngineHandler();
   if (engine)
     engine->CandidateClicked(index);
 }
 
 void InputMethodManagerImpl::CandidateWindowOpened() {
@@ skipping 64 matching lines @@
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 Profile* InputMethodManagerImpl::GetProfile() const {
   return ProfileManager::GetActiveUserProfile();
 }
 
 }  // namespace input_method
 }  // namespace chromeos