src/chrome/test/data/extensions/api_test/sockets_tcp/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 protocol = "none";
  19 var socketId = 0;
  20 var echoDataSent = false;
  21 var succeeded = false;
  22 var waitCount = 0;
  23
  24 // Many thanks to Dennis for his StackOverflow answer: http://goo.gl/UDanx
  25 // Since amended to handle BlobBuilder deprecation.
  26 function string2ArrayBuffer(string, callback) {
  27   var blob = new Blob([string]);
  28   var f = new FileReader();
  29   f.onload = function(e) {
  30     callback(e.target.result);
  31   };
  32   f.readAsArrayBuffer(blob);
  33 }
  34
  35 function arrayBuffer2String(buf, callback) {
  36   var blob = new Blob([new Uint8Array(buf)]);
  37   var f = new FileReader();
  38   f.onload = function(e) {
  39     callback(e.target.result);
  40   };
  41   f.readAsText(blob);
  42 }
  43
  44 var testSocketCreation = function() {
  45   function onCreate(socketInfo) {
  46     function onGetInfo(info) {
  47       chrome.test.assertFalse(info.connected);
  48
  49       if (info.peerAddress || info.peerPort) {
  50         chrome.test.fail('Unconnected socket should not have peer');
  51       }
  52       if (info.localAddress || info.localPort) {
  53         chrome.test.fail('Unconnected socket should not have local binding');
  54       }
  55
  56       chrome.sockets.tcp.close(socketInfo.socketId, function() {
  57         chrome.sockets.tcp.getInfo(socketInfo.socketId, function(info) {
  58           chrome.test.assertEq(undefined, info);
  59           chrome.test.succeed();
  60         });
  61       });
  62     }
  63
  64     chrome.test.assertTrue(socketInfo.socketId > 0);
  65
  66     // Obtaining socket information before a connect() call should be safe, but
  67     // return empty values.
  68     chrome.sockets.tcp.getInfo(socketInfo.socketId, onGetInfo);
  69   }
  70
  71   chrome.sockets.tcp.create({}, onCreate);
  72 };
  73
  74
  75 var testSending = function() {
  76   dataRead = "";
  77   succeeded = false;
  78   echoDataSent = false;
  79   waitCount = 0;
  80
  81   setTimeout(waitForBlockingOperation, 1000);
  82
  83   createSocket();
  84
  85   function createSocket() {
  86     chrome.sockets.tcp.create({
  87       "name": "test",
  88       "persistent": true,
  89       "bufferSize": 104
  90     }, onCreateComplete);
  91   }
  92
  93   function onCreateComplete(socketInfo) {
  94     console.log("onCreateComplete");
  95     socketId = socketInfo.socketId;
  96     chrome.test.assertTrue(socketId > 0, "failed to create socket");
  97
  98     console.log("add event listeners");
  99     chrome.sockets.tcp.onReceive.addListener(onSocketReceive);
 100     chrome.sockets.tcp.onReceiveError.addListener(onSocketReceiveError);
 101
 102     chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterCreateComplete);
 103   }
 104
 105   function onGetInfoAfterCreateComplete(result) {
 106     console.log("onGetInfoAfterCreateComplete");
 107     chrome.test.assertTrue(!result.localAddress,
 108                            "Socket should not have local address");
 109     chrome.test.assertTrue(!result.localPort,
 110                            "Socket should not have local port");
 111     chrome.test.assertTrue(!result.peerAddress,
 112                            "Socket should not have peer address");
 113     chrome.test.assertTrue(!result.peerPort,
 114                            "Socket should not have peer port");
 115     chrome.test.assertFalse(result.connected, "Socket should not be connected");
 116
 117     chrome.test.assertEq("test", result.name, "Socket name did not persist");
 118     chrome.test.assertTrue(result.persistent,
 119                            "Socket should be persistent");
 120     chrome.test.assertEq(104, result.bufferSize, "Buffer size did not persist");
 121     chrome.test.assertFalse(result.paused, "Socket should not be paused");
 122
 123     chrome.sockets.tcp.update(socketId, {
 124       "name": "test2",
 125       "persistent": false,
 126       bufferSize: 2048
 127     }, onUpdateComplete);
 128   }
 129
 130   function onUpdateComplete() {
 131     console.log("onUpdateComplete");
 132     chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterUpdateComplete);
 133   }
 134
 135   function onGetInfoAfterUpdateComplete(result) {
 136     console.log("onGetInfoAfterUpdateComplete");
 137     chrome.test.assertTrue(!result.localAddress,
 138                            "Socket should not have local address");
 139     chrome.test.assertTrue(!result.localPort,
 140                            "Socket should not have local port");
 141     chrome.test.assertTrue(!result.peerAddress,
 142                            "Socket should not have peer address");
 143     chrome.test.assertTrue(!result.peerPort,
 144                            "Socket should not have peer port");
 145     chrome.test.assertFalse(result.connected, "Socket should not be connected");
 146
 147     chrome.test.assertEq("test2", result.name, "Socket name did not persist");
 148     chrome.test.assertFalse(result.persistent,
 149                            "Socket should not be persistent");
 150     chrome.test.assertEq(2048, result.bufferSize,
 151                          "Buffer size did not persist");
 152     chrome.test.assertFalse(result.paused, "Socket should not be paused");
 153
 154     chrome.sockets.tcp.connect(socketId, address, port, onConnectComplete);
 155   }
 156
 157   function onConnectComplete(result) {
 158     console.log("onConnectComplete");
 159     chrome.test.assertEq(0, result,
 160                          "Connect failed with error " + result);
 161
 162     chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterConnectComplete);
 163   }
 164
 165   function onGetInfoAfterConnectComplete(result) {
 166     console.log("onGetInfoAfterConnectComplete");
 167     chrome.test.assertTrue(!!result.localAddress,
 168                            "Bound socket should always have local address");
 169     chrome.test.assertTrue(!!result.localPort,
 170                            "Bound socket should always have local port");
 171
 172     // NOTE: We're always called with 'localhost', but getInfo will only return
 173     // IPs, not names.
 174     chrome.test.assertEq(result.peerAddress, "127.0.0.1",
 175                          "Peer addresss should be the listen server");
 176     chrome.test.assertEq(result.peerPort, port,
 177                          "Peer port should be the listen server");
 178     chrome.test.assertTrue(result.connected, "Socket should be connected");
 179
 180     chrome.sockets.tcp.setPaused(socketId, true, onSetPausedComplete);
 181   }
 182
 183   function onSetPausedComplete() {
 184     console.log("onSetPausedComplete");
 185     chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterSetPausedComplete);
 186   }
 187
 188   function onGetInfoAfterSetPausedComplete(result) {
 189     console.log("onGetInfoAfterSetPausedComplete");
 190     chrome.test.assertTrue(result.paused, "Socket should be paused");
 191     chrome.sockets.tcp.setPaused(socketId, false, onUnpauseComplete);
 192   }
 193
 194   function onUnpauseComplete() {
 195     console.log("onUnpauseComplete");
 196     chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterUnpauseComplete);
 197   }
 198
 199   function onGetInfoAfterUnpauseComplete(result) {
 200     console.log("onGetInfoAfterUnpauseComplete");
 201     chrome.test.assertFalse(result.paused, "Socket should not be paused");
 202     chrome.sockets.tcp.setNoDelay(socketId, true, onSetNoDelayComplete);
 203   }
 204
 205   function onSetNoDelayComplete(result) {
 206     console.log("onSetNoDelayComplete");
 207     if (result != 0) {
 208       chrome.test.fail("setNoDelay failed for TCP: " +
 209           "result=" + result + ", " +
 210           "lastError=" + chrome.runtime.lastError.message);
 211     }
 212     chrome.sockets.tcp.setKeepAlive(
 213         socketId, true, 1000, onSetKeepAliveComplete);
 214   }
 215
 216   function onSetKeepAliveComplete(result) {
 217     console.log("onSetKeepAliveComplete");
 218     if (result != 0) {
 219       chrome.test.fail("setKeepAlive failed for TCP: " +
 220           "result=" + result + ", " +
 221           "lastError=" + chrome.runtime.lastError.message);
 222     }
 223
 224     string2ArrayBuffer(request, function(arrayBuffer) {
 225       echoDataSent = true;
 226       chrome.sockets.tcp.send(socketId, arrayBuffer, onSendComplete);
 227     });
 228   }
 229
 230   function onSendComplete(sendInfo) {
 231     console.log("onSendComplete: " + sendInfo.bytesSent + " bytes.");
 232     chrome.test.assertEq(0, sendInfo.resultCode, "Send failed.");
 233     chrome.test.assertTrue(sendInfo.bytesSent > 0,
 234         "Send didn't write bytes.");
 235     bytesSent += sendInfo.bytesSent;
 236   }
 237
 238   function onSocketReceive(receiveInfo) {
 239     console.log("onSocketReceive");
 240     chrome.test.assertEq(socketId, receiveInfo.socketId);
 241     arrayBuffer2String(receiveInfo.data, function(s) {
 242       dataAsString = s;  // save this for error reporting
 243       var match = !!s.match(expectedResponsePattern);
 244       chrome.test.assertTrue(match, "Received data does not match.");
 245       console.log("echo data received, closing socket");
 246       chrome.sockets.tcp.close(socketId, onCloseComplete);
 247     });
 248   }
 249
 250   function onSocketReceiveError(receiveErrorInfo) {
 251     // Note: Once we have sent the "echo" message, the echo server sends back
 252     // the "echo" response and closes the connection right away. This means
 253     // we get a "connection closed" error very quickly after sending our
 254     // message. This is why we ignore errors from that point on.
 255     if (echoDataSent)
 256       return;
 257
 258     console.log("onSocketReceiveError");
 259     chrome.test.fail("Receive error on socket " + receiveErrorInfo.socketId +
 260       ": result code=" + receiveErrorInfo.resultCode);
 261   }
 262
 263   function onCloseComplete() {
 264     console.log("onCloseComplete");
 265     succeeded = true;
 266     chrome.test.succeed();
 267   }
 268
 269 };  // testSending()
 270
 271 function waitForBlockingOperation() {
 272   if (++waitCount < 10) {
 273     setTimeout(waitForBlockingOperation, 1000);
 274   } else {
 275     // We weren't able to succeed in the given time.
 276     chrome.test.fail("Operations didn't complete after " + waitCount + " " +
 277                      "seconds. Response so far was <" + dataAsString + ">.");
 278   }
 279 }
 280
 281 var onMessageReply = function(message) {
 282   var parts = message.split(":");
 283   var test_type = parts[0];
 284   address = parts[1];
 285   port = parseInt(parts[2]);
 286   console.log("Running tests, protocol " + test_type + ", echo server " +
 287               address + ":" + port);
 288   if (test_type == 'tcp') {
 289     protocol = test_type;
 290     chrome.test.runTests([testSocketCreation, testSending]);
 291   } else {
 292     chrome.test.fail("Invalid test type: " + test_type);
 293   }
 294 };
 295
 296 // Find out which protocol we're supposed to test, and which echo server we
 297 // should be using, then kick off the tests.
 298 chrome.test.sendMessage("info_please", onMessageReply);