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

chrome/browser/extensions/event_router.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/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 121 matching lines @@
     }
   }
 }
 
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* profile_id,
                                            const std::string& extension_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
-                                           const GURL& event_url,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
   if (ActivityLog::IsLogEnabled()) {
     LogExtensionEventMessage(profile_id, extension_id, event_name,
                              scoped_ptr<ListValue>(event_args->DeepCopy()));
   }
 
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
-  ipc_sender->Send(new ExtensionMsg_MessageInvoke(MSG_ROUTING_CONTROL,
-      extension_id, kDispatchEvent, args, event_url,
+  ipc_sender->Send(new ExtensionMsg_MessageInvoke(
+      MSG_ROUTING_CONTROL,
+      extension_id,
+      kDispatchEvent,
+      args,
       user_gesture == USER_GESTURE_ENABLED));
 
   // DispatchExtensionMessage does _not_ take ownership of event_args, so we
   // must ensure that the destruction of args does not attempt to free it.
   Value* removed_event_args = NULL;
   args.Remove(1, &removed_event_args);
 }
 
 // static
 void EventRouter::DispatchEvent(IPC::Sender* ipc_sender,
                                 void* profile_id,
                                 const std::string& extension_id,
                                 const std::string& event_name,
                                 scoped_ptr<ListValue> event_args,
-                                const GURL& event_url,
                                 UserGestureState user_gesture,
                                 const EventFilteringInfo& info) {
   DispatchExtensionMessage(ipc_sender, profile_id, extension_id, event_name,
-                           event_args.get(), event_url, user_gesture, info);
+                           event_args.get(), user_gesture, info);
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&EventRouter::IncrementInFlightEventsOnUI,
                   profile_id,
                   extension_id));
 }
 
 EventRouter::EventRouter(Profile* profile, ExtensionPrefs* extension_prefs)
@@ skipping 413 matching lines @@
       process->GetBrowserContext());
   ProcessMap* process_map = ExtensionSystem::Get(listener_profile)->
       extension_service()->process_map();
   // If the event is privileged, only send to extension processes. Otherwise,
   // it's OK to send to normal renderers (e.g., for content scripts).
   if (ExtensionAPI::GetSharedInstance()->IsPrivileged(event->event_name) &&
       !process_map->Contains(extension->id(), process->GetID())) {
     return;
   }
 
+  // If the event is restricted to a URL, only dispatch if the extension has
+  // permission for it (or if the event originated from itself).
+  if (!event->event_url.is_empty() &&
+      event->event_url.host() != extension->id() &&
+      !extension->GetActivePermissions()->HasEffectiveAccessToURL(
+          event->event_url)) {
+    return;
+  }
+
   if (!CanDispatchEventToProfile(listener_profile, extension, event))
     return;
 
   if (!event->will_dispatch_callback.is_null()) {
     event->will_dispatch_callback.Run(listener_profile, extension,
                                       event->event_args.get());
   }
 
-  DispatchExtensionMessage(process, listener_profile, extension_id,
+  DispatchExtensionMessage(process, listener_profile, extension->id(),
                            event->event_name, event->event_args.get(),
-                           event->event_url, event->user_gesture,
-                           event->filter_info);
+                           event->user_gesture, event->filter_info);
   IncrementInFlightEvents(listener_profile, extension);
 }
 
 bool EventRouter::CanDispatchEventToProfile(Profile* profile,
                                             const Extension* extension,
                                             const linked_ptr<Event>& event) {
   // Is this event from a different profile than the renderer (ie, an
   // incognito tab event sent to a normal process, or vice versa).
   bool cross_incognito =
       event->restrict_to_profile && profile != event->restrict_to_profile;
@@ skipping 224 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions