Final batch adding real histogram values for extension events.

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 94 matching lines @@
 
   void OnActivate(const std::string& component_id) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnActivate::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
         component_id,
         input_ime::ParseScreenType(GetCurrentScreenType())));
 
-    DispatchEventToExtension(input_ime::OnActivate::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_ACTIVATE,
+                             input_ime::OnActivate::kEventName, args.Pass());
   }
 
   void OnDeactivated(const std::string& component_id) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnDeactivated::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnDeactivated::Create(component_id));
 
-    DispatchEventToExtension(input_ime::OnDeactivated::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_DEACTIVATED,
+                             input_ime::OnDeactivated::kEventName, args.Pass());
   }
 
   void OnFocus(
       const InputMethodEngineInterface::InputContext& context) override {
     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::ParseInputContextType(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(input_ime::OnFocus::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_FOCUS,
+                             input_ime::OnFocus::kEventName, args.Pass());
   }
 
   void OnBlur(int context_id) override {
     if (extension_id_.empty() || !HasListener(input_ime::OnBlur::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
-    DispatchEventToExtension(input_ime::OnBlur::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_BLUR,
+                             input_ime::OnBlur::kEventName, args.Pass());
   }
 
   void OnInputContextUpdate(
       const InputMethodEngineInterface::InputContext& context) override {
     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::ParseInputContextType(context.type);
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
-    DispatchEventToExtension(input_ime::OnInputContextUpdate::kEventName,
-                             args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_IME_ON_INPUT_CONTEXT_UPDATE,
+        input_ime::OnInputContextUpdate::kEventName, args.Pass());
   }
 
   bool IsInterestedInKeyEvent() const override {
     return ShouldForwardKeyEvent();
   }
 
   void OnKeyEvent(const std::string& component_id,
                   const InputMethodEngineInterface::KeyboardEvent& event,
                   chromeos::input_method::KeyEventHandle* key_data) override {
     if (extension_id_.empty())
@@ skipping 19 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(component_id, key_data_value));
 
-    DispatchEventToExtension(input_ime::OnKeyEvent::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_KEY_EVENT,
+                             input_ime::OnKeyEvent::kEventName, args.Pass());
   }
 
   void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
       InputMethodEngineInterface::MouseButtonEvent button) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnCandidateClicked::kEventName))
       return;
 
@@ skipping 10 matching lines @@
       case InputMethodEngineInterface::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         button_enum = input_ime::MOUSE_BUTTON_LEFT;
         break;
     }
 
     scoped_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
         component_id, candidate_id, button_enum));
 
-    DispatchEventToExtension(input_ime::OnCandidateClicked::kEventName,
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_CANDIDATE_CLICKED,
+                             input_ime::OnCandidateClicked::kEventName,
                              args.Pass());
   }
 
   void OnMenuItemActivated(const std::string& component_id,
                            const std::string& menu_id) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnMenuItemActivated::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
-    DispatchEventToExtension(input_ime::OnMenuItemActivated::kEventName,
-                             args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_IME_ON_MENU_ITEM_ACTIVATED,
+        input_ime::OnMenuItemActivated::kEventName, args.Pass());
   }
 
   void OnSurroundingTextChanged(const std::string& component_id,
                                 const std::string& text,
                                 int cursor_pos,
                                 int anchor_pos) override {
     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(input_ime::OnSurroundingTextChanged::kEventName,
-                             args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_IME_ON_SURROUNDING_TEXT_CHANGED,
+        input_ime::OnSurroundingTextChanged::kEventName, args.Pass());
   }
 
   void OnCompositionBoundsChanged(
       const std::vector<gfx::Rect>& bounds) override {
     if (extension_id_.empty() ||
         !HasListener(kOnCompositionBoundsChangedEventName))
       return;
 
     // Note: this is a private API event.
     base::ListValue* bounds_list = new base::ListValue();
@@ skipping 10 matching lines @@
       return;
     scoped_ptr<base::ListValue> args(new base::ListValue());
 
     // The old extension code uses the first parameter to get the bounds of the
     // first composition character, so for backward compatibility, add it here.
     base::Value* first_value = NULL;
     if (bounds_list->Get(0, &first_value))
       args->Append(first_value->DeepCopy());
     args->Append(bounds_list);
 
-    DispatchEventToExtension(kOnCompositionBoundsChangedEventName, args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_METHOD_PRIVATE_ON_COMPOSITION_BOUNDS_CHANGED,
+        kOnCompositionBoundsChangedEventName, args.Pass());
   }
 
   void OnReset(const std::string& component_id) override {
     if (extension_id_.empty() || !HasListener(input_ime::OnReset::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(component_id));
 
-    DispatchEventToExtension(input_ime::OnReset::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_RESET,
+                             input_ime::OnReset::kEventName, args.Pass());
   }
 
  private:
-  void DispatchEventToExtension(const std::string& event_name,
-                                scoped_ptr<base::ListValue> args) {
+  void DispatchEventToExtension(
+      extensions::events::HistogramValue histogram_value,
+      const std::string& event_name,
+      scoped_ptr<base::ListValue> args) {
     if (event_name != input_ime::OnActivate::kEventName) {
       // For suspended IME extension (e.g. XKB extension), don't awake it by IME
       // 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 */);
         if (!extension)
           return;
         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(
-        extensions::events::UNKNOWN, event_name, args.Pass()));
+    scoped_ptr<extensions::Event> event(
+        new extensions::Event(histogram_value, event_name, args.Pass()));
     event->restrict_to_browser_context = profile_;
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, event.Pass());
   }
 
   // Returns true if the extension is ready to accept key event, otherwise
   // returns false.
   bool ShouldForwardKeyEvent() const {
     // Only forward key events to extension if there are non-lazy listeners
     // for onKeyEvent. Because if something wrong with the lazy background
@@ skipping 583 matching lines @@
   InputMethodEngineInterface* engine =
       GetInputImeEventRouter(
           Profile::FromBrowserContext(details.browser_context))
           ->GetActiveEngine(details.extension_id);
   // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
     engine->Enable(engine->GetActiveComponentId());
 }
 
 }  // namespace extensions