Refactoring for InputMethodEngine and InputMethodEventRouter.

chrome/browser/extensions/api/input_ime/input_ime_api.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/extensions/api/input_ime/input_ime_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "chrome/common/extensions/api/input_ime/input_components_handler.h"
+#include "chromeos/ime/component_extension_ime_manager.h"
+#include "chromeos/ime/extension_ime_util.h"
+#include "chromeos/ime/input_method_manager.h"

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

Nona, I guess the original design was to avoid dependency to InputMethodManager,
but I don't know why.
This cl would introduce dependency to InputMethodManager. With reasonable
justification, I can move the dependency to InputMethodEngine.

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

Probably, it is historical reasons. It used to be planed that this API would be
used also in other platforms.
However, that plan is no longer active and already chrome os specific dependency
was introduced.
So I think we no longer consider the dependency to chrome os specific headers.

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

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

Done.

 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 
 #if defined(USE_X11)
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #endif
 
@@ skipping 41 matching lines @@
 
   if (input.checked)
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_CHECKED;
   out->checked = input.checked ? *input.checked : false;
 
   if (input.enabled)
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_ENABLED;
   out->enabled = input.enabled ? *input.enabled : true;
 }
 
-static void DispatchEventToExtension(Profile* profile,
-                                     const std::string& extension_id,
+static void DispatchEventToExtension(const std::string& extension_id,
                                      const std::string& event_name,
                                      scoped_ptr<base::ListValue> args) {
+  Profile* profile = ProfileManager::GetActiveUserProfile();
   scoped_ptr<extensions::Event> event(new extensions::Event(
       event_name, args.Pass()));
   event->restrict_to_browser_context = profile;
   extensions::EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void CallbackKeyEventHandle(chromeos::input_method::KeyEventHandle* key_data,
                             bool handled) {
   base::Callback<void(bool consumed)>* callback =
       reinterpret_cast<base::Callback<void(bool consumed)>*>(key_data);
   callback->Run(handled);
   delete callback;
 }
 
 }  // namespace
 
 namespace chromeos {
 class ImeObserver : public InputMethodEngineInterface::Observer {
  public:
-  ImeObserver(Profile* profile, const std::string& extension_id)
-      : profile_(profile), extension_id_(extension_id), has_background_(false) {
-    extensions::ExtensionSystem* extension_system =
-        extensions::ExtensionSystem::Get(profile_);
-    ExtensionService* extension_service = extension_system->extension_service();
-    const extensions::Extension* extension =
-        extension_service->GetExtensionById(extension_id, false);
-    DCHECK(extension);
-    extensions::BackgroundInfo* info = static_cast<extensions::BackgroundInfo*>(
-        extension->GetManifestData("background"));
-    if (info)
-      has_background_ = info->has_background_page();
+  explicit ImeObserver(const std::string& extension_id)
+      : extension_id_(extension_id) {
   }
 
   virtual ~ImeObserver() {}
 
   virtual void OnActivate(const std::string& engine_id) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(engine_id));
 
-    DispatchEventToExtension(profile_, extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnActivate::kEventName, args.Pass());
   }
 
   virtual void OnDeactivated(const std::string& engine_id) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnDeactivated::Create(engine_id));
 
-    DispatchEventToExtension(profile_, extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnDeactivated::kEventName, args.Pass());
   }
 
   virtual void OnFocus(
       const InputMethodEngineInterface::InputContext& context) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type = input_ime::InputContext::ParseType(context.type);
 
     scoped_ptr<base::ListValue> args(input_ime::OnFocus::Create(context_value));
 
     // The component IME extensions need to know the current screen type (e.g.
     // lock screen, login screen, etc.) so that its on-screen keyboard page
     // won't open new windows/pages. See crbug.com/395621.
     base::DictionaryValue* val = NULL;
     if (args->GetDictionary(0, &val)) {
       std::string screen_type;
       if (!UserManager::Get()->IsUserLoggedIn()) {
         screen_type = "login";
       } else if (chromeos::ScreenLocker::default_screen_locker() &&
                  chromeos::ScreenLocker::default_screen_locker()->locked()) {
         screen_type = "lock";
       } else if (UserAddingScreen::Get()->IsRunning()) {
         screen_type = "secondary-login";
       }
       if (!screen_type.empty())
         val->SetStringWithoutPathExpansion("screen", screen_type);
     }
 
-    DispatchEventToExtension(profile_, extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnFocus::kEventName, args.Pass());
   }
 
   virtual void OnBlur(int context_id) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
-    DispatchEventToExtension(profile_, extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnBlur::kEventName, args.Pass());
   }
 
   virtual void OnInputContextUpdate(
       const InputMethodEngineInterface::InputContext& context) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type = input_ime::InputContext::ParseType(context.type);
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
-    DispatchEventToExtension(profile_,
-                             extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnInputContextUpdate::kEventName,
                              args.Pass());
   }
 
   virtual void OnKeyEvent(
       const std::string& engine_id,
       const InputMethodEngineInterface::KeyboardEvent& event,
       chromeos::input_method::KeyEventHandle* key_data) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     // If there is no listener for the event, no need to dispatch the event to
     // extension. Instead, releases the key event for default system behavior.
     if (!ShouldForwardKeyEvent()) {
       // Continue processing the key event so that the physical keyboard can
       // still work.
       CallbackKeyEventHandle(key_data, false);
       return;
     }
@@ skipping 12 matching lines @@
     key_data_value.key = event.key;
     key_data_value.code = event.code;
     key_data_value.alt_key.reset(new bool(event.alt_key));
     key_data_value.ctrl_key.reset(new bool(event.ctrl_key));
     key_data_value.shift_key.reset(new bool(event.shift_key));
     key_data_value.caps_lock.reset(new bool(event.caps_lock));
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnKeyEvent::Create(engine_id, key_data_value));
 
-    DispatchEventToExtension(profile_, extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnKeyEvent::kEventName, args.Pass());
   }
 
   virtual void OnCandidateClicked(
       const std::string& engine_id,
       int candidate_id,
       InputMethodEngineInterface::MouseButtonEvent button) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     input_ime::OnCandidateClicked::Button button_enum =
         input_ime::OnCandidateClicked::BUTTON_NONE;
     switch (button) {
       case InputMethodEngineInterface::MOUSE_BUTTON_MIDDLE:
         button_enum = input_ime::OnCandidateClicked::BUTTON_MIDDLE;
         break;
 
       case InputMethodEngineInterface::MOUSE_BUTTON_RIGHT:
         button_enum = input_ime::OnCandidateClicked::BUTTON_RIGHT;
         break;
 
       case InputMethodEngineInterface::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         button_enum = input_ime::OnCandidateClicked::BUTTON_LEFT;
         break;
     }
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnCandidateClicked::Create(engine_id,
                                               candidate_id,
                                               button_enum));
 
-    DispatchEventToExtension(profile_,
-                             extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnCandidateClicked::kEventName,
                              args.Pass());
   }
 
   virtual void OnMenuItemActivated(const std::string& engine_id,
                                    const std::string& menu_id) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(engine_id, menu_id));
 
-    DispatchEventToExtension(profile_,
-                             extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnMenuItemActivated::kEventName,
                              args.Pass());
   }
 
   virtual void OnSurroundingTextChanged(const std::string& engine_id,
                                         const std::string& text,
                                         int cursor_pos,
                                         int anchor_pos) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     input_ime::OnSurroundingTextChanged::SurroundingInfo info;
     info.text = text;
     info.focus = cursor_pos;
     info.anchor = anchor_pos;
     scoped_ptr<base::ListValue> args(
         input_ime::OnSurroundingTextChanged::Create(engine_id, info));
 
-    DispatchEventToExtension(profile_,
-                             extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnSurroundingTextChanged::kEventName,
                              args.Pass());
   }
 
   virtual void OnReset(const std::string& engine_id) OVERRIDE {
-    if (profile_ == NULL || extension_id_.empty())
+    if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(engine_id));
 
-    DispatchEventToExtension(profile_,
-                             extension_id_,
+    DispatchEventToExtension(extension_id_,
                              input_ime::OnReset::kEventName,
                              args.Pass());
   }
 
  private:
   // Returns true if the extension is ready to accept key event, otherwise
   // returns false.
   bool ShouldForwardKeyEvent() const {
     // Need to check the background page first since the
     // ExtensionHasEventListner returns true if the extension does not have a
     // background page. See crbug.com/394682.
-    return has_background_ && extensions::EventRouter::Get(profile_)
+    return extensions::EventRouter::Get(ProfileManager::GetActiveUserProfile())
         ->ExtensionHasEventListener(extension_id_,
                                     input_ime::OnKeyEvent::kEventName);
   }
 
-  Profile* profile_;
   std::string extension_id_;
-  bool has_background_;
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserver);
 };
 
 }  // namespace chromeos
 
 namespace extensions {
 
 InputImeEventRouter*
 InputImeEventRouter::GetInstance() {
   return Singleton<InputImeEventRouter>::get();
 }
 
-bool InputImeEventRouter::RegisterIme(
+bool InputImeEventRouter::RegisterImeExtension(
     const std::string& extension_id,
-    const extensions::InputComponentInfo& component) {
+    const std::vector<extensions::InputComponentInfo>& input_components) {
 #if defined(USE_X11)
-  VLOG(1) << "RegisterIme: " << extension_id << " id: " << component.id;
+  VLOG(1) << "RegisterImeExtension: " << extension_id;
 
-  Profile* profile = ProfileManager::GetActiveUserProfile();
-  // Avoid potential mem leaks due to duplicated component IDs.
-  if (!profile_engine_map_[profile][extension_id][component.id]) {
-    std::vector<std::string> layouts;
-    layouts.assign(component.layouts.begin(), component.layouts.end());
+  if (engine_map_[extension_id])
+    return false;
 
-    std::vector<std::string> languages;
-    languages.assign(component.languages.begin(), component.languages.end());
+  chromeos::input_method::InputMethodManager* manager =
+      chromeos::input_method::InputMethodManager::Get();
+  chromeos::ComponentExtensionIMEManager* comp_ext_ime_manager =
+      manager->GetComponentExtensionIMEManager();
 
-    // Ideally Observer should be per (extension_id + Profile), and multiple
-    // InputMethodEngine can share one Observer. But it would become tricky
-    // to maintain an internal map for observers which does nearly nothing
-    // but just make sure they can properly deleted.
-    // Making Obesrver per InputMethodEngine can make things cleaner.
-    scoped_ptr<chromeos::InputMethodEngineInterface::Observer> observer(
-        new chromeos::ImeObserver(profile, extension_id));
-    chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
-    engine->Initialize(observer.Pass(),
-                       component.name.c_str(),
-                       extension_id.c_str(),
-                       component.id.c_str(),
-                       languages,
-                       layouts,
-                       component.options_page_url,
-                       component.input_view_url);
-    profile_engine_map_[profile][extension_id][component.id] = engine;
+  chromeos::input_method::InputMethodDescriptors descriptors;
+  // Only creates descriptors for 3rd party IME extension, because the
+  // descriptors for component IME extensions are managed by InputMethodUtil.
+  if (!comp_ext_ime_manager->IsWhitelistedExtension(extension_id)) {
+    for (std::vector<extensions::InputComponentInfo>::const_iterator it =
+         input_components.begin(); it != input_components.end(); ++it) {
+      const extensions::InputComponentInfo& component = *it;
+      DCHECK(component.type == extensions::INPUT_COMPONENT_TYPE_IME);
+
+      std::vector<std::string> layouts;
+      layouts.assign(component.layouts.begin(), component.layouts.end());
+      std::vector<std::string> languages;
+      languages.assign(component.languages.begin(), component.languages.end());
+
+      std::string input_method_id =
+          chromeos::extension_ime_util::GetInputMethodID(
+              extension_id, component.id);
+      descriptors.push_back(chromeos::input_method::InputMethodDescriptor(
+          input_method_id,
+          component.name,
+          std::string(), // TODO(uekawa): Set short name.
+          layouts,
+          languages,
+          false,  // 3rd party IMEs are always not for login.
+          component.options_page_url,
+          component.input_view_url));
+    }
   }
 
+  scoped_ptr<chromeos::InputMethodEngineInterface::Observer> observer(
+      new chromeos::ImeObserver(extension_id));
+  chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
+  engine->Initialize(observer.Pass(), extension_id.c_str());
+  engine_map_[extension_id] = engine;
+  manager->AddInputMethodExtension(extension_id, descriptors, engine);
+
   return true;
 #else
   // TODO(spang): IME support under ozone.
   NOTIMPLEMENTED();
   return false;
 #endif
 }
 
 void InputImeEventRouter::UnregisterAllImes(const std::string& extension_id) {
-  Profile* profile = ProfileManager::GetActiveUserProfile();
-  ProfileEngineMap::iterator extension_map =
-      profile_engine_map_.find(profile);
-  if (extension_map == profile_engine_map_.end())
-    return;
-  ExtensionMap::iterator engine_map = extension_map->second.find(extension_id);
-  if (engine_map == extension_map->second.end())
-    return;
-  STLDeleteContainerPairSecondPointers(engine_map->second.begin(),
-                                       engine_map->second.end());
-  extension_map->second.erase(extension_id);
-  profile_engine_map_.erase(profile);
+  if (engine_map_.find(extension_id) != engine_map_.end()) {
+    chromeos::input_method::InputMethodManager::Get()
+        ->RemoveInputMethodExtension(extension_id);
+    delete engine_map_[extension_id];
+    engine_map_.erase(extension_id);
+  }
 }
 
 InputMethodEngineInterface* InputImeEventRouter::GetEngine(
     const std::string& extension_id, const std::string& engine_id) {
-  // IME can only work on active user profile.
-  Profile* profile = ProfileManager::GetActiveUserProfile();
-
-  ProfileEngineMap::const_iterator extension_map =
-      profile_engine_map_.find(profile);
-  if (extension_map == profile_engine_map_.end())
-    return NULL;
-  ExtensionMap::const_iterator engine_map =
-      extension_map->second.find(extension_id);
-  if (engine_map == extension_map->second.end())
-    return NULL;
-  EngineMap::const_iterator engine = engine_map->second.find(engine_id);
-  if (engine == engine_map->second.end())
-    return NULL;
-  return engine->second;
+  if (engine_map_.find(extension_id) != engine_map_.end()) {

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

nit: it is totally up to you but I prefer

if (engine_map_.find(extension_id) != engine_map_.end() &&
  engine_map_[extension_id]->GetActiveEngineId() == engine_id)
  return engine_map_[extension_id];
else
  return NULL;

or

if (engine_map_.find(extension_id) == engine_map_.end())
  return NULL;

if (engine_map_[extension_id]->GetActiveEngineId() == engine _id)
  return engine_map_[extension_id];

return NULL;

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

Done.

+    if (engine_map_[extension_id]->GetActiveEngineId() == engine_id)
+      return engine_map_[extension_id];
+  }
+  return NULL;
 }
 
 InputMethodEngineInterface* InputImeEventRouter::GetActiveEngine(
     const std::string& extension_id) {
-  // IME can only work on active user profile.
-  Profile* profile = ProfileManager::GetActiveUserProfile();
-
-  ProfileEngineMap::const_iterator extension_map =
-      profile_engine_map_.find(profile);
-  if (extension_map == profile_engine_map_.end())
-    return NULL;
-  ExtensionMap::const_iterator engine_map =
-      extension_map->second.find(extension_id);
-  if (engine_map == extension_map->second.end())
-    return NULL;
-
-  for (EngineMap::const_iterator i = engine_map->second.begin();
-       i != engine_map->second.end();
-       ++i) {
-    if (i->second->IsActive())
-      return i->second;
+  if (engine_map_.find(extension_id) != engine_map_.end()) {

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

same as above.

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

Done.

+    if (engine_map_[extension_id]->IsActive())
+      return engine_map_[extension_id];
   }
   return NULL;
 }
 
 void InputImeEventRouter::OnKeyEventHandled(
     const std::string& extension_id,
     const std::string& request_id,
     bool handled) {
   RequestMap::iterator request = request_map_.find(request_id);
   if (request == request_map_.end()) {
@@ skipping 364 matching lines @@
   InputImeEventRouter::GetInstance()->OnKeyEventHandled(
       extension_id(), params->request_id, params->response);
   return true;
 }
 
 InputImeAPI::InputImeAPI(content::BrowserContext* context)
     : browser_context_(context), extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 
   EventRouter* event_router = EventRouter::Get(browser_context_);
-  event_router->RegisterObserver(this, input_ime::OnActivate::kEventName);
   event_router->RegisterObserver(this, input_ime::OnFocus::kEventName);
 }
 
 InputImeAPI::~InputImeAPI() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<InputImeAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<InputImeAPI>* InputImeAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
                                     const Extension* extension) {
   const std::vector<InputComponentInfo>* input_components =
       extensions::InputComponents::GetInputComponents(extension);
-  if (!input_components)
-    return;
-  for (std::vector<extensions::InputComponentInfo>::const_iterator component =
-           input_components->begin();
-       component != input_components->end();
-       ++component) {
-    if (component->type == extensions::INPUT_COMPONENT_TYPE_IME) {
-      // Don't pass profile_ to register ime, instead always use
-      // GetActiveUserProfile. It is because:
-      // The original profile for login screen is called signin profile.
-      // And the active profile is the incognito profile based on signin
-      // profile. So if |profile_| is signin profile, we need to make sure
-      // the router/observer runs under its incognito profile, because the
-      // component extensions were installed under its incognito profile.
-      input_ime_event_router()->RegisterIme(extension->id(), *component);
-    }
-  }
+  if (input_components)
+    input_ime_event_router()->RegisterImeExtension(
+        extension->id(), *input_components);
 }
 
 void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   const std::vector<InputComponentInfo>* input_components =
       extensions::InputComponents::GetInputComponents(extension);
   if (!input_components)
     return;
   if (input_components->size() > 0)
     input_ime_event_router()->UnregisterAllImes(extension->id());
 }
 
 void InputImeAPI::OnListenerAdded(const EventListenerInfo& details) {
   InputMethodEngineInterface* engine =
       input_ime_event_router()->GetActiveEngine(details.extension_id);
+  // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
-    engine->NotifyImeReady();
+    engine->Enable(engine->GetActiveEngineId());
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions