Checks whether background is defined in IME extension manifest. And also move KeyEventDone logic fr…

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/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/common/manifest_handlers/background_info.h"
 
 #if defined(USE_X11)
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #endif
 
 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 47 matching lines @@
                                      const std::string& extension_id,
                                      const std::string& event_name,
                                      scoped_ptr<base::ListValue> args) {
   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) {}
+      : 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();
+  }
 
   virtual ~ImeObserver() {}
 
   virtual void OnActivate(const std::string& engine_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(engine_id));
 
     DispatchEventToExtension(profile_, extension_id_,
@@ skipping 59 matching lines @@
       const InputMethodEngineInterface::KeyboardEvent& event,
       chromeos::input_method::KeyEventHandle* key_data) OVERRIDE {
     if (profile_ == NULL || 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 (!HasKeyEventListener()) {
       // Continue processing the key event so that the physical keyboard can
       // still work.
-      base::Callback<void(bool consumed)>* callback =
-          reinterpret_cast<base::Callback<void(bool consumed)>*>(key_data);
-      callback->Run(false);
-      delete callback;
+      CallbackKeyEventHandle(key_data, false);
       return;
     }
 
     extensions::InputImeEventRouter* ime_event_router =
         extensions::InputImeEventRouter::GetInstance();
 
     const std::string request_id =
         ime_event_router->AddRequest(engine_id, key_data);
 
     input_ime::KeyboardEvent key_data_value;
@@ skipping 92 matching lines @@
     scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(engine_id));
 
     DispatchEventToExtension(profile_,
                              extension_id_,
                              input_ime::OnReset::kEventName,
                              args.Pass());
   }
 
  private:
   bool HasKeyEventListener() const {
-    return extensions::EventRouter::Get(profile_)
+    return has_background_ && extensions::EventRouter::Get(profile_)

[nona, 2014/07/17 08:43:15]

Could you elaborate a bit more about this logic? Perhaps good to rename this
method to "ShouldForwardKeyEvent" and add comment like as follows:

// Returns true if the extension is ready to accept key event,
// otherwise returns false.

and also good to add comment in method body:

// Need to check the background page first since  the 
// ExtensionHasEventListner returns true if the extension does
// not have a background page.

[Shu Chen, 2014/07/17 09:24:14]

Done.

         ->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() {
@@ skipping 106 matching lines @@
   RequestMap::iterator request = request_map_.find(request_id);
   if (request == request_map_.end()) {
     LOG(ERROR) << "Request ID not found: " << request_id;
     return;
   }
 
   std::string engine_id = request->second.first;
   chromeos::input_method::KeyEventHandle* key_data = request->second.second;
   request_map_.erase(request);
 
-  InputMethodEngineInterface* engine = GetEngine(extension_id, engine_id);
-  if (!engine) {
-    LOG(ERROR) << "Engine does not exist: " << engine_id;
-    return;
-  }
-
-  engine->KeyEventDone(key_data, handled);
+  CallbackKeyEventHandle(key_data, handled);
 }
 
 std::string InputImeEventRouter::AddRequest(
     const std::string& engine_id,
     chromeos::input_method::KeyEventHandle* key_data) {
   std::string request_id = base::IntToString(next_request_id_);
   ++next_request_id_;
 
   request_map_[request_id] = std::make_pair(engine_id, key_data);
 
@@ skipping 407 matching lines @@
       input_ime_event_router()->GetActiveEngine(details.extension_id);
   if (engine)
     engine->NotifyImeReady();
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions