Merge pull request #22 from whiteout-io/dev/WO-995

[WO-995] Use workaround for native chrome.sockets.tcp.secure for TLS

Author: Tankred Hase

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tcp-socket",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "main": "src/tcp-socket",
   "description": "This shim brings the W3C Raw Socket API to node.js and Chromium. Its purpose is to enable apps to use the same api in Firefox OS, Chrome OS, and on the server.",
   "repository": {

src/tcp-socket.js

@@ -490,14 +490,16 @@
                     }
                 });
 
-                chrome.sockets.tcp.connect(self._socketId, self.host, self.port, function(result) {
-                    if (result < 0) {
-                        self.readyState = 'closed';
-                        self._emit('error', new Error('Unable to connect'));
-                        return;
-                    }
+                chrome.sockets.tcp.setPaused(self._socketId, true, function() {
+                    chrome.sockets.tcp.connect(self._socketId, self.host, self.port, function(result) {
+                        if (result < 0) {
+                            self.readyState = 'closed';
+                            self._emit('error', new Error('Unable to connect'));
+                            return;
+                        }
 
-                    self._onSocketConnected();
+                        self._onSocketConnected();
+                    });
                 });
             });
         };
@@ -510,25 +512,24 @@
         TCPSocket.prototype._onSocketConnected = function() {
             var self = this;
 
+            if (!self._useTLS) {
+                return read();
+            }
+
             // do an immediate TLS handshake if self._useTLS === true
-            if (self._useTLS) {
-                self._upgradeToSecure(function() {
-                    if (!self._useForgeTls) {
-                        // chrome.socket is up and running by now, while forge needs to be
-                        // fed traffic and emits 'open' at a later point
-                        self._emit('open');
+            self._upgradeToSecure(function() {
+                read();
+            });
 
-                        // the tls handshake is done let's start reading from the legacy socket
-                        if (self._useLegacySocket) {
-                            self._readLegacySocket();
-                        }
-                    }
-                });
-            } else {
-                // socket is up and running
-                self._emit('open');
+            function read() {
                 if (self._useLegacySocket) {
-                    self._readLegacySocket(); // let's start reading
+                    // the tls handshake is done let's start reading from the legacy socket
+                    self._readLegacySocket();
+                    self._emit('open');
+                } else {
+                    chrome.sockets.tcp.setPaused(self._socketId, false, function() {
+                        self._emit('open');
+                    });
                 }
             }
         };
@@ -542,14 +543,17 @@
 
             callback = callback || function() {};
 
-            if (self._useForgeTls) {
-                // setup the forge tls client or webworker as tls fallback
-                createTls.bind(self)();
-                callback();
-            } else if (!self._useLegacySocket) {
+            if (!self._useLegacySocket && self.readyState !== 'open') {
+                // use chrome.sockets.tcp.secure for TLS, not for STARTTLS!
+                // use forge only for STARTTLS
+                self._useForgeTls = false;
                 chrome.sockets.tcp.secure(self._socketId, onUpgraded);
             } else if (self._useLegacySocket) {
                 chrome.socket.secure(self._socketId, onUpgraded);
+            } else if (self._useForgeTls) {
+                // setup the forge tls client or webworker as tls fallback
+                createTls.bind(self)();
+                callback();
             }
 
             // invoked after chrome.socket.secure or chrome.sockets.tcp.secure have been upgraded

test/unit/tcp-socket-browser-test.js

@@ -131,15 +131,16 @@ define(function(require) {
         describe('chrome.sockets', function() {
             beforeEach(function() {
                 // create chrome.socket stub
-                var ChromeLegacySocket = function() {};
-                ChromeLegacySocket.prototype.create = function() {};
-                ChromeLegacySocket.prototype.connect = function() {};
-                ChromeLegacySocket.prototype.disconnect = function() {};
-                ChromeLegacySocket.prototype.send = function() {};
-                ChromeLegacySocket.prototype.secure = function() {};
+                var ChromeSocket = function() {};
+                ChromeSocket.prototype.create = function() {};
+                ChromeSocket.prototype.connect = function() {};
+                ChromeSocket.prototype.disconnect = function() {};
+                ChromeSocket.prototype.send = function() {};
+                ChromeSocket.prototype.secure = function() {};
+                ChromeSocket.prototype.setPaused = function() {};
 
                 window.chrome.socket = undefined;
-                socketStub = sinon.createStubInstance(ChromeLegacySocket);
+                socketStub = sinon.createStubInstance(ChromeSocket);
                 window.chrome.sockets = {
                     tcp: socketStub
                 };
@@ -159,7 +160,7 @@ define(function(require) {
                                 socketId: 42,
                                 data: testData.buffer
                             });
-                        }, 10);
+                        }, 50);
                     }
                 };
 
@@ -172,6 +173,8 @@ define(function(require) {
                 });
                 socketStub.connect.withArgs(42, '127.0.0.1', 9000).yieldsAsync(0);
                 socketStub.secure.withArgs(42).yieldsAsync(0);
+                socketStub.setPaused.withArgs(42, true).yieldsAsync();
+                socketStub.setPaused.withArgs(42, false).yieldsAsync();
                 socketStub.send.withArgs(42).yieldsAsync({
                     bytesWritten: 3
                 });
@@ -211,12 +214,13 @@ define(function(require) {
                     expect(socketStub.secure.called).to.be.false;
                     expect(socketStub.send.calledOnce).to.be.true;
                     expect(socketStub.disconnect.calledOnce).to.be.true;
+                    expect(socketStub.setPaused.calledTwice).to.be.true;
 
                     done();
                 };
             });
 
-            it.skip('should open, read, write, close with ssl', function(done) {
+            it('should open, read, write, close with ssl', function(done) {
                 var sent = false;
 
                 socket = TcpSocket.open('127.0.0.1', 9000, {
@@ -250,6 +254,7 @@ define(function(require) {
                     expect(socketStub.secure.calledOnce).to.be.true;
                     expect(socketStub.send.calledOnce).to.be.true;
                     expect(socketStub.disconnect.calledOnce).to.be.true;
+                    expect(socketStub.setPaused.calledTwice).to.be.true;
 
                     done();
                 };