Remove deprecated extension EventRouter APIs.

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/json/json_writer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 107 matching lines @@
 
       if (!ReadMenuItems(sub_list, &(output->back().children))) {
         return false;
       }
     }
   }
 
   return true;
 }
 
+static void DispatchEventToExtension(Profile* profile,
+                                     const std::string& extension_id,
+                                     const std::string& event_name,
+                                     scoped_ptr<ListValue> args) {
+  scoped_ptr<extensions::Event> event(new extensions::Event(
+      event_name, args.Pass()));
+  event->restrict_to_profile = profile;
+  extensions::ExtensionSystem::Get(profile)->event_router()->
+      DispatchEventToExtension(extension_id, event.Pass());
+}
+
 }  // namespace
 
 namespace events {
 
 const char kOnActivate[] = "input.ime.onActivate";
 const char kOnDeactivated[] = "input.ime.onDeactivated";
 const char kOnFocus[] = "input.ime.onFocus";
 const char kOnBlur[] = "input.ime.onBlur";
 const char kOnInputContextUpdate[] = "input.ime.onInputContextUpdate";
 const char kOnKeyEvent[] = "input.ime.onKeyEvent";
@@ skipping 14 matching lines @@
 
   virtual ~ImeObserver() {}
 
   virtual void OnActivate(const std::string& engine_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(Value::CreateStringValue(engine_id));
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnActivate,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnActivate, args.Pass());
   }
 
   virtual void OnDeactivated(const std::string& engine_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(Value::CreateStringValue(engine_id));
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnDeactivated,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnDeactivated, args.Pass());
   }
 
   virtual void OnFocus(
       const InputMethodEngine::InputContext& context) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger("contextID", context.id);
     dict->SetString("type", context.type);
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(dict);
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnFocus,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnFocus, args.Pass());
   }
 
   virtual void OnBlur(int context_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(Value::CreateIntegerValue(context_id));
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnBlur,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnBlur, args.Pass());
   }
 
   virtual void OnInputContextUpdate(
       const InputMethodEngine::InputContext& context) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger("contextID", context.id);
     dict->SetString("type", context.type);
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(dict);
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnInputContextUpdate,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnInputContextUpdate, args.Pass());
   }
 
   virtual void OnKeyEvent(
       const std::string& engine_id,
       const InputMethodEngine::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);
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("type", event.type);
     dict->SetString("requestId", request_id);
     dict->SetString("key", event.key);
     dict->SetBoolean("altKey", event.alt_key);
     dict->SetBoolean("ctrlKey", event.ctrl_key);
     dict->SetBoolean("shiftKey", event.shift_key);
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(Value::CreateStringValue(engine_id));
     args->Append(dict);
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnKeyEvent,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnKeyEvent, args.Pass());
   }
 
   virtual void OnCandidateClicked(
       const std::string& engine_id,
       int candidate_id,
       chromeos::InputMethodEngine::MouseButtonEvent button) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(Value::CreateStringValue(engine_id));
     args->Append(Value::CreateIntegerValue(candidate_id));
     switch (button) {
       case chromeos::InputMethodEngine::MOUSE_BUTTON_MIDDLE:
         args->Append(Value::CreateStringValue("middle"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_RIGHT:
         args->Append(Value::CreateStringValue("right"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         args->Append(Value::CreateStringValue("left"));
         break;
     }
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnCandidateClicked,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnCandidateClicked, args.Pass());
   }
 
   virtual void OnMenuItemActivated(const std::string& engine_id,
                                    const std::string& menu_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new ListValue());
     args->Append(Value::CreateStringValue(engine_id));
     args->Append(Value::CreateStringValue(menu_id));
 
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        DispatchEventToExtension(extension_id_, events::kOnMenuItemActivated,
-                                 args.Pass(), profile_, GURL());
+    DispatchEventToExtension(profile_, extension_id_,
+                             events::kOnMenuItemActivated, args.Pass());
   }
 
  private:
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserver);
 };
 
@@ skipping 522 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &handled));
 
   InputImeEventRouter::GetInstance()->OnKeyEventHandled(
       extension_id(), request_id_str, handled);
 
   return true;
 }
 #endif
 
 }  // namespace extensions