Test that chrome.runtime.onMessage isn't fired for chrome.runtime.sendMessage

chrome/test/data/extensions/api_test/messaging/connect/test.js

 // Copyright (c) 2011 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.
 
 var listenOnce = chrome.test.listenOnce;
 var listenForever = chrome.test.listenForever;
 
 JSON.parse = function() {
   return "JSON.parse clobbered by extension.";
 };
@@ skipping 272 matching lines @@
       try {
         chrome.extension.onRequest.addListener(function() {});
       } catch(e) {
         error = e;
       }
       chrome.test.assertTrue(error != undefined);
 
       chrome.test.succeed();
     },
 
+    // Tests that chrome.runtime.sendMessage is *not* delivered to the current
+    // context, consistent behavior with chrome.runtime.connect() and web APIs
+    // like localStorage changed listeners.
+    // Regression test for http://crbug.com/479951.
+    function sendMessageToCurrentContextFails() {
+      var stopFailing = failWhileListening(chrome.runtime.onMessage);

[Devlin, 2015/04/28 22:24:40]

nit: stopFailing is kinda a funny name...but I got nothin' better.

[not at google - send to devlin, 2015/04/28 22:46:31]

I think of it like a function.

function stopFailing() {
  ...
}

makes perfect sense.

+      chrome.runtime.sendMessage('ping', chrome.test.callbackFail(
+          'Could not establish connection. Receiving end does not exist.',
+          function() {
+            stopFailing();
+            chrome.test.succeed();
+          }
+      ));
+    },
+
+    // Like sendMessageToCurrentContextFails, but with the sendMessage call not
+    // given a callback. This requires a more creative test setup because there
+    // is no callback to signal when it's supposed to have been done.
+    // Regression test for http://crbug.com/479951.
+    function sendMessageToCurrentTextWithoutCallbackFails() {
+      // Make the iframe - in a different context - watch for the message
+      // event. It *should* get it, while the current context's one doesn't.
+      var iframe = document.createElement('iframe');
+      iframe.src = chrome.runtime.getURL('blank_iframe.html');
+      document.body.appendChild(iframe);
+
+      var stopFailing = failWhileListening(chrome.runtime.onMessage);
+      chrome.test.listenOnce(
+        iframe.contentWindow.chrome.runtime.onMessage,
+        function(msg, sender) {
+          chrome.test.assertEq('ping', msg);
+          chrome.test.assertEq(chrome.runtime.id, sender.id);
+          chrome.test.assertEq(location.href, sender.url);
+          setTimeout(function() {
+            stopFailing();
+            chrome.test.succeed();
+          }, 0);
+        }
+      );
+
+      chrome.runtime.sendMessage('ping');
+    },
   ]);
 });
 
 function connectToTabWithFrameId(frameId, expectedMessages) {
   var port = chrome.tabs.connect(testTab.id, {
     frameId: frameId
   });
   var messages = [];
   var isDone = false;
   listenForever(port.onMessage, function(message) {
     if (isDone) // Should not get any messages after completing the test.
       chrome.test.fail(
           'Unexpected message from port to frame ' + frameId + ': ' + message);
 
     messages.push(message);
     isDone = messages.length == expectedMessages.length;
     if (isDone) {
       chrome.test.assertEq(expectedMessages.sort(), messages.sort());
       chrome.test.succeed();
     }
   });
   listenOnce(port.onDisconnect, function() {
     if (!isDone) // The event should never be triggered when we expect messages.
       chrome.test.fail('Unexpected disconnect from port to frame ' + frameId);
   });
   port.postMessage({testSendMessageToFrame: true});
   chrome.test.log('connectToTabWithFrameId: port to frame ' + frameId);
 }
+
+// Listens to |event| and returns a callback to run to stop listening. While
+// listening, if |event| is fired, calls chrome.test.fail().
+function failWhileListening(event, doneListening) {
+  var failListener = function() {
+    chrome.test.fail('Event listener ran, but it shouldn\'t have. ' +
+                     'It\'s possible that may be triggered flakily, but this ' +
+                     'really is a real failure, not flaky sadness. Promise!');
+  };
+  var release = chrome.test.callbackAdded();
+  event.addListener(failListener);
+  return function() {
+    event.removeListener(failListener);
+    release();
+  };
+}