Deprecate chrome.extension.sendRequest in favor of sendMessage, with a safer

chrome/renderer/resources/extensions/miscellaneous_bindings.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 script contains unprivileged javascript APIs related to chrome
 // extensions.  It is 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.
 
   require('json_schema');
   require('event_bindings');
   var miscNatives = requireNative('miscellaneous_bindings');
   var CloseChannel = miscNatives.CloseChannel;
   var PortAddRef = miscNatives.PortAddRef;
   var PortRelease = miscNatives.PortRelease;
   var PostMessage = miscNatives.PostMessage;
   var BindToGC = miscNatives.BindToGC;
 
   var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
   var manifestVersion;
   var extensionId;
 
-  // The reserved channel name for the sendRequest API.
+  // The reserved channel name for the sendRequest/sendMessage APIs.
+  // Note: sendRequest is deprecated.
   chromeHidden.kRequestChannel = "chrome.extension.sendRequest";
+  chromeHidden.kMessageChannel = "chrome.extension.sendMessage";
 
   // Map of port IDs to port object.
   var ports = {};
 
   // Map of port IDs to chromeHidden.onUnload listeners. Keep track of these
   // to free the onUnload listeners when ports are closed.
   var portReleasers = {};
 
   // Change even to odd and vice versa, to get the other side of a given
   // channel.
@@ skipping 53 matching lines @@
     }
     var port = new PortImpl(portId, opt_name);
     ports[portId] = port;
     portReleasers[portId] = PortRelease.bind(this, portId);
     chromeHidden.onUnload.addListener(portReleasers[portId]);
 
     PortAddRef(portId);
     return port;
   };
 
+  // Helper function for dispatchOnRequest.
+  function handleSendRequestError(isSendMessage, responseCallbackPreserved,
+                                  sourceExtensionId, targetExtensionId) {
+    var errorMsg;
+    var eventName = (isSendMessage  ?
+        "chrome.extension.onMessage" : "chrome.extension.onRequest");
+    if (isSendMessage && !responseCallbackPreserved) {
+      errorMsg =
+          "The " + eventName + " listener must return true if you want to" +
+          " send a response after the listener returns ";
+    } else {
+      errorMsg =
+          "Cannot send a response more than once per " + eventName +
+          " listener per document";
+    }
+    errorMsg += " (message was sent by extension " + sourceExtensionId;
+    if (sourceExtensionId != targetExtensionId)
+      errorMsg += " for extension " + targetExtensionId;
+    errorMsg += ").";
+    chrome.extension.lastError = {"message": errorMsg};
+    console.error("Could not send response: " + errorMsg);
+  }
+
+  // Helper function for dispatchOnConnect
   function dispatchOnRequest(portId, channelName, sender,
                              sourceExtensionId, targetExtensionId,
                              isExternal) {
-    var requestEvent = (isExternal ?
-        chrome.extension.onRequestExternal : chrome.extension.onRequest);
+    var isSendMessage = channelName == chromeHidden.kMessageChannel;
+    var requestEvent = (isSendMessage ?
+       (isExternal ?
+           chrome.extension.onMessageExternal : chrome.extension.onMessage) :
+       (isExternal ?
+           chrome.extension.onRequestExternal : chrome.extension.onRequest));
     if (requestEvent.hasListeners()) {
       var port = chromeHidden.Port.createPort(portId, channelName);
       port.onMessage.addListener(function(request) {
+        var responseCallbackPreserved = false;
         var responseCallback = function(response) {
           if (port) {
             port.postMessage(response);
             port.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.
-            var errorMsg =
-                "Cannot send a response more than once per " +
-                "chrome.extension.onRequest listener per document (message " +
-                "was sent by extension " + sourceExtensionId;
-            if (sourceExtensionId != targetExtensionId) {
-              errorMsg += " for extension " + targetExtensionId;
-            }
-            errorMsg += ").";
-            chrome.extension.lastError = {"message": errorMsg};
-            console.error("Could not send response: " + errorMsg);
+              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.
         BindToGC(responseCallback, function() {
           if (port) {
             port.destroy_();
             port = null;
           }
         });
-        requestEvent.dispatch(request, sender, responseCallback);
+          if (!isSendMessage) {
+            requestEvent.dispatch(request, sender, responseCallback);
+          } else {
+            var rv = requestEvent.dispatch(request, sender, responseCallback);
+            responseCallbackPreserved =
+                rv && rv.results && rv.results.indexOf(true) > -1;
+            if (!responseCallbackPreserved) {
+              // If they didn't access the response callback, they're not
+              // going to send a response, so clean up the port immediately.
+              port.destroy_();
+              port = null;
+            }
+          }
       });
       return true;
     }
     return false;
   }
 
   // Called by native code when a channel has been opened to this context.
   chromeHidden.Port.dispatchOnConnect = function(portId, channelName, tab,
                                                  sourceExtensionId,
                                                  targetExtensionId) {
     // Only create a new Port if someone is actually listening for a connection.
     // In addition to being an optimization, this also fixes a bug where if 2
     // channels were opened to and from the same process, closing one would
     // close both.
     if (targetExtensionId != extensionId)
       return false;  // not for us
     if (ports[getOppositePortId(portId)])
       return false;  // this channel was opened by us, so ignore it
 
     // Determine whether this is coming from another extension, so we can use
     // the right event.
     var isExternal = sourceExtensionId != extensionId;
 
     if (tab)
       tab = chromeHidden.JSON.parse(tab);
     var sender = {tab: tab, id: sourceExtensionId};
 
-    // Special case for sendRequest/onRequest.
-    if (channelName == chromeHidden.kRequestChannel) {
+    // Special case for sendRequest/onRequest and sendMessage/onMessage.
+    if (channelName == chromeHidden.kRequestChannel ||
+        channelName == chromeHidden.kMessageChannel) {
       return dispatchOnRequest(portId, channelName, sender,
                                sourceExtensionId, targetExtensionId,
                                isExternal);
     }
 
     var connectEvent = (isExternal ?
         chrome.extension.onConnectExternal : chrome.extension.onConnect);
     if (connectEvent.hasListeners()) {
       var port = chromeHidden.Port.createPort(portId, channelName);
       port.sender = sender;
@@ skipping 32 matching lines @@
   chromeHidden.Port.dispatchOnMessage = function(msg, portId) {
     var port = ports[portId];
     if (port) {
       if (msg) {
         msg = chromeHidden.JSON.parse(msg);
       }
       port.onMessage.dispatch(msg, port);
     }
   };
 
+  // Shared implementation used by tabs.sendMessage and extension.sendMessage.
+  chromeHidden.Port.sendMessageImpl = function(port, request,
+                                               responseCallback) {
+    port.postMessage(request);
+
+    if (port.name == chromeHidden.kMessageChannel && !responseCallback) {
+      // TODO(mpcomplete): Do this for the old sendRequest API too, after
+      // verifying it doesn't break anything.
+      // Go ahead and disconnect immediately if the sender is not expecting
+      // a response.
+      port.disconnect();
+      return;
+    }
+
+    // Ensure the callback exists for the older sendRequest API.
+    if (!responseCallback)
+      responseCallback = function() {};
+
+    port.onDisconnect.addListener(function() {
+      // For onDisconnects, we only notify the callback if there was an error
+      try {
+        if (chrome.extension.lastError)
+          responseCallback();
+      } finally {
+        port = null;
+      }
+    });
+    port.onMessage.addListener(function(response) {
+      try {
+        responseCallback(response);
+      } finally {
+        port.disconnect();
+        port = null;
+      }
+    });
+  }
+
   // This function is called on context initialization for both content scripts
   // and extension contexts.
   chromeHidden.onLoad.addListener(function(tempExtensionId,
                                            isExtensionProcess,
                                            inIncognitoContext,
                                            tempManifestVersion) {
     extensionId = tempExtensionId;
     manifestVersion = tempManifestVersion;
 
     chrome.extension = chrome.extension || {};
 
     if (manifestVersion < 2) {
       chrome.self = chrome.extension;
       chrome.extension.inIncognitoTab = inIncognitoContext;
     }
 
     chrome.extension.inIncognitoContext = inIncognitoContext;
   });