Hide Port privates

chrome/renderer/resources/extensions/messaging.js

 // 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.
 
 // This contains unprivileged javascript APIs for extensions and apps.  It
 // can be loaded by any extension-related context, such as content scripts or
 // background pages. See user_script_slave.cc for script that is loaded by
 // content scripts only.
 
   // 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 messagingNatives = requireNative('messaging_natives');
   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 Port(portId, opt_name) {
+  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.
-  Port.prototype.postMessage = function(msg) {
+  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.
-  Port.prototype.disconnect = function() {
+  PortImpl.prototype.disconnect = function() {
     messagingNatives.CloseChannel(this.portId_, true);
     this.destroy_();
   };
 
-  Port.prototype.destroy_ = function() {
+  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]);
 
@@ skipping 69 matching lines @@
       return false;
     if (!requestEvent.hasListeners())
       return false;
     var port = createPort(portId, channelName);
 
     function messageListener(request) {
       var responseCallbackPreserved = false;
       var responseCallback = function(response) {
         if (port) {
           port.postMessage(response);
-          port.destroy_();
+          privates(port).impl.destroy_();
           port = null;
         } else {
           // We nulled out port when sending the response, and now the page
           // is trying to send another response for the same request.
           handleSendRequestError(isSendMessage, responseCallbackPreserved,
                                  sourceExtensionId, targetExtensionId);
         }
       };
       // In case the extension never invokes the responseCallback, and also
       // doesn't keep a reference to it, we need to clean up the port. Do
       // so by attaching to the garbage collection of the responseCallback
       // using some native hackery.
       messagingNatives.BindToGC(responseCallback, function() {
         if (port) {
-          port.destroy_();
+          privates(port).impl.destroy_();
           port = null;
         }
       });
       var rv = requestEvent.dispatch(request, sender, responseCallback);
       if (isSendMessage) {
         responseCallbackPreserved =
             rv && rv.results && $Array.indexOf(rv.results, true) > -1;
         if (!responseCallbackPreserved && port) {
           // If they didn't access the response callback, they're not
           // going to send a response, so clean up the port immediately.
-          port.destroy_();
+          privates(port).impl.destroy_();
           port = null;
         }
       }
     }
 
-    port.onDestroy_ = function() {
+    privates(port).impl.onDestroy_ = function() {
       port.onMessage.removeListener(messageListener);
     };
     port.onMessage.addListener(messageListener);
 
     var eventName = isSendMessage ? "runtime.onMessage" : "extension.onRequest";
     if (isExternal)
       eventName += "External";
     logActivity.LogEvent(targetExtensionId,
                          eventName,
                          [sourceExtensionId, sourceUrl]);
@@ skipping 68 matching lines @@
   function dispatchOnDisconnect(portId, errorMessage) {
     var port = ports[portId];
     if (port) {
       // Update the renderer's port bookkeeping, without notifying the browser.
       messagingNatives.CloseChannel(portId, false);
       if (errorMessage)
         lastError.set('Port', errorMessage, null, chrome);
       try {
         port.onDisconnect.dispatch(port);
       } finally {
-        port.destroy_();
+        privates(port).impl.destroy_();
         lastError.clear(chrome);
       }
     }
   };
 
   // Called by native code when a message has been sent to the given port.
   function dispatchOnMessage(msg, portId) {
     var port = ports[portId];
     if (port) {
       if (msg)
@@ skipping 33 matching lines @@
     }
 
     function messageListener(response) {
       try {
         responseCallback(response);
       } finally {
         port.disconnect();
       }
     }
 
-    port.onDestroy_ = function() {
+    privates(port).impl.onDestroy_ = function() {
       port.onDisconnect.removeListener(disconnectListener);
       port.onMessage.removeListener(messageListener);
     };
     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(PortImpl, [
+    'disconnect',
+    'postMessage'
+  ],
+  [
+    '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;