extensions/test/data/sockets_udp/api/background.js

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // net/tools/testserver/testserver.py is picky about the format of what it
   6 // calls its "echo" messages. One might go so far as to mutter to oneself that
   7 // it isn't an echo server at all.
   8 //
   9 // The response is based on the request but obfuscated using a random key.
  10 const request = "0100000005320000005hello";
  11 var expectedResponsePattern = /0100000005320000005.{11}/;
  12
  13 var address;
  14 var bytesSent = 0;
  15 var dataAsString;
  16 var dataRead = [];
  17 var port = -1;
  18 var socketId = 0;
  19 var succeeded = false;
  20 var waitCount = 0;
  21
  22 // Many thanks to Dennis for his StackOverflow answer: http://goo.gl/UDanx
  23 // Since amended to handle BlobBuilder deprecation.
  24 function string2ArrayBuffer(string, callback) {
  25   var blob = new Blob([string]);
  26   var f = new FileReader();
  27   f.onload = function(e) {
  28     callback(e.target.result);
  29   };
  30   f.readAsArrayBuffer(blob);
  31 }
  32
  33 function arrayBuffer2String(buf, callback) {
  34   var blob = new Blob([new Uint8Array(buf)]);
  35   var f = new FileReader();
  36   f.onload = function(e) {
  37     callback(e.target.result);
  38   };
  39   f.readAsText(blob);
  40 }
  41
  42 ///////////////////////////////////////////////////////////////////////////////
  43 // Test socket creation
  44 //
  45
  46 var testSocketCreation = function() {
  47   function onCreate(createInfo) {
  48     function onGetInfo(info) {
  49       if (info.localAddress || info.localPort) {
  50         chrome.test.fail('Unconnected socket should not have local binding');
  51       }
  52
  53       chrome.test.assertEq(createInfo.socketId, info.socketId);
  54       chrome.test.assertEq(false, info.persistent);
  55
  56       chrome.sockets.udp.close(createInfo.socketId, function() {
  57         chrome.sockets.udp.getInfo(createInfo.socketId, function(info) {
  58           chrome.test.assertEq(undefined, info);
  59           chrome.test.succeed();
  60         });
  61       });
  62     }
  63
  64     chrome.test.assertTrue(createInfo.socketId > 0);
  65
  66     // Obtaining socket information before a connect() call should be safe, but
  67     // return empty values.
  68     chrome.sockets.udp.getInfo(createInfo.socketId, onGetInfo);
  69   }
  70
  71   chrome.sockets.udp.create({}, onCreate);
  72 };
  73
  74 ///////////////////////////////////////////////////////////////////////////////
  75 // Test socket send/receive
  76 //
  77
  78 function waitForBlockingOperation() {
  79   if (++waitCount < 10) {
  80     setTimeout(waitForBlockingOperation, 1000);
  81   } else {
  82     // We weren't able to succeed in the given time.
  83     chrome.test.fail("Operations didn't complete after " + waitCount + " " +
  84                      "seconds. Response so far was <" + dataAsString + ">.");
  85   }
  86 }
  87
  88 var testSending = function() {
  89   dataRead = "";
  90   succeeded = false;
  91   waitCount = 0;
  92   socketId = 0;
  93   var localSocketId;
  94
  95   console.log("testSending");
  96   setTimeout(waitForBlockingOperation, 1000);
  97   chrome.sockets.udp.create({}, onCreate);
  98
  99   function onCreate(socketInfo) {
 100     console.log("socket created: " + socketInfo.socketId);
 101     localSocketId = socketId = socketInfo.socketId;
 102     chrome.test.assertTrue(localSocketId > 0, "failed to create socket");
 103     chrome.sockets.udp.onReceive.addListener(onReceive);
 104     chrome.sockets.udp.onReceiveError.addListener(onReceiveError);
 105     chrome.sockets.udp.bind(localSocketId, "0.0.0.0", 0, onBind);
 106   }
 107
 108   function onBind(result) {
 109     console.log("socket bound to local host");
 110     chrome.test.assertEq(0, result, "Bind failed with error: " + result);
 111     if (result < 0)
 112       return;
 113
 114     chrome.sockets.udp.getInfo(localSocketId, onGetInfo);
 115   }
 116
 117   function onGetInfo(result) {
 118     console.log("got socket info");
 119     chrome.test.assertTrue(!!result.localAddress,
 120                            "Bound socket should always have local address");
 121     chrome.test.assertTrue(!!result.localPort,
 122                            "Bound socket should always have local port");
 123
 124     string2ArrayBuffer(request, onArrayBuffer);
 125   }
 126
 127   function onArrayBuffer(arrayBuffer) {
 128     console.log("sending bytes to echo server: " + arrayBuffer.byteLength);
 129     chrome.sockets.udp.send(localSocketId, arrayBuffer, address, port,
 130                             function(sendInfo) {
 131       chrome.test.assertEq(0, sendInfo.resultCode);
 132       chrome.test.assertEq(sendInfo.bytesSent, arrayBuffer.byteLength);
 133     });
 134   }
 135
 136   function onReceiveError(info) {
 137     chrome.test.fail("Socket receive error: " + info.resultCode);
 138   }
 139
 140   function onReceive(info) {
 141     console.log("received bytes on from echo server: " + info.data.byteLength +
 142       "(" + info.socketId + ")");
 143     if (localSocketId == info.socketId) {
 144       arrayBuffer2String(info.data, function(s) {
 145         dataAsString = s;  // save this for error reporting
 146         var match = !!s.match(expectedResponsePattern);
 147         chrome.test.assertTrue(match, "Received data does not match.");
 148         chrome.sockets.udp.close(localSocketId, function () {
 149           chrome.sockets.udp.onReceive.removeListener(onReceive);
 150           chrome.sockets.udp.onReceiveError.removeListener(onReceiveError);
 151           succeeded = true;
 152           chrome.test.succeed();
 153         });
 154       });
 155     }
 156   }
 157 }
 158
 159 var testSetPaused = function() {
 160   dataRead = "";
 161   succeeded = false;
 162   waitCount = 0;
 163   socketId = 0;
 164   var localSocketId = 0;
 165   var receiveTimer;
 166
 167   console.log("testSetPaused");
 168   setTimeout(waitForBlockingOperation, 1000);
 169   chrome.sockets.udp.create({}, onCreate);
 170
 171   function onCreate(socketInfo) {
 172     console.log("socket created: " + socketInfo.socketId);
 173     localSocketId = socketId = socketInfo.socketId;
 174     chrome.test.assertTrue(localSocketId > 0, "failed to create socket");
 175
 176     chrome.sockets.udp.onReceiveError.addListener(onReceiveError);
 177     chrome.sockets.udp.onReceive.addListener(onReceive);
 178
 179     chrome.sockets.udp.setPaused(localSocketId, true, function () {
 180       chrome.sockets.udp.bind(localSocketId, "0.0.0.0", 0, onBind);
 181     });
 182   }
 183
 184   function onBind(result) {
 185     console.log("socket bound to local host");
 186     chrome.test.assertEq(0, result, "Bind failed with error: " + result);
 187     if (result < 0)
 188       return;
 189
 190     string2ArrayBuffer(request, onArrayBuffer);
 191   }
 192
 193   function onArrayBuffer(arrayBuffer) {
 194     console.log("sending bytes to echo server: " + arrayBuffer.byteLength);
 195     chrome.sockets.udp.send(localSocketId, arrayBuffer, address, port,
 196                             function(sendInfo) {
 197       chrome.test.assertEq(0, sendInfo.resultCode);
 198       chrome.test.assertEq(sendInfo.bytesSent, arrayBuffer.byteLength);
 199       receiveTimer = setTimeout(waitForReceiveEvents, 1000);
 200     });
 201   }
 202
 203   function waitForReceiveEvents() {
 204     chrome.sockets.udp.close(localSocketId, function () {
 205       chrome.sockets.udp.onReceive.removeListener(onReceive);
 206       chrome.sockets.udp.onReceiveError.removeListener(onReceiveError);
 207       succeeded = true;
 208       chrome.test.succeed("No data received from echo server!");
 209     });
 210   };
 211
 212   function onReceiveError(info) {
 213     if (localSocketId == info.socketId) {
 214       if (receiveTimer)
 215         clearTimeout(receiveTimer);
 216       chrome.test.fail("Socket receive error: " + info.resultCode);
 217     }
 218   }
 219
 220   function onReceive(info) {
 221     console.log("Received data on socket" + "(" + info.socketId + ")");
 222     if (localSocketId == info.socketId) {
 223       if (receiveTimer)
 224         clearTimeout(receiveTimer);
 225       chrome.test.fail("Should not receive data when socket is paused: " +
 226                        info.data.byteLength);
 227     }
 228   }
 229 }
 230
 231 ///////////////////////////////////////////////////////////////////////////////
 232 // Test driver
 233 //
 234
 235 var onMessageReply = function(message) {
 236   var parts = message.split(":");
 237   var test_type = parts[0];
 238   address = parts[1];
 239   port = parseInt(parts[2]);
 240   console.log("Running tests, echo server " +
 241               address + ":" + port);
 242   if (test_type == 'multicast') {
 243     console.log("Running multicast tests");
 244     chrome.test.runTests([ testMulticast ]);
 245   } else {
 246     console.log("Running udp tests");
 247     chrome.test.runTests([ testSocketCreation, testSending, testSetPaused ]);
 248   }
 249 };
 250
 251 // Find out which protocol we're supposed to test, and which echo server we
 252 // should be using, then kick off the tests.
 253 chrome.test.sendMessage("info_please", onMessageReply);