Multicast socket API

chrome/test/data/extensions/api_test/socket/api/background.js

Index: chrome/test/data/extensions/api_test/socket/api/background.js
diff --git a/chrome/test/data/extensions/api_test/socket/api/background.js b/chrome/test/data/extensions/api_test/socket/api/background.js
index 7f78b564ab9c7d340a3a2102b267e4d5a30aeed5..9ca240fa6ae57d7e8ffbf08fb5902526718a9204 100644
--- a/chrome/test/data/extensions/api_test/socket/api/background.js
+++ b/chrome/test/data/extensions/api_test/socket/api/background.js
@@ -234,6 +234,120 @@ var testSocketListening = function() {
   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];
@@ -243,6 +357,8 @@ var onMessageReply = function(message) {
               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 ]);