[IME] Releases key events to default handler if no handler in the active IME extension.

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/chrome_notification_types.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
@@ skipping 146 matching lines @@
                              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())
       return;
 
-    std::string request_id =
-        extensions::InputImeEventRouter::GetInstance()->AddRequest(engine_id,
-                                                                   key_data);
+    extensions::InputImeEventRouter* ime_event_router =
+        extensions::InputImeEventRouter::GetInstance();
+
+    const std::string request_id =
+        ime_event_router->AddRequest(engine_id, key_data);
+
+    // 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()) {
+      ime_event_router->OnKeyEventHandled(extension_id_, request_id, false);
+      return;
+    }
 
     input_ime::KeyboardEvent key_data_value;
     key_data_value.type = input_ime::KeyboardEvent::ParseType(event.type);
     key_data_value.request_id = request_id;
     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));
@@ skipping 81 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::ExtensionSystem::Get(profile_)
+        ->event_router()
+        ->ExtensionHasEventListener(extension_id_,
+                                    input_ime::OnKeyEvent::kEventName);
+  }
+
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserver);
 };
 
 }  // namespace chromeos
 
 namespace extensions {
@@ skipping 526 matching lines @@
     if (input_components->size() > 0)
       input_ime_event_router()->UnregisterAllImes(profile_, extension->id());
   }
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions