For suspended IME extension (e.g. XKB extension), don't awake it by IME events except onActivate. T…

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/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.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 "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/browser/process_manager.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
 #include "ui/base/ime/chromeos/extension_ime_util.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 
 namespace input_ime = extensions::api::input_ime;
 namespace KeyEventHandled = extensions::api::input_ime::KeyEventHandled;
 namespace DeleteSurroundingText =
     extensions::api::input_ime::DeleteSurroundingText;
 namespace UpdateMenuItems = extensions::api::input_ime::UpdateMenuItems;
@@ skipping 42 matching lines @@
 
   if (input.enabled)
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_ENABLED;
   out->enabled = input.enabled ? *input.enabled : true;
 }
 
 static void DispatchEventToExtension(const std::string& extension_id,
                                      const std::string& event_name,
                                      scoped_ptr<base::ListValue> args) {
   Profile* profile = ProfileManager::GetActiveUserProfile();
+  if (event_name != input_ime::OnActivate::kEventName) {
+    // For suspended IME extension (e.g. XKB extension), don't awake it by IME

[Seigo Nonaka, 2015/01/29 09:11:29]

I'm sorry but "suspended IME" and its example is not clear for me.

IIRC, there four state in extension IMEs:
1. not installed.
2. installed but not enabled(not checked by user in settings page)
3. enabled but not activated(listed in system tray but the indicator is
different from this).
4. active.

Looks like the suspended IMEs are 3., right?
If so, please write like as,

For the IMEs which enabled but not activated, don't awake it by IME ...

[Shu Chen, 2015/01/30 14:38:29]

"suspend" means the extension background is killed by extension system for
"event page":
https://developer.chrome.com/extensions/event_pages
The logic here is to make sure once an IME extension background is killed, it
should not be awaken by IME API events, until a listened non-IME-API event
arrives.

[Seigo Nonaka, 2015/02/02 00:56:38]

Oh, I didn't know extension background page can be suspended.

Then, I have another questions.

1. Does this function is called only for IME event? Looks like all event except
for OnActivate  will be ignored, is it correct?

2. Also, no need to call other events? IIRC, extension suspension can happen at
any time, so looks like need to dispatch all event if the IME is activated.

+    // events except onActivate. The IME extension should be awake by other
+    // events (e.g. runtime.onMessage) from its other pages.
+    // This is to save memory for steady state Chrome OS on which the users
+    // don't want any IME features.
+    extensions::ExtensionSystem* extension_system =
+        extensions::ExtensionSystem::Get(profile);
+    if (extension_system) {
+      const extensions::Extension* extension =
+          extension_system->extension_service()->GetExtensionById(
+              extension_id, false /* include_disabled */);
+      extensions::ProcessManager* process_manager =
+          extensions::ProcessManager::Get(profile);
+      if (extensions::BackgroundInfo::HasBackgroundPage(extension) &&
+          !process_manager->GetBackgroundHostForExtension(extension_id)) {
+        return;
+      }
+    }
+  }
+
   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 =
@@ skipping 810 matching lines @@
   // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
     engine->Enable(engine->GetActiveComponentId());
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions