[IME] Removes the duplicated IMEs in chrome://settings/languages, and support async component IMEs …

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 94 matching lines @@
     case STATE_TERMINATING: {
       if (candidate_window_controller_.get())
         candidate_window_controller_.reset();
       break;
     }
   }
 }
 
 scoped_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetSupportedInputMethods() const {
-  return whitelist_.GetSupportedInputMethods();
+  if (!extension_ime_util::UseWrappedExtensionKeyboardLayouts()) {
+    return whitelist_.GetSupportedInputMethods();
+  }
+  // Returns empty list because all the supported imes have been migrated to
+  // component extension imes.
+  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];
     const InputMethodDescriptor* descriptor =
@@ skipping 113 matching lines @@
   }
 
   if (!Contains(*new_active_input_method_ids, input_method_id))
     new_active_input_method_ids->push_back(input_method_id);
 
   return true;
 }
 
 // Starts or stops the system input method framework as needed.
 void InputMethodManagerImpl::ReconfigureIMFramework() {
   if (component_extension_ime_manager_->IsInitialized())

[Yuki, 2014/03/07 07:47:04]

We don't need this conditional.  LoadNecessaryComponentExtensions() itself
checks whether the manager is initialized or not.

[Shu Chen, 2014/03/07 08:24:09]

Done.

     LoadNecessaryComponentExtensions();
 
-  const bool need_engine =
-      !ContainsOnlyKeyboardLayout(active_input_method_ids_);
-
   // Initialize candidate window controller and widgets such as
   // candidate window, infolist and mode indicator.  Note, mode
   // indicator is used by only keyboard layout input methods.
-  if (need_engine || active_input_method_ids_.size() > 1)
-    MaybeInitializeCandidateWindowController();
+  MaybeInitializeCandidateWindowController();
 }
 
 bool InputMethodManagerImpl::EnableInputMethod(
     const std::string& input_method_id) {
   if (!EnableInputMethodImpl(input_method_id, &active_input_method_ids_))
     return false;
 
   ReconfigureIMFramework();
   return true;
 }
@@ skipping 75 matching lines @@
   if (candidate_window_controller_.get())
     candidate_window_controller_->Hide();
 
   // Disable the current engine handler.
   IMEEngineHandlerInterface* engine =
       IMEBridge::Get()->GetCurrentEngineHandler();
   if (engine)
     engine->Disable();
 
   // Configure the next engine handler.
-  if (InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch)) {
+  if (InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch) &&
+      !extension_ime_util::IsKeyboardLayoutExtension(
+          input_method_id_to_switch)) {
     IMEBridge::Get()->SetCurrentEngineHandler(NULL);
   } else {
     IMEEngineHandlerInterface* next_engine =
         IMEBridge::Get()->SetCurrentEngineHandlerById(
             input_method_id_to_switch);
 
     if (next_engine)
       next_engine->Enable();
   }
 
@@ skipping 40 matching lines @@
 }
 
 void InputMethodManagerImpl::OnComponentExtensionInitialized(
     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   component_extension_ime_manager_->Initialize(delegate.Pass());
   util_.SetComponentExtensions(
       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor());
 
   LoadNecessaryComponentExtensions();
+  component_extension_ime_manager_->NotifyInitialized();

[Yuki, 2014/03/07 07:47:04]

In general, This sort of methods (NotifyFoobar()) should be called from the
notifier itself (Thus could be private: methods).  If you need to call Notify()
outside of the object, it's a wrong design, I think.

Having said that, we're short in time, let's put a TODO comment that this method
call should be moved into ComponentExtensionIMEManager.

As a second best solution, please put this call inside
LoadNecessaryComponentExtensions().  There are two calls to
LoadNecessaryComponentExtensions(), and we should notify in either case,
shouldn't we?

[Shu Chen, 2014/03/07 08:24:09]

This NotifyInitialized() should be called only once. If move to
LoadNecessaryComponentExtensions() then there will be chances to call it twice.
I would prefer to add TODO comment for now.

[Yuki, 2014/03/07 09:02:28]

Then, could you add a flag inside ComponentExtensionIMEManager like
|is_initialized_|?  Like:
  if (is_initialized_ && was_initialization_notified_) ...

 
   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 =

[Yuki, 2014/03/07 07:47:04]

Just a nit:

std::vector unfiltered_ids;  // empty vector
unfiltered_ids.swap(active_ids_);

is much more efficient because typical implementations of swap() never copy
members while the assignment operator does copy.  (Typical implementations of
vector assignment don't do copy-on-write).

[Shu Chen, 2014/03/07 08:24:09]

Done.

       active_input_method_ids_;
   active_input_method_ids_.clear();
   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(
@@ skipping 389 matching lines @@
   active_input_method_ids_ = saved_active_input_method_ids_;
 
   ChangeInputMethod(current_input_method_.id());
 }
 
 bool InputMethodManagerImpl::InputMethodIsActivated(
     const std::string& input_method_id) {
   return Contains(active_input_method_ids_, input_method_id);
 }
 
-bool InputMethodManagerImpl::ContainsOnlyKeyboardLayout(
-    const std::vector<std::string>& value) {
-  for (size_t i = 0; i < value.size(); ++i) {
-    if (!InputMethodUtil::IsKeyboardLayout(value[i]))
-      return false;
-  }
-  return true;
-}
-
 void InputMethodManagerImpl::MaybeInitializeCandidateWindowController() {
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos