Remove the event URL security check out of the renderer and into the browser.

chrome/renderer/extensions/dispatcher.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/renderer/extensions/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
@@ skipping 534 matching lines @@
 }
 
 void Dispatcher::OnSetChannel(int channel) {
   Feature::SetCurrentChannel(
       static_cast<chrome::VersionInfo::Channel>(channel));
 }
 
 void Dispatcher::OnMessageInvoke(const std::string& extension_id,
                                  const std::string& function_name,
                                  const base::ListValue& args,
-                                 const GURL& event_url,
                                  bool user_gesture) {
   scoped_ptr<WebScopedUserGesture> web_user_gesture;
   if (user_gesture) {
     web_user_gesture.reset(new WebScopedUserGesture);
   }
 
   v8_context_set_.DispatchChromeHiddenMethod(
-      extension_id, function_name, args, NULL, event_url);
+      extension_id, function_name, args, NULL);
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch, for which Invoke is the chokepoint.
   if (is_extension_process_) {
     RenderThread::Get()->ScheduleIdleHandler(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   // Tell the browser process when an event has been dispatched with a lazy
   // background page active.
@@ skipping 778 matching lines @@
 void Dispatcher::OnSuspend(const std::string& extension_id) {
   // Dispatch the suspend event. This doesn't go through the standard event
   // dispatch machinery because it requires special handling. We need to let
   // the browser know when we are starting and stopping the event dispatch, so
   // that it still considers the extension idle despite any activity the suspend
   // event creates.
   base::ListValue args;
   args.Set(0, new base::StringValue(kOnSuspendEvent));
   args.Set(1, new base::ListValue());
   v8_context_set_.DispatchChromeHiddenMethod(
-      extension_id, kEventDispatchFunction, args, NULL, GURL());
+      extension_id, kEventDispatchFunction, args, NULL);
 
   RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id));
 }
 
 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   base::ListValue args;
   args.Set(0, new base::StringValue(kOnSuspendCanceledEvent));
   args.Set(1, new base::ListValue());
   v8_context_set_.DispatchChromeHiddenMethod(
-      extension_id, kEventDispatchFunction, args, NULL, GURL());
+      extension_id, kEventDispatchFunction, args, NULL);
 }
 
 Feature::Context Dispatcher::ClassifyJavaScriptContext(
     const std::string& extension_id,
     int extension_group,
     const ExtensionURLInfo& url_info) {
   if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
     return extensions_.Contains(extension_id) ?
         Feature::CONTENT_SCRIPT_CONTEXT : Feature::UNSPECIFIED_CONTEXT;
   }
@@ skipping 76 matching lines @@
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
   return true;
 }
 
 }  // namespace extensions