Multicast socket API

chrome/test/data/extensions/api_test/socket/api/background.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.
 
 // net/tools/testserver/testserver.py is picky about the format of what it
 // calls its "echo" messages. One might go so far as to mutter to oneself that
 // it isn't an echo server at all.
 //
 // The response is based on the request but obfuscated using a random key.
 const request = "0100000005320000005hello";
@@ skipping 216 matching lines @@
   }
 
   function onServerSocketCreate(socketInfo) {
     socketId = socketInfo.socketId;
     socket.listen(socketId, address, port, onListen);
   }
 
   socket.create('tcp', {}, onServerSocketCreate);
 };
 
+function testMulticast() {
+  var kMulticastAddress = "237.132.100." + (Math.random() * 250 >> 0);

[scheib, 2013/04/02 18:25:17]

Random in tests tends to result in flaky tests. Pick a few stable random
addresses and hard code them if needed.

[Bei Zhang, 2013/04/05 00:38:59]

My concern is, as multiple slaves might be running in the same subnet, they may
send to each other thus make the result flaky if they are joining the same
group. Maybe I should ask someone who knows how the machines are deployed?

On 2013/04/02 18:25:17, scheib wrote:

[scheib, 2013/04/05 17:41:04]

Good concern, I don't know a good solution, consult domain experts. ;)

+  var kPort = 9000 + (Math.random() * 2000 >>0);
+
+  function arrayBufferToString(arrayBuffer) {
+    // UTF-16LE
+    return String.fromCharCode.apply(String, new Uint16Array(arrayBuffer));
+  }
+
+  function stringToArrayBuffer(string) {
+    // UTF-16LE
+    var buf = new ArrayBuffer(string.length * 2);
+    var bufView = new Uint16Array(buf);
+    for (var i = 0, strLen = string.length; i < strLen; i++) {
+      bufView[i] = string.charCodeAt(i);
+    }
+    return buf;
+  }
+
+  function testSendMessage(message, address, port) {
+    address = address || kMulticastAddress;
+    port = port || kPort;
+    var clientSocketId;
+    socket.create('udp', {}, function (socketInfo) {
+      if (socketInfo) {
+        clientSocketId = socketInfo.socketId;
+        chrome.test.assertTrue(clientSocketId > 0,
+                               "Cannot create client udp socket.");
+        socket.bind(clientSocketId, "0.0.0.0", kPort + 2, function (result) {
+          chrome.test.assertTrue(clientSocketId > 0,
+            "Cannot bind client udp socket.");
+          socket.sendTo(clientSocketId,
+            stringToArrayBuffer(message),
+            address,
+            port, function (result) {
+              chrome.test.assertTrue(result.bytesWritten >= 0,
+                  "Send to failed. " + JSON.stringify(result));
+              socket.destroy(clientSocketId);
+            });
+        });
+      } else {
+        chrome.test.fail("Cannot create client udp socket");
+      }
+    });
+  }
+
+  function recvBeforeAddMembership(serverSocketId) {
+    var recvTimeout;
+    var ok = false;
+    socket.recvFrom(serverSocketId, 1024, function (result) {
+      if (ok){
+        recvWithMembership(serverSocketId);
+      } else {
+        console.log(JSON.stringify(arrayBufferToString(result.data)));
+        chrome.test.fail("Recieved message before joining the group");
+      }
+    });
+    testSendMessage(request);
+    recvTimeout = setTimeout(function () {
+      ok = true;
+      testSendMessage(request, "127.0.0.1", kPort);
+    }, 2000);
+  }
+
+  function recvWithMembership(serverSocketId) {
+    socket.joinGroup(serverSocketId, kMulticastAddress, function (result) {
+      chrome.test.assertEq(0, result, "Join group failed.");
+      var recvTimeout;
+      socket.recvFrom(serverSocketId, 1024, function (result) {
+        chrome.test.assertTrue(!!result && !!result.data, "Recv failed.");
+        chrome.test.assertEq(request, arrayBufferToString(result.data),
+          "Wrong message!");
+        clearTimeout(recvTimeout);
+        recvWithoutMembership(serverSocketId);
+      });
+      testSendMessage(request);
+      recvTimeout = setTimeout(function () {
+        socket.destroy(serverSocketId);
+        chrome.test.fail("Cannot receive from multicast group.");
+      }, 2000);
+    });
+  }
+
+  function recvWithoutMembership(serverSocketId) {
+    socket.leaveGroup(serverSocketId, kMulticastAddress, function (result) {
+      chrome.test.assertEq(0, result, "leave group failed.");
+      var recvTimeout;
+      socket.recvFrom(serverSocketId, 1024, function (result) {
+        chrome.test.fail("Recieved message after leaving the group");
+        clearTimeout(recvTimeout);
+      });
+      testSendMessage(request);
+      recvTimeout = setTimeout(function () {
+        socket.destroy(serverSocketId);
+        succeeded = true;
+        chrome.test.succeed();
+      }, 2000);
+    });
+  }
+
+  socket.create('udp', {}, function (socketInfo) {
+    var serverSocketId;
+    if (socketInfo) {
+      serverSocketId = socketInfo.socketId;
+      socket.bind(serverSocketId, "0.0.0.0", kPort, function (result) {
+        chrome.test.assertEq(0, result, "Bind failed.");
+        recvBeforeAddMembership(serverSocketId);
+      });
+    } else {
+      chrome.test.fail("Cannot create server udp socket");
+    }
+  });
+}
+
 var onMessageReply = function(message) {
   var parts = message.split(":");
   test_type = parts[0];
   address = parts[1];
   port = parseInt(parts[2]);
   console.log("Running tests, protocol " + protocol + ", echo server " +
               address + ":" + port);
   if (test_type == 'tcp_server') {
     chrome.test.runTests([ testSocketListening ]);
+  } else if (test_type == 'multicast') {
+    chrome.test.runTests([ testMulticast ]);
   } else {
     protocol = test_type;
     chrome.test.runTests([ testSocketCreation, testSending ]);
   }
 };
 
 // Find out which protocol we're supposed to test, and which echo server we
 // should be using, then kick off the tests.
 chrome.test.sendMessage("info_please", onMessageReply);