Send port-closed notification when a frame with ports unloads....

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 36 matching lines @@
   RenderProcessHost* GetProcessForExtension(const std::string& extension_id);
 
   // 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);
 
-  // Closes an extension channel for test automation.
-  void CloseAutomationChannel(int port_id);
+  // Closes the message channel associated with the given port, and notifies
+  // the other side.
+  void CloseChannel(int port_id);
 
   // Sends a message from a renderer to the given port.
-  // TODO(mpcomplete): include the source tab.
   void PostMessageFromRenderer(int port_id, const std::string& message);
 
   // Send an event to every registered extension renderer.
   void DispatchEventToRenderers(
       const std::string& event_name, const std::string& event_args);
 
-  // NotificationObserver interface.
-  void Observe(NotificationType type,
-               const NotificationSource& source,
-               const NotificationDetails& details);
-
   // Given an extension's ID, opens a channel between the given automation
   // "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 OpenAutomationChannelToExtension(int source_process_id,
                                        int routing_id,
                                        const std::string& extension_id,
                                        IPC::Message::Sender* source);
 
+  // NotificationObserver interface.
+  void Observe(NotificationType type,
+               const NotificationSource& source,
+               const NotificationDetails& details);
+
   // --- 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.
   // This runs on the IO thread so that it can be used in a synchronous IPC
   // message.
   int OpenChannelToExtension(int routing_id, const std::string& extension_id,
                              ResourceMessageFilter* source);
 
  private:
+  // The connection between two ports.  It is possible that both ports
+  // refer to the same renderer.
+  struct MessageChannel {
+    IPC::Message::Sender* port1;
+    IPC::Message::Sender* port2;
+  };
+
+  // A map of channel ID to its channel object.
+  typedef std::map<int, MessageChannel> MessageChannelMap;
+
   // Allocates a pair of port ids.
   // NOTE: this can be called from any thread.
   void AllocatePortIdPair(int* port1, int* port2);
 
   // Gets the process ID for the specified extension.
   // NOTE: this can be called from any thread.
   int GetProcessIdForExtension(const std::string& extension_id);
 
+  void CloseChannelImpl(MessageChannelMap::iterator channel_iter, int port_id);
+
   int OpenChannelToExtensionImpl(const std::string& extension_id,
                                  IPC::Message::Sender* source);
 
   NotificationRegistrar registrar_;
 
   // The UI message loop, used for posting tasks.
   MessageLoop* ui_loop_;
 
   // A map of extension ID to the render_process_id that the extension lives in.
   typedef std::map<std::string, int> ProcessIDMap;
@@ skipping 19 matching lines @@
   void OpenChannelOnUIThread(int source_routing_id,
       int source_port_id, int source_process_id,
       int dest_port_id, int dest_process_id);
 
   // Common between OpenChannelOnUIThread and
   // OpenAutomationChannelToExtension.
   void OpenChannelOnUIThreadImpl(
     int source_routing_id, int source_port_id, IPC::Message::Sender* source,
     int dest_port_id, int dest_process_id, int source_process_id);
 
-  // The connection between two ports.  It is possible that both ports
-  // refer to the same renderer.
-  struct MessageChannel {
-    IPC::Message::Sender* port1;
-    IPC::Message::Sender* port2;
-  };
-
-  // A map of channel ID to its channel object.
-  typedef std::map<int, MessageChannel> MessageChannelMap;
   MessageChannelMap channels_;
 
   // True if Init has been called.
   bool initialized_;
 
   // For generating unique channel IDs.
   int next_port_id_;
 
   // Protects the next_port_id_ variable, since it can be
   // used on the IO thread or the UI thread.
   Lock next_port_id_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionMessageService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_MESSAGE_SERVICE_H_