An implementation of chrome.socket.secure().

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

 // Copyright 2013 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";
 var expectedResponsePattern = /0100000005320000005.{11}/;
+const http_get = "GET test.html HTTP/1.0\r\n\r\n";
+var expectedHTTPPattern = /HTTP.1.0 200 OK/;
 
-var address;
+var tcp_address;
+var https_address;
 var bytesSent = 0;
 var dataAsString;
 var dataRead = [];
-var port = -1;
+var tcp_port = -1;
+var https_port = -1;
 var protocol = "none";
-var socketId = 0;
+var tcp_socketId = 0;
+var https_socketId = 0;
 var echoDataSent = false;
 var succeeded = false;
 var waitCount = 0;
 
+// Keys are socketIds.  Values are inner dictionaries with two keys: onReceive,
+// onReceiveError.  Both are functions.
+var receive_dispatcher = {}
+
 // Many thanks to Dennis for his StackOverflow answer: http://goo.gl/UDanx
 // Since amended to handle BlobBuilder deprecation.
 function string2ArrayBuffer(string, callback) {
   var blob = new Blob([string]);
   var f = new FileReader();
   f.onload = function(e) {
     callback(e.target.result);
   };
   f.readAsArrayBuffer(blob);
 }
 
 function arrayBuffer2String(buf, callback) {
   var blob = new Blob([new Uint8Array(buf)]);
   var f = new FileReader();
   f.onload = function(e) {
     callback(e.target.result);
   };
   f.readAsText(blob);
 }
 
+function dispatchSocketReceive(receiveInfo) {
+  if (receive_dispatcher[receiveInfo.socketId] !== undefined) {
+    receive_dispatcher[receiveInfo.socketId].onReceive(receiveInfo);
+  } else {
+    console.log("dispatchSocketReceive: No handler for socket " +
+        receiveInfo.socketId);
+  }
+}
+
+function dispatchSocketReceiveError(receiveErrorInfo) {
+  if (receive_dispatcher[receiveErrorInfo.socketId] !== undefined) {
+    receive_dispatcher[receiveErrorInfo.socketId].onReceiveError(
+        receiveErrorInfo);
+  } else {
+    console.log("dispatchSocketReceiveError: No handler for socket " +
+        receiveErrorInfo.socketId);
+  }
+}
+
 var testSocketCreation = function() {
   function onCreate(socketInfo) {
     function onGetInfo(info) {
       chrome.test.assertFalse(info.connected);
 
       if (info.peerAddress || info.peerPort) {
         chrome.test.fail('Unconnected socket should not have peer');
       }
       if (info.localAddress || info.localPort) {
         chrome.test.fail('Unconnected socket should not have local binding');
@@ skipping 10 matching lines @@
     chrome.test.assertTrue(socketInfo.socketId > 0);
 
     // Obtaining socket information before a connect() call should be safe, but
     // return empty values.
     chrome.sockets.tcp.getInfo(socketInfo.socketId, onGetInfo);
   }
 
   chrome.sockets.tcp.create({}, onCreate);
 };
 
-
 var testSending = function() {
   dataRead = "";
   succeeded = false;
   echoDataSent = false;
   waitCount = 0;
 
   setTimeout(waitForBlockingOperation, 1000);
 
   createSocket();
 
   function createSocket() {
     chrome.sockets.tcp.create({
       "name": "test",
       "persistent": true,
       "bufferSize": 104
     }, onCreateComplete);
   }
 
   function onCreateComplete(socketInfo) {
     console.log("onCreateComplete");
-    socketId = socketInfo.socketId;
-    chrome.test.assertTrue(socketId > 0, "failed to create socket");
+    tcp_socketId = socketInfo.socketId;
+    chrome.test.assertTrue(tcp_socketId > 0, "failed to create socket");
 
     console.log("add event listeners");
-    chrome.sockets.tcp.onReceive.addListener(onSocketReceive);
-    chrome.sockets.tcp.onReceiveError.addListener(onSocketReceiveError);
+    receive_dispatcher[tcp_socketId] = {
+      onReceive: onSocketReceive,
+      onReceiveError: onSocketReceiveError
+    };
 
-    chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterCreateComplete);
+    chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterCreateComplete);
   }
 
   function onGetInfoAfterCreateComplete(result) {
     console.log("onGetInfoAfterCreateComplete");
     chrome.test.assertTrue(!result.localAddress,
                            "Socket should not have local address");
     chrome.test.assertTrue(!result.localPort,
                            "Socket should not have local port");
     chrome.test.assertTrue(!result.peerAddress,
                            "Socket should not have peer address");
     chrome.test.assertTrue(!result.peerPort,
                            "Socket should not have peer port");
     chrome.test.assertFalse(result.connected, "Socket should not be connected");
 
     chrome.test.assertEq("test", result.name, "Socket name did not persist");
     chrome.test.assertTrue(result.persistent,
                            "Socket should be persistent");
     chrome.test.assertEq(104, result.bufferSize, "Buffer size did not persist");
     chrome.test.assertFalse(result.paused, "Socket should not be paused");
 
-    chrome.sockets.tcp.update(socketId, {
+    chrome.sockets.tcp.update(tcp_socketId, {
       "name": "test2",
       "persistent": false,
       bufferSize: 2048
     }, onUpdateComplete);
   }
 
   function onUpdateComplete() {
     console.log("onUpdateComplete");
-    chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterUpdateComplete);
+    chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterUpdateComplete);
   }
 
   function onGetInfoAfterUpdateComplete(result) {
     console.log("onGetInfoAfterUpdateComplete");
     chrome.test.assertTrue(!result.localAddress,
                            "Socket should not have local address");
     chrome.test.assertTrue(!result.localPort,
                            "Socket should not have local port");
     chrome.test.assertTrue(!result.peerAddress,
                            "Socket should not have peer address");
     chrome.test.assertTrue(!result.peerPort,
                            "Socket should not have peer port");
     chrome.test.assertFalse(result.connected, "Socket should not be connected");
 
     chrome.test.assertEq("test2", result.name, "Socket name did not persist");
     chrome.test.assertFalse(result.persistent,
                            "Socket should not be persistent");
     chrome.test.assertEq(2048, result.bufferSize,
                          "Buffer size did not persist");
     chrome.test.assertFalse(result.paused, "Socket should not be paused");
 
-    chrome.sockets.tcp.connect(socketId, address, port, onConnectComplete);
+    chrome.sockets.tcp.connect(tcp_socketId, tcp_address, tcp_port,
+                               onConnectComplete);
   }
 
   function onConnectComplete(result) {
     console.log("onConnectComplete");
     chrome.test.assertEq(0, result,
                          "Connect failed with error " + result);
 
-    chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterConnectComplete);
+    chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterConnectComplete);
   }
 
   function onGetInfoAfterConnectComplete(result) {
     console.log("onGetInfoAfterConnectComplete");
     chrome.test.assertTrue(!!result.localAddress,
                            "Bound socket should always have local address");
     chrome.test.assertTrue(!!result.localPort,
                            "Bound socket should always have local port");
 
     // NOTE: We're always called with 'localhost', but getInfo will only return
     // IPs, not names.
     chrome.test.assertEq(result.peerAddress, "127.0.0.1",
                          "Peer addresss should be the listen server");
-    chrome.test.assertEq(result.peerPort, port,
+    chrome.test.assertEq(result.peerPort, tcp_port,
                          "Peer port should be the listen server");
     chrome.test.assertTrue(result.connected, "Socket should be connected");
 
-    chrome.sockets.tcp.setPaused(socketId, true, onSetPausedComplete);
+    chrome.sockets.tcp.setPaused(tcp_socketId, true, onSetPausedComplete);
   }
 
   function onSetPausedComplete() {
     console.log("onSetPausedComplete");
-    chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterSetPausedComplete);
+    chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterSetPausedComplete);
   }
 
   function onGetInfoAfterSetPausedComplete(result) {
     console.log("onGetInfoAfterSetPausedComplete");
     chrome.test.assertTrue(result.paused, "Socket should be paused");
-    chrome.sockets.tcp.setPaused(socketId, false, onUnpauseComplete);
+    chrome.sockets.tcp.setPaused(tcp_socketId, false, onUnpauseComplete);
   }
 
   function onUnpauseComplete() {
     console.log("onUnpauseComplete");
-    chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterUnpauseComplete);
+    chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterUnpauseComplete);
   }
 
   function onGetInfoAfterUnpauseComplete(result) {
     console.log("onGetInfoAfterUnpauseComplete");
     chrome.test.assertFalse(result.paused, "Socket should not be paused");
-    chrome.sockets.tcp.setNoDelay(socketId, true, onSetNoDelayComplete);
+    chrome.sockets.tcp.setNoDelay(tcp_socketId, true, onSetNoDelayComplete);
   }
 
   function onSetNoDelayComplete(result) {
     console.log("onSetNoDelayComplete");
     if (result != 0) {
       chrome.test.fail("setNoDelay failed for TCP: " +
           "result=" + result + ", " +
           "lastError=" + chrome.runtime.lastError.message);
     }
     chrome.sockets.tcp.setKeepAlive(
-        socketId, true, 1000, onSetKeepAliveComplete);
+        tcp_socketId, true, 1000, onSetKeepAliveComplete);
   }
 
   function onSetKeepAliveComplete(result) {
     console.log("onSetKeepAliveComplete");
     if (result != 0) {
       chrome.test.fail("setKeepAlive failed for TCP: " +
           "result=" + result + ", " +
           "lastError=" + chrome.runtime.lastError.message);
     }
 
     string2ArrayBuffer(request, function(arrayBuffer) {
       echoDataSent = true;
-      chrome.sockets.tcp.send(socketId, arrayBuffer, onSendComplete);
+      chrome.sockets.tcp.send(tcp_socketId, arrayBuffer, onSendComplete);
     });
   }
 
   function onSendComplete(sendInfo) {
     console.log("onSendComplete: " + sendInfo.bytesSent + " bytes.");
     chrome.test.assertEq(0, sendInfo.resultCode, "Send failed.");
     chrome.test.assertTrue(sendInfo.bytesSent > 0,
         "Send didn't write bytes.");
     bytesSent += sendInfo.bytesSent;
   }
 
   function onSocketReceive(receiveInfo) {
     console.log("onSocketReceive");
-    chrome.test.assertEq(socketId, receiveInfo.socketId);
+    chrome.test.assertEq(tcp_socketId, receiveInfo.socketId);
     arrayBuffer2String(receiveInfo.data, function(s) {
       dataAsString = s;  // save this for error reporting
       var match = !!s.match(expectedResponsePattern);
       chrome.test.assertTrue(match, "Received data does not match.");
       console.log("echo data received, closing socket");
-      chrome.sockets.tcp.close(socketId, onCloseComplete);
+      chrome.sockets.tcp.close(tcp_socketId, onCloseComplete);
     });
   }
 
   function onSocketReceiveError(receiveErrorInfo) {
     // Note: Once we have sent the "echo" message, the echo server sends back
     // the "echo" response and closes the connection right away. This means
     // we get a "connection closed" error very quickly after sending our
     // message. This is why we ignore errors from that point on.
     if (echoDataSent)
       return;
 
     console.log("onSocketReceiveError");
     chrome.test.fail("Receive error on socket " + receiveErrorInfo.socketId +
       ": result code=" + receiveErrorInfo.resultCode);
   }
 
   function onCloseComplete() {
     console.log("onCloseComplete");
     succeeded = true;
     chrome.test.succeed();
   }
 
 };  // testSending()
 
+var testSecure = function () {
+  var request_sent = false;
+  succeeded = false;
+  dataAsString = "";
+  setTimeout(waitForBlockingOperation, 1000);
+
+  chrome.sockets.tcp.create({}, onCreateComplete);
+
+  function onCreateComplete(socketInfo) {
+    https_socketId = socketInfo.socketId;
+    receive_dispatcher[https_socketId] = {
+      onReceive: onSocketReceive,
+      onReceiveError: onSocketReceiveError
+    };
+
+    chrome.test.assertTrue(https_socketId > 0, "failed to create socket");
+    chrome.sockets.tcp.setPaused(https_socketId, true, onPausedComplete);
+  }
+
+  function onPausedComplete() {
+    console.log("HTTPS onPausedComplete. Connecting to " +https_address + ":" +
+        https_port);
+    chrome.sockets.tcp.connect(https_socketId, https_address, https_port,
+                               onConnectComplete);
+  }
+
+  function onConnectComplete(result) {
+    console.log("HTTPS onConnectComplete");
+    chrome.test.assertEq(0, result,
+                         "Connect failed with error " + result);
+    chrome.sockets.tcp.secure(https_socketId, null, onSecureComplete);
+  }
+
+  function onSecureComplete(result) {
+    console.log("HTTPS onSecureComplete(" + result + ")");
+    chrome.test.assertEq(0, result,
+                         "Secure failed with error " + result);
+    chrome.sockets.tcp.setPaused(https_socketId, false, onUnpauseComplete);
+  }
+
+  function onUnpauseComplete() {
+    console.log("HTTPS onUnpauseComplete");
+    string2ArrayBuffer(http_get, function(arrayBuffer) {
+      request_sent = true;
+      chrome.sockets.tcp.send(https_socketId, arrayBuffer, onSendComplete);
+    });
+  }
+
+  function onSendComplete(sendInfo) {
+    console.log("HTTPS onSendComplete: " + sendInfo.bytesSent + " bytes.");
+    chrome.test.assertEq(0, sendInfo.resultCode, "Send failed.");
+    chrome.test.assertTrue(sendInfo.bytesSent > 0,
+        "Send didn't write bytes.");
+    bytesSent += sendInfo.bytesSent;
+  }
+
+  function onSocketReceive(receiveInfo) {
+    console.log("HTTPS onSocketReceive");
+    chrome.test.assertEq(https_socketId, receiveInfo.socketId);
+    arrayBuffer2String(receiveInfo.data, function(s) {
+      // we will get more data than we care about.  We only care about the
+      // first segment of data (the HTTP 200 code).  Ignore the rest, which
+      // won't match the pattern.
+      if (succeeded == false) {
+        dataAsString = s;  // for waitForBlockingOperation().
+        console.log("HTTPS receive: got " + s);
+        var match = !!s.match(expectedHTTPPattern);
+        chrome.test.assertTrue(match, "Received data does not match.");
+        console.log("HTTPS response received, closing socket.");
+        chrome.sockets.tcp.close(https_socketId, onCloseComplete);
+      }
+      succeeded = true;
+    });
+  }
+
+  function onSocketReceiveError(receiveErrorInfo) {
+    console.log("HTTPS onSocketReceiveError");
+    if (request_sent) {
+      return;
+    }
+    chrome.test.fail("Receive error on socket " + receiveErrorInfo.socketId +
+      ": result code=" + receiveErrorInfo.resultCode);
+  }
+
+  function onCloseComplete() {
+    console.log("HTTPS Test Succeeded");
+    chrome.test.succeed();
+  }
+};  // testSecure()
+
 function waitForBlockingOperation() {
   if (++waitCount < 10) {
     setTimeout(waitForBlockingOperation, 1000);
   } else {
     // We weren't able to succeed in the given time.
     chrome.test.fail("Operations didn't complete after " + waitCount + " " +
                      "seconds. Response so far was <" + dataAsString + ">.");
   }
 }
 
 var onMessageReply = function(message) {
-  var parts = message.split(":");
-  var test_type = parts[0];
-  address = parts[1];
-  port = parseInt(parts[2]);
-  console.log("Running tests, protocol " + test_type + ", echo server " +
-              address + ":" + port);
-  if (test_type == 'tcp') {
-    protocol = test_type;
-    chrome.test.runTests([testSocketCreation, testSending]);
-  } else {
-    chrome.test.fail("Invalid test type: " + test_type);
+  var components = message.split(',');
+  var tests = [];
+  for (var i = 0; i < components.length; ++i) {
+    var parts = components[i].split(":");
+    var test_type = parts[0];
+    if (test_type == 'tcp') {
+      tcp_address = parts[1];
+      tcp_port = parseInt(parts[2]);
+      console.log("Running tests for TCP, echo server " +
+          tcp_address + ":" + tcp_port);
+      tests = tests.concat([testSocketCreation, testSending]);
+    } else if (test_type == 'https') {
+      https_address = parts[1];
+      https_port = parseInt(parts[2]);
+      console.log("Running tests for HTTPS, server " +
+          https_address + ":" + https_port);
+      tests = tests.concat([testSecure]);
+    } else {
+      chrome.test.fail("Invalid test type: " + test_type);
+    }
   }
+  // Setup the suite-wide event listeners.
+  chrome.sockets.tcp.onReceive.addListener(dispatchSocketReceive);
+  chrome.sockets.tcp.onReceiveError.addListener(dispatchSocketReceiveError);
+
+  chrome.test.runTests(tests);
 };
 
 // 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);