Clear the onMessage and onDisconnect listeners when their Extension Port is destroyed.

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.
 
+// Tests for browser_tests --gtest_filter=ExtensionApiTest.Messaging
+
+var assertEq = chrome.test.assertEq;
+var assertTrue = chrome.test.assertTrue;
 var listenOnce = chrome.test.listenOnce;
 var listenForever = chrome.test.listenForever;
 
 JSON.parse = function() {
   return "JSON.parse clobbered by extension.";
 };
 
 JSON.stringify = function() {
   return "JSON.stringify clobbered by extension.";
 };
@@ skipping 38 matching lines @@
         port.disconnect();
       });
     },
 
     // Tests that port name is sent & received correctly.
     function portName() {
       var portName = "lemonjello";
       var port = chrome.tabs.connect(testTab.id, {name: portName});
       port.postMessage({testPortName: true});
       listenOnce(port.onMessage, function(msg) {
-        chrome.test.assertEq(msg.portName, portName);
+        assertEq(msg.portName, portName);
         port.disconnect();
       });
     },
 
     // Tests that postMessage from the tab and its response works.
     function postMessageFromTab() {
       listenOnce(chrome.runtime.onConnect, function(port) {
-        chrome.test.assertEq({
+        assertEq({
           tab: testTab,
           frameId: 0, // Main frame
           url: testTab.url,
-           id: chrome.runtime.id
+          id: chrome.runtime.id
         }, port.sender);
         listenOnce(port.onMessage, function(msg) {
-          chrome.test.assertTrue(msg.testPostMessageFromTab);
+          assertTrue(msg.testPostMessageFromTab);
           port.postMessage({success: true, portName: port.name});
           chrome.test.log("postMessageFromTab: got message from tab");
         });
       });
 
       var port = chrome.tabs.connect(testTab.id);
       port.postMessage({testPostMessageFromTab: true});
       chrome.test.log("postMessageFromTab: sent first message to tab");
       listenOnce(port.onMessage, function(msg) {
         port.disconnect();
       });
     },
 
     // Tests receiving a request from a content script and responding.
     function sendMessageFromTab() {
       var doneListening = listenForever(
         chrome.runtime.onMessage,
         function(request, sender, sendResponse) {
-          chrome.test.assertEq({
+          assertEq({
             tab: testTab,
             frameId: 0, // Main frame
             url: testTab.url,
-             id: chrome.runtime.id
+            id: chrome.runtime.id
           }, sender);
           if (request.step == 1) {
             // Step 1: Page should send another request for step 2.
             chrome.test.log("sendMessageFromTab: got step 1");
             sendResponse({nextStep: true});
           } else {
             // Step 2.
-            chrome.test.assertEq(request.step, 2);
+            assertEq(2, request.step);
             sendResponse();
             doneListening();
           }
       });
 
       var port = chrome.tabs.connect(testTab.id);
       port.postMessage({testSendMessageFromTab: true});
       port.disconnect();
       chrome.test.log("sendMessageFromTab: sent first message to tab");
     },
@@ skipping 24 matching lines @@
                 return frame.frameId > 0; // Exclude main frame.
               }).map(function(frame) {
                 return {
                   tab: testTab,
                   frameId: frame.frameId,
                   url: frame.url,
                   id: chrome.runtime.id
                 };
               }).sort(sortByFrameId);
               senders.sort(sortByFrameId);
-              chrome.test.assertEq(expectedSenders, senders);
+              assertEq(expectedSenders, senders);
               doneListening();
             });
           }
         }
       );
 
       var port = chrome.tabs.connect(testTab.id);
       port.postMessage({testSendMessageFromFrame: true});
       port.disconnect();
       chrome.test.log("sendMessageFromFrameInTab: send 1st message to tab");
@@ skipping 11 matching lines @@
 
     // connect with a positive frameId should trigger onConnect in that specific
     // frame only.
     function sendMessageToFrameInTab() {
       chrome.webNavigation.getAllFrames({
         tabId: testTab.id
       }, function(details) {
         var frames = details.filter(function(frame) {
           return /\?testSendMessageFromFrame1$/.test(frame.url);
         });
-        chrome.test.assertEq(1, frames.length);
+        assertEq(1, frames.length);
         connectToTabWithFrameId(frames[0].frameId, ['from_1']);
       });
     },
 
     // sendMessage with an invalid frameId should fail.
     function sendMessageToInvalidFrameInTab() {
       chrome.tabs.sendMessage(testTab.id, {}, {
         frameId: 999999999 // Some (hopefully) invalid frameId.
       }, chrome.test.callbackFail(
         'Could not establish connection. Receiving end does not exist.'));
@@ skipping 29 matching lines @@
 
       var port = chrome.tabs.connect(testTab.id);
       port.postMessage({testConnectFromTabError: true});
       port.disconnect();
       chrome.test.log("testConnectFromTabError: sent 1st message to tab");
     },
 
     // Tests sending a request to a tab and receiving a response.
     function sendMessage() {
       chrome.tabs.sendMessage(testTab.id, {step2: 1}, function(response) {
-        chrome.test.assertTrue(response.success);
+        assertTrue(response.success);
         chrome.test.succeed();
       });
     },
 
     // Tests that we get the disconnect event when the tab disconnect.
     function disconnect() {
       var port = chrome.tabs.connect(testTab.id);
       port.postMessage({testDisconnect: true});
       listenOnce(port.onDisconnect, function() {});
     },
@@ skipping 23 matching lines @@
     },
 
     // Tests that the sendRequest API is disabled.
     function sendRequest() {
       var error;
       try {
         chrome.extension.sendRequest("hi");
       } catch(e) {
         error = e;
       }
-      chrome.test.assertTrue(error != undefined);
+      assertTrue(error != undefined);
 
       error = undefined;
       try {
         chrome.extension.onRequest.addListener(function() {});
       } catch(e) {
         error = e;
       }
-      chrome.test.assertTrue(error != undefined);
+      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);
@@ skipping 11 matching lines @@
     // 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(
+      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);
+          assertEq('ping', msg);
+          assertEq(chrome.runtime.id, sender.id);
+          assertEq(location.href, sender.url);
           setTimeout(function() {
             stopFailing();
             chrome.test.succeed();
           }, 0);
         }
       );
 
       chrome.runtime.sendMessage('ping');
     },
+
+    // Tests that destroying a port clears its onMessage and onDisconnect
+    // listeners.
+    function disconnectingPortRemovesEventListeners() {
+      var port = chrome.runtime.connect(chrome.runtime.id);
+      assertTrue(!port.onMessage.hasListeners() &&
+                 !port.onDisconnect.hasListeners());
+      port.onMessage.addListener(function() {});
+      port.onDisconnect.addListener(function() {});
+      assertTrue(port.onMessage.hasListeners() &&
+                 port.onDisconnect.hasListeners());
+      port.disconnect();
+      assertTrue(!port.onMessage.hasListeners() &&
+                 !port.onDisconnect.hasListeners());
+      chrome.test.succeed();
+    }
   ]);
 });
 
 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());
+      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();
   };
 }