Support a private event - inputMethodPrivate.onCompositionBoundsChanged so that component IME exten…

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"
@@ skipping 28 matching lines @@
 namespace CommitText = extensions::api::input_ime::CommitText;
 namespace ClearComposition = extensions::api::input_ime::ClearComposition;
 namespace SetComposition = extensions::api::input_ime::SetComposition;
 using chromeos::InputMethodEngineInterface;
 
 namespace {
 
 const char kErrorEngineNotAvailable[] = "Engine is not available";
 const char kErrorSetMenuItemsFail[] = "Could not create menu Items";
 const char kErrorUpdateMenuItemsFail[] = "Could not update menu Items";
+const char kOnCompositionBoundsChangedEventName[] =
+    "inputMethodPrivate.onCompositionBoundsChanged";
 
 void SetMenuItemToMenu(const input_ime::MenuItem& input,
                        InputMethodEngineInterface::MenuItem* out) {
   out->modified = 0;
   out->id = input.id;
   if (input.label) {
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_LABEL;
     out->label = *input.label;
   }
 
@@ skipping 39 matching lines @@
 
 namespace chromeos {
 class ImeObserver : public InputMethodEngineInterface::Observer {
  public:
   explicit ImeObserver(const std::string& extension_id)
       : extension_id_(extension_id) {}
 
   virtual ~ImeObserver() {}
 
   virtual void OnActivate(const std::string& component_id) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(

[Yuki, 2014/10/24 09:52:33]

nit: Better to break at greater level (shallower level) in general.
if (extension_id_.empty() ||
    !HasListener(input_ime::OnActivate::kEventName))

Ditto for the same change below.

[Shu Chen, 2014/10/24 15:38:06]

Done.

+        input_ime::OnActivate::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
         component_id,
         input_ime::OnActivate::ParseScreen(GetCurrentScreenType())));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnActivate::kEventName, args.Pass());
   }
 
   virtual void OnDeactivated(const std::string& component_id) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(
+        input_ime::OnDeactivated::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnDeactivated::Create(component_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnDeactivated::kEventName, args.Pass());
   }
 
   virtual void OnFocus(
       const InputMethodEngineInterface::InputContext& context) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(input_ime::OnFocus::kEventName))
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type = input_ime::InputContext::ParseType(context.type);
     context_value.auto_correct = context.auto_correct;
     context_value.auto_complete = context.auto_complete;
     context_value.spell_check = context.spell_check;
 
     scoped_ptr<base::ListValue> args(input_ime::OnFocus::Create(context_value));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnFocus::kEventName, args.Pass());
   }
 
   virtual void OnBlur(int context_id) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(input_ime::OnBlur::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnBlur::kEventName, args.Pass());
   }
 
   virtual void OnInputContextUpdate(
       const InputMethodEngineInterface::InputContext& context) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(
+        input_ime::OnInputContextUpdate::kEventName))
       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(extension_id_,
@@ skipping 39 matching lines @@
         input_ime::OnKeyEvent::Create(component_id, key_data_value));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnKeyEvent::kEventName, args.Pass());
   }
 
   virtual void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
       InputMethodEngineInterface::MouseButtonEvent button) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(
+        input_ime::OnCandidateClicked::kEventName))
       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(
         component_id, candidate_id, button_enum));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnCandidateClicked::kEventName, args.Pass());
   }
 
   virtual void OnMenuItemActivated(const std::string& component_id,
                                    const std::string& menu_id) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(
+        input_ime::OnMenuItemActivated::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnMenuItemActivated::kEventName, args.Pass());
   }
 
   virtual void OnSurroundingTextChanged(const std::string& component_id,
                                         const std::string& text,
                                         int cursor_pos,
                                         int anchor_pos) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(
+        input_ime::OnSurroundingTextChanged::kEventName))
       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(component_id, info));
 
     DispatchEventToExtension(extension_id_,
                              input_ime::OnSurroundingTextChanged::kEventName,
                              args.Pass());
   }
 
+  virtual void OnCompositionBoundsChanged(const gfx::Rect& bounds) override {
+    if (extension_id_.empty() || !HasListener(
+        kOnCompositionBoundsChangedEventName))
+      return;
+
+    // Note: this is a private API event.
+    scoped_ptr<base::ListValue> args(new base::ListValue());
+    base::DictionaryValue* bounds_value = new base::DictionaryValue();
+    bounds_value->SetInteger("x", bounds.x());
+    bounds_value->SetInteger("y", bounds.y());
+    bounds_value->SetInteger("w", bounds.width());
+    bounds_value->SetInteger("h", bounds.height());
+    args->Append(bounds_value);
+
+    DispatchEventToExtension(extension_id_,
+                             kOnCompositionBoundsChangedEventName,
+                             args.Pass());
+  }
+
   virtual void OnReset(const std::string& component_id) override {
-    if (extension_id_.empty())
+    if (extension_id_.empty() || !HasListener(input_ime::OnReset::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(component_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnReset::kEventName, args.Pass());
   }
 
  private:
   // Returns true if the extension is ready to accept key event, otherwise
@@ skipping 11 matching lines @@
                 input_ime::OnKeyEvent::kEventName);
     for (extensions::EventListenerMap::ListenerList::const_iterator it =
              listener_list.begin();
          it != listener_list.end(); ++it) {
       if ((*it)->extension_id() == extension_id_ && !(*it)->IsLazy())
         return true;
     }
     return false;
   }
 
+  bool HasListener(const std::string& event_name) const {
+    return extensions::EventRouter::Get(
+        ProfileManager::GetActiveUserProfile())->HasEventListener(event_name);
+  }
+
   // 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.
   std::string GetCurrentScreenType() {
     switch (chromeos::input_method::InputMethodManager::Get()
                 ->GetUISessionState()) {
       case chromeos::input_method::InputMethodManager::STATE_LOGIN_SCREEN:
         return "login";
       case chromeos::input_method::InputMethodManager::STATE_LOCK_SCREEN:
         return "lock";
@@ skipping 537 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