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

chrome/browser/extensions/extension_message_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_MESSAGE_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_MESSAGE_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 22 matching lines @@
   static ExtensionMessageService* GetInstance(URLRequestContext* context);
 
   ExtensionMessageService();
 
   // --- UI thread only:
 
   // Register an extension and its corresponding renderer process.
   void RegisterExtension(const std::string& extension_id,
                          int render_process_id);
 
+  // Add or remove |render_process_pid| as a listener for |event_name|.
+  void AddEventListener(std::string event_name, int render_process_id);
+  void RemoveEventListener(std::string event_name, int render_process_id);
+
   // --- IO thread only:
 
   // Given an extension's ID, opens a channel between the given renderer "port"
   // and that extension.  Returns a channel ID to be used for posting messages
   // between the processes, or -1 if the extension doesn't exist.
   int OpenChannelToExtension(const std::string& extension_id,
                              ResourceMessageFilter* source);
 
   // Sends a message from a renderer to the given port.
   void PostMessageFromRenderer(int port_id, const std::string& message,
@@ skipping 16 matching lines @@
  private:
   // A map of extension ID to the render_process_id that the extension lives in.
   typedef std::map<std::string, int> ProcessIDMap;
   ProcessIDMap process_ids_;
 
   // Protects the process_ids map, since it can be accessed on the IO thread
   // or UI thread.  Be careful not to hold this lock when calling external
   // code (especially sending messages) to avoid deadlock.
   Lock process_ids_lock_;
 
+  // A map between an event name and a set of process id's that are listening
+  // to that event.
+  typedef std::map<std::string, std::set<int> > ListenerMap;
+  ListenerMap listeners_;
+
+  // Protects listeners_ map, since it can be accessed from either the IO or
+  // UI thread.  Be careful not to hold this lock when calling external code
+  // (especially sending messages) to avoid deadlock.
+  Lock listener_lock_;
+
   // --- IO thread only:
 
   // The connection between two renderers.
   struct MessageChannel {
     ResourceMessageFilter* port1;
     ResourceMessageFilter* port2;
   };
 
   // A map of channel ID to its channel object.
   typedef std::map<int, MessageChannel> MessageChannelMap;
   MessageChannelMap channels_;
 
   // For generating unique channel IDs.
   int next_port_id_;
 
   // A map of render_process_id to its corresponding message filter, which we
   // use for sending messages.
   typedef std::map<int, ResourceMessageFilter*> RendererMap;
   RendererMap renderers_;
 
   // A unique list of renderers that we are aware of.
   std::set<ResourceMessageFilter*> renderers_unique_;
 
   // Set to true when we start observing this notification.
   bool observing_renderer_shutdown_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionMessageService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_MESSAGE_SERVICE_H_