Only send events to renderers that are listening to an event....

chrome/browser/extensions/extension_message_service.cc

 // Copyright (c) 2009 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/extension_message_service.h"
 
 #include "base/singleton.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extension.h"
@@ skipping 46 matching lines @@
   }
   return instance;
 }
 
 ExtensionMessageService::ExtensionMessageService()
     : next_port_id_(0), observing_renderer_shutdown_(false) {
 }
 
 void ExtensionMessageService::RegisterExtension(
     const std::string& extension_id, int render_process_id) {
+  DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
   AutoLock lock(process_ids_lock_);
   DCHECK(process_ids_.find(extension_id) == process_ids_.end() ||
          process_ids_[extension_id] == render_process_id);
   process_ids_[extension_id] = render_process_id;
 }
 
+void ExtensionMessageService::AddEventListener(std::string event_name,
+                                               int render_process_id) {
+  DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
+  AutoLock lock(listener_lock_);
+  DCHECK(listeners_[event_name].count(render_process_id) == 0);
+  listeners_[event_name].insert(render_process_id);
+}
+
+void ExtensionMessageService::RemoveEventListener(std::string event_name,
+                                                  int render_process_id) {
+  DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
+  AutoLock lock(listener_lock_);
+  DCHECK(listeners_[event_name].count(render_process_id) == 1);
+  listeners_[event_name].erase(render_process_id);
+}
+
 int ExtensionMessageService::OpenChannelToExtension(
     const std::string& extension_id, ResourceMessageFilter* source) {
   DCHECK(MessageLoop::current() ==
          ChromeThread::GetMessageLoop(ChromeThread::IO));
 
   // Lookup the targeted extension process.
   int process_id;
   {
     AutoLock lock(process_ids_lock_);
     ProcessIDMap::iterator process_id_it = process_ids_.find(
@@ skipping 48 matching lines @@
     dest = channel.port2;
     DCHECK(source == channel.port1);
   }
 
   int source_port_id = GET_OPPOSITE_PORT_ID(port_id);
   dest->Send(new ViewMsg_ExtensionHandleMessage(message, source_port_id));
 }
 
 void ExtensionMessageService::DispatchEventToRenderers(
     const std::string& event_name, const std::string& event_args) {
+  std::set<int> pids;
+  {
+    AutoLock lock(listener_lock_);
+    pids = listeners_[event_name];
+    if (pids.empty())
+      return;
+  }
   MessageLoop* io_thread = ChromeThread::GetMessageLoop(ChromeThread::IO);
   if (MessageLoop::current() != io_thread) {
     // Do the actual work on the IO thread.
     io_thread->PostTask(FROM_HERE, NewRunnableMethod(this,
         &ExtensionMessageService::DispatchEventToRenderers,
         event_name, event_args));
     return;
   }
 
-  // TODO(mpcomplete): we should only send messages to extension process
-  // renderers.
-  std::set<ResourceMessageFilter*>::iterator renderer;
-  for (renderer = renderers_unique_.begin();
-       renderer != renderers_unique_.end(); ++renderer) {
-    (*renderer)->Send(new ViewMsg_ExtensionHandleEvent(event_name, event_args));
+  // Send the event only to renderers that are listening for it.
+  for (std::set<int>::iterator pid = pids.begin(); pid != pids.end(); ++pid) {
+    RendererMap::iterator renderer = renderers_.find(*pid);
+    if (renderer == renderers_.end())
+      continue;
+    ResourceMessageFilter* filter = renderer->second;
+    filter->Send(new ViewMsg_ExtensionHandleEvent(event_name, event_args));
   }
 }
 
 void ExtensionMessageService::RendererReady(ResourceMessageFilter* renderer) {
   DCHECK(MessageLoop::current() ==
-       ChromeThread::GetMessageLoop(ChromeThread::IO));
+         ChromeThread::GetMessageLoop(ChromeThread::IO));
 
   DCHECK(renderers_.find(renderer->GetProcessId()) == renderers_.end());
   renderers_[renderer->GetProcessId()] = renderer;
   renderers_unique_.insert(renderer);
 
   if (!observing_renderer_shutdown_) {
     observing_renderer_shutdown_ = true;
     NotificationService::current()->AddObserver(
         this,
         NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN,
         NotificationService::AllSources());
   }
 }
 
 void ExtensionMessageService::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   DCHECK(MessageLoop::current() ==
-       ChromeThread::GetMessageLoop(ChromeThread::IO));
+         ChromeThread::GetMessageLoop(ChromeThread::IO));
 
   DCHECK(type.value == NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN);
   ResourceMessageFilter* renderer = Source<ResourceMessageFilter>(source).ptr();
 
   renderers_.erase(renderer->GetProcessId());
   renderers_unique_.erase(renderer);
 
   // Close any channels that share this renderer.
   // TODO(mpcomplete): should we notify the other side of the port?
   for (MessageChannelMap::iterator it = channels_.begin();
        it != channels_.end(); ) {
     MessageChannelMap::iterator current = it++;
     if (current->second.port1 == renderer || current->second.port2 == renderer)
       channels_.erase(current);
   }
 }