Move the Extension Port implementation out of messaging.js into its own file port.js.

extensions/renderer/resources/messaging.js

 // Copyright 2014 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.
 
 // chrome.runtime.messaging API implementation.
 
   // TODO(kalman): factor requiring chrome out of here.
   var chrome = requireNative('chrome').GetChrome();
-  var Event = require('event_bindings').Event;
   var lastError = require('lastError');
   var logActivity = requireNative('activityLogger');
   var logging = requireNative('logging');
   var messagingNatives = requireNative('messaging_natives');
+  var Port = require('port').Port;
   var processNatives = requireNative('process');
   var unloadEvent = require('unload_event');
-  var utils = require('utils');
   var messagingUtils = require('messaging_utils');
 
   // The reserved channel name for the sendRequest/send(Native)Message APIs.
   // Note: sendRequest is deprecated.
   var kRequestChannel = "chrome.extension.sendRequest";
   var kMessageChannel = "chrome.runtime.sendMessage";
   var kNativeMessageChannel = "chrome.runtime.sendNativeMessage";
 
   // Map of port IDs to port object.
   var ports = {};
 
   // Map of port IDs to unloadEvent listeners. Keep track of these to free the
   // unloadEvent listeners when ports are closed.
   var portReleasers = {};
 
   // Change even to odd and vice versa, to get the other side of a given
   // channel.
   function getOppositePortId(portId) { return portId ^ 1; }
 
-  // Port object.  Represents a connection to another script context through
-  // which messages can be passed.
-  function PortImpl(portId, opt_name) {
-    this.portId_ = portId;
-    this.name = opt_name;
-
-    var portSchema = {name: 'port', $ref: 'runtime.Port'};
-    var options = {unmanaged: true};
-    this.onDisconnect = new Event(null, [portSchema], options);
-    this.onMessage = new Event(
-        null,
-        [{name: 'message', type: 'any', optional: true}, portSchema],
-        options);
-    this.onDestroy_ = null;
-  }
-
-  // Sends a message asynchronously to the context on the other end of this
-  // port.
-  PortImpl.prototype.postMessage = function(msg) {
-    // JSON.stringify doesn't support a root object which is undefined.
-    if (msg === undefined)
-      msg = null;
-    msg = $JSON.stringify(msg);
-    if (msg === undefined) {
-      // JSON.stringify can fail with unserializable objects. Log an error and
-      // drop the message.
-      //
-      // TODO(kalman/mpcomplete): it would be better to do the same validation
-      // here that we do for runtime.sendMessage (and variants), i.e. throw an
-      // schema validation Error, but just maintain the old behaviour until
-      // there's a good reason not to (http://crbug.com/263077).
-      console.error('Illegal argument to Port.postMessage');
-      return;
-    }
-    messagingNatives.PostMessage(this.portId_, msg);
-  };
-
-  // Disconnects the port from the other end.
-  PortImpl.prototype.disconnect = function() {
-    messagingNatives.CloseChannel(this.portId_, true);
-    this.destroy_();
-  };
-
-  PortImpl.prototype.destroy_ = function() {
-    var portId = this.portId_;
-
-    if (this.onDestroy_)
-      this.onDestroy_();
-    privates(this.onDisconnect).impl.destroy_();
-    privates(this.onMessage).impl.destroy_();
-
-    messagingNatives.PortRelease(portId);
-    unloadEvent.removeListener(portReleasers[portId]);
-
-    delete ports[portId];
-    delete portReleasers[portId];
-  };
-
   // Returns true if the specified port id is in this context. This is used by
   // the C++ to avoid creating the javascript message for all the contexts that
   // don't care about a particular message.
   function hasPort(portId) {
     return portId in ports;
   };
 
   // Hidden port creation function.  We don't want to expose an API that lets
   // people add arbitrary port IDs to the port list.
   function createPort(portId, opt_name) {
     if (ports[portId])
       throw new Error("Port '" + portId + "' already exists.");
     var port = new Port(portId, opt_name);
     ports[portId] = port;
     portReleasers[portId] = $Function.bind(messagingNatives.PortRelease,
                                            this,
                                            portId);
     unloadEvent.addListener(portReleasers[portId]);
     messagingNatives.PortAddRef(portId);
     return port;
   };
 
+  // Called when a Port is destroyed. Does general accounting cleanup.
+  function onPortDestroyed(port) {
+    var portId = privates(port).impl.portId_;
+    unloadEvent.removeListener(portReleasers[portId]);
+    delete ports[portId];
+    delete portReleasers[portId];
+  }
+
   // Helper function for dispatchOnRequest.
   function handleSendRequestError(isSendMessage,
                                   responseCallbackPreserved,
                                   sourceExtensionId,
                                   targetExtensionId,
                                   sourceUrl) {
     var errorMsg = [];
     var eventName = isSendMessage ? "runtime.onMessage" : "extension.onRequest";
     if (isSendMessage && !responseCallbackPreserved) {
       $Array.push(errorMsg,
@@ skipping 67 matching lines @@
           // If they didn't access the response callback, they're not
           // going to send a response, so clean up the port immediately.
           privates(port).impl.destroy_();
           port = null;
         }
       }
     }
 
     privates(port).impl.onDestroy_ = function() {
       port.onMessage.removeListener(messageListener);
+      onPortDestroyed(port);
     };
     port.onMessage.addListener(messageListener);
 
     var eventName = isSendMessage ? "runtime.onMessage" : "extension.onRequest";
     if (isExternal)
       eventName += "External";
     logActivity.LogEvent(targetExtensionId,
                          eventName,
                          [sourceExtensionId, sourceUrl]);
     return true;
@@ skipping 135 matching lines @@
     }
 
     function messageListener(response) {
       try {
         responseCallback(response);
       } finally {
         port.disconnect();
       }
     }
 
     privates(port).impl.onDestroy_ = function() {

[Devlin, 2015/04/17 00:14:52]

I don't love this part, especially now that it's in its own file.  How opposed
would you be to making a generic port.onDestroyedListener, that can be called
from port itself?

[not at google - send to devlin, 2015/04/17 00:16:34]

You need to be careful, because Ports are exposed directly to extensions and we
don't want to give those an onDestroyedListener.

When I create port manager this should go away.

[Devlin, 2015/04/17 00:25:52]

Right, in my mind there's:
Private private: Nothing but the class itself
Public private: Accessible through privates()
Public public: Accessible via extensions

Right now, this strikes me as the first - I was suggesting make it the second.

[not at google - send to devlin, 2015/04/17 00:27:59]

Heh, a distinction unique to these JS bindings.

Another design I had considered was to make some kind of InternalPort class
which handled the real Port to give to the extension. However, such an
InternalPort would belong inside the port manager, so if that's the design that
makes the most sense - that's what it will end up as.

       port.onDisconnect.removeListener(disconnectListener);
       port.onMessage.removeListener(messageListener);
+      onPortDestroyed(port);
     };
     port.onDisconnect.addListener(disconnectListener);
     port.onMessage.addListener(messageListener);
   };
 
   function sendMessageUpdateArguments(functionName, hasOptionsArgument) {
     // skip functionName and hasOptionsArgument
     var args = $Array.slice(arguments, 2);
     var alignedArgs = messagingUtils.alignSendMessageArguments(args,
         hasOptionsArgument);
     if (!alignedArgs)
       throw new Error('Invalid arguments to ' + functionName + '.');
     return alignedArgs;
   }
 
-var Port = utils.expose('Port', PortImpl, { functions: [
-    'disconnect',
-    'postMessage'
-  ],
-  properties: [
-    'name',
-    'onDisconnect',
-    'onMessage'
-  ] });
-
 exports.kRequestChannel = kRequestChannel;
 exports.kMessageChannel = kMessageChannel;
 exports.kNativeMessageChannel = kNativeMessageChannel;
-exports.Port = Port;
 exports.createPort = createPort;
 exports.sendMessageImpl = sendMessageImpl;
 exports.sendMessageUpdateArguments = sendMessageUpdateArguments;
 
 // For C++ code to call.
 exports.hasPort = hasPort;
 exports.dispatchOnConnect = dispatchOnConnect;
 exports.dispatchOnDisconnect = dispatchOnDisconnect;
 exports.dispatchOnMessage = dispatchOnMessage;