Use FrameTreeNode ID as frameId in extension APIs

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 242 matching lines @@
           // This shouldn't ever be called, so it's a bit pointless.
           chrome.test.fail();
         });
         // Didn't crash.
         chrome.test.succeed();
       } catch (e) {
         chrome.test.fail(e.stack);
       }
     },
 
+    // Tests that reloading a child frame disconnects the port if it was the
+    // only recipient of the port (i.e. no onConnect in main frame).
+    function connectChildFrameAndNavigate() {
+      listenOnce(chrome.runtime.onMessage, function(msg) {
+        chrome.test.assertEq('testConnectChildFrameAndNavigateSetupDone', msg);
+        // Now we have set up a frame and ensured that there is no onConnect
+        // handler in the main frame. Run the actual test:
+        var port = chrome.tabs.connect(testTab.id);
+        listenOnce(port.onDisconnect, function() {});
+        port.postMessage({testConnectChildFrameAndNavigate: true});
+      });
+      chrome.tabs.connect(testTab.id)
+        .postMessage({testConnectChildFrameAndNavigateSetup: true});
+    },
+
     // Tests that we get the disconnect event when the tab context closes.
     function disconnectOnClose() {
       var port = chrome.tabs.connect(testTab.id);
       port.postMessage({testDisconnectOnClose: true});
       listenOnce(port.onDisconnect, function() {
         testTab = null; // the tab is about:blank now.
       });
     },
 
     // Tests that the sendRequest API is disabled.
@@ skipping 20 matching lines @@
     // 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);
       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.
     //
     // NOTE(kalman): This test is correct. However, the patch which fixes it
     // (see bug) was reverted, and I don't plan on resubmitting, so instead
     // I'll comment out this test, and leave it here for the record.
     //
     // 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.
+  port.onMessage.addListener(function(message) {
+    if (isDone) { // Should not get any messages after completing the test.
       chrome.test.fail(
           'Unexpected message from port to frame ' + frameId + ': ' + message);
+      return;
+    }
 
     messages.push(message);
     isDone = messages.length == expectedMessages.length;
     if (isDone) {
       chrome.test.assertEq(expectedMessages.sort(), messages.sort());
       chrome.test.succeed();
     }
   });
-  listenOnce(port.onDisconnect, function() {
+  port.onDisconnect.addListener(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();
   };
 }