Eliminated named constants for instances of remoting.Error.

remoting/webapp/crd/js/xmpp_connection.js

 // Copyright 2014 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.
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * A connection to an XMPP server.
  *
+ * TODO(sergeyu): Chrome provides two APIs for TCP sockets: chrome.socket and
+ * chrome.sockets.tcp . chrome.socket is deprecated but it's still used here
+ * because TLS support in chrome.sockets.tcp is currently broken, see
+ * crbug.com/403076 .
+ *
  * @constructor
  * @implements {remoting.SignalStrategy}
  */
 remoting.XmppConnection = function() {
   /** @private */
   this.server_ = '';
   /** @private */
   this.port_ = 0;
   /** @private {?function(remoting.SignalStrategy.State):void} */
   this.onStateChangedCallback_ = null;
   /** @private {?function(Element):void} */
   this.onIncomingStanzaCallback_ = null;
-  /** @type {?remoting.TcpSocket} @private */
-  this.socket_ = null;
+  /** @private */
+  this.socketId_ = -1;
   /** @private */
   this.state_ = remoting.SignalStrategy.State.NOT_CONNECTED;
   /** @private */
+  this.readPending_ = false;
+  /** @private */
   this.sendPending_ = false;
   /** @private */
   this.startTlsPending_ = false;
   /** @private {Array<ArrayBuffer>} */
   this.sendQueue_ = [];
   /** @private {remoting.XmppLoginHandler} */
   this.loginHandler_ = null;
   /** @private {remoting.XmppStreamParser} */
   this.streamParser_ = null;
   /** @private */
   this.jid_ = '';
   /** @private */
-  this.error_ = remoting.Error.NONE;
+  this.error_ = remoting.Error.none();
 };
 
 /**
  * @param {function(remoting.SignalStrategy.State):void} onStateChangedCallback
  */
 remoting.XmppConnection.prototype.setStateChangedCallback = function(
     onStateChangedCallback) {
   this.onStateChangedCallback_ = onStateChangedCallback;
 };
 
-remoting.XmppConnection.prototype.setSocketForTests = function(
-    /** remoting.TcpSocket */ socket) {
-  this.socket_ = socket;
-};
-
 /**
  * @param {?function(Element):void} onIncomingStanzaCallback Callback to call on
  *     incoming messages.
  */
 remoting.XmppConnection.prototype.setIncomingStanzaCallback =
     function(onIncomingStanzaCallback) {
   this.onIncomingStanzaCallback_ = onIncomingStanzaCallback;
 };
 
 /**
  * @param {string} server
  * @param {string} username
  * @param {string} authToken
  */
 remoting.XmppConnection.prototype.connect =
     function(server, username, authToken) {
   base.debug.assert(this.state_ == remoting.SignalStrategy.State.NOT_CONNECTED);
   base.debug.assert(this.onStateChangedCallback_ != null);
 
-  this.error_ = remoting.Error.NONE;
+  this.error_ = remoting.Error.none();
   var hostnameAndPort = server.split(':', 2);
   this.server_ = hostnameAndPort[0];
   this.port_ =
       (hostnameAndPort.length == 2) ? parseInt(hostnameAndPort[1], 10) : 5222;
 
   // The server name is passed as to attribute in the <stream>. When connecting
   // to talk.google.com it affects the certificate the server will use for TLS:
   // talk.google.com uses gmail certificate when specified server is gmail.com
   // or googlemail.com and google.com cert otherwise. In the same time it
   // doesn't accept talk.google.com as target server. Here we use google.com
   // server name when authenticating to talk.google.com. This ensures that the
   // server will use google.com cert which will be accepted by the TLS
   // implementation in Chrome (TLS API doesn't allow specifying domain other
   // than the one that was passed to connect()).
   var xmppServer = this.server_;
   if (xmppServer == 'talk.google.com')
     xmppServer = 'google.com';
 
   // <starttls> handshake before starting TLS is not needed when connecting on
   // the HTTPS port.
   var needHandshakeBeforeTls = this.port_ != 443;
 
   /** @type {remoting.XmppLoginHandler} */
   this.loginHandler_ = new remoting.XmppLoginHandler(
       xmppServer, username, authToken, needHandshakeBeforeTls,
       this.sendString_.bind(this), this.startTls_.bind(this),
       this.onHandshakeDone_.bind(this), this.onError_.bind(this));
+  chrome.socket.create("tcp", {}, this.onSocketCreated_.bind(this));
   this.setState_(remoting.SignalStrategy.State.CONNECTING);
-
-  if (!this.socket_) {
-    this.socket_ = new remoting.TcpSocket();
-  }
-  var that = this;
-  this.socket_.connect(this.server_, this.port_)
-      .then(this.onSocketConnected_.bind(this))
-      .catch(function(error) {
-        that.onError_(remoting.Error.NETWORK_FAILURE,
-                      'Failed to connect to ' + that.server_ + ': ' + error);
-      });
 };
 
 /** @param {string} message */
 remoting.XmppConnection.prototype.sendMessage = function(message) {
   base.debug.assert(this.state_ == remoting.SignalStrategy.State.CONNECTED);
   this.sendString_(message);
 };
 
 /**
  * @param {remoting.LogToServer} logToServer The LogToServer instance for the
@@ skipping 17 matching lines @@
 remoting.XmppConnection.prototype.getJid = function() {
   return this.jid_;
 };
 
 /** @return {remoting.SignalStrategy.Type} The signal strategy type. */
 remoting.XmppConnection.prototype.getType = function() {
   return remoting.SignalStrategy.Type.XMPP;
 };
 
 remoting.XmppConnection.prototype.dispose = function() {
-  base.dispose(this.socket_);
-  this.socket_ = null;
+  this.closeSocket_();
   this.setState_(remoting.SignalStrategy.State.CLOSED);
 };
 
-/** @private */
-remoting.XmppConnection.prototype.onSocketConnected_ = function() {
+/**
+ * @param {chrome.socket.CreateInfo} createInfo
+ * @private
+ */
+remoting.XmppConnection.prototype.onSocketCreated_ = function(createInfo) {
   // Check if connection was destroyed.
   if (this.state_ != remoting.SignalStrategy.State.CONNECTING) {
     return;
   }
 
   this.setState_(remoting.SignalStrategy.State.HANDSHAKE);
   this.loginHandler_.start();
 
   if (!this.startTlsPending_) {
-    this.socket_.startReceiving(this.onReceive_.bind(this),
-                                this.onReceiveError_.bind(this));
+    this.tryRead_();
   }
 };
 
 /**
- * @param {ArrayBuffer} data
  * @private
  */
-remoting.XmppConnection.prototype.onReceive_ = function(data) {
+remoting.XmppConnection.prototype.tryRead_ = function() {
+  base.debug.assert(!this.readPending_);
   base.debug.assert(this.state_ == remoting.SignalStrategy.State.HANDSHAKE ||
                     this.state_ == remoting.SignalStrategy.State.CONNECTED);
+  base.debug.assert(!this.startTlsPending_);
 
-  if (this.state_ == remoting.SignalStrategy.State.HANDSHAKE) {
-    this.loginHandler_.onDataReceived(data);
-  } else if (this.state_ == remoting.SignalStrategy.State.CONNECTED) {
-    this.streamParser_.appendData(data);
-  }
+  this.readPending_ = true;
+  chrome.socket.read(this.socketId_, this.onRead_.bind(this));
 };
 
 /**
- * @param {number} errorCode
+ * @param {chrome.socket.ReadInfo} readInfo
  * @private
  */
 remoting.XmppConnection.prototype.onReceiveError_ = function(errorCode) {
-  this.onError_(remoting.Error.NETWORK_FAILURE,
-                'Failed to receive from XMPP socket: ' + errorCode);
+  this.onError_(
+      new remoting.Error(remoting.Error.Tag.NETWORK_FAILURE),
+      'Failed to receive from XMPP socket: ' + errorCode);
 };
 
 /**
  * @param {string} text
  * @private
  */
 remoting.XmppConnection.prototype.sendString_ = function(text) {
   this.sendBuffer_(base.encodeUtf8(text));
 };
 
 /**
  * @param {ArrayBuffer} data
  * @private
  */
 remoting.XmppConnection.prototype.sendBuffer_ = function(data) {
   this.sendQueue_.push(data);
   this.flushSendQueue_();
 };
 
 /**
  * @private
  */
 remoting.XmppConnection.prototype.flushSendQueue_ = function() {
   if (this.sendPending_ || this.sendQueue_.length == 0) {
     return;
   }
 
-  var that = this;
-
+  var data = this.sendQueue_[0]
   this.sendPending_ = true;
-  this.socket_.send(this.sendQueue_[0])
-      .then(function(/** number */ bytesSent) {
-        that.sendPending_ = false;
-        that.onSent_(bytesSent);
-      })
-      .catch(function(/** number */ error) {
-        that.sendPending_ = false;
-        that.onError_(remoting.Error.NETWORK_FAILURE,
-                      'TCP write failed with error ' + error);
-      });
+  chrome.socket.write(this.socketId_, data, this.onWrite_.bind(this));
 };
 
 /**
- * @param {number} bytesSent
+ * @param {chrome.socket.WriteInfo} writeInfo
  * @private
  */
-remoting.XmppConnection.prototype.onSent_ = function(bytesSent) {
-  // Ignore send() result if the socket was closed.
+remoting.XmppConnection.prototype.onWrite_ = function(writeInfo) {
+  base.debug.assert(this.sendPending_);
+  this.sendPending_ = false;
+
+  // Ignore write() result if the socket was closed.
   if (this.state_ != remoting.SignalStrategy.State.HANDSHAKE &&
       this.state_ != remoting.SignalStrategy.State.CONNECTED) {
     return;
   }
 
+  if (writeInfo.bytesWritten < 0) {
+    this.onError_(remoting.Error.NETWORK_FAILURE,

[Jamie, 2015/03/12 21:40:11]

The change (and the next) looks like it's going in the wrong direction. How did
it pass the compiler?

[John Williams, 2015/03/13 00:26:35]

Ugh. Long story. But you are correct.

+                  'TCP write failed with error ' + writeInfo.bytesWritten);
+    return;
+  }
+
   base.debug.assert(this.sendQueue_.length > 0);
 
-  var data = this.sendQueue_[0];
-  base.debug.assert(bytesSent <= data.byteLength);
-  if (bytesSent == data.byteLength) {
+  var data = this.sendQueue_[0]
+  base.debug.assert(writeInfo.bytesWritten <= data.byteLength);
+  if (writeInfo.bytesWritten == data.byteLength) {
     this.sendQueue_.shift();
   } else {
-    this.sendQueue_[0] = data.slice(data.byteLength - bytesSent);
+    this.sendQueue_[0] = data.slice(data.byteLength - writeInfo.bytesWritten);
   }
 
   this.flushSendQueue_();
 };
 
 /**
  * @private
  */
 remoting.XmppConnection.prototype.startTls_ = function() {
+  base.debug.assert(!this.readPending_);
   base.debug.assert(!this.startTlsPending_);
 
-  var that = this;
+  this.startTlsPending_ = true;
+  chrome.socket.secure(
+      this.socketId_, {}, this.onTlsStarted_.bind(this));
+}
 
-  this.startTlsPending_ = true;
-  this.socket_.startTls()
-      .then(function() {
-        that.startTlsPending_ = false;
-        that.socket_.startReceiving(that.onReceive_.bind(that),
-                                    that.onReceiveError_.bind(that));
+/**
+ * @param {number} resultCode
+ * @private
+ */
+remoting.XmppConnection.prototype.onTlsStarted_ = function(resultCode) {
+  base.debug.assert(this.startTlsPending_);
+  this.startTlsPending_ = false;
 
-        that.loginHandler_.onTlsStarted();
-      })
-      .catch(function(/** number */ error) {
-        that.startTlsPending_ = false;
-        that.onError_(remoting.Error.NETWORK_FAILURE,
-                      'Failed to start TLS: ' + error);
-      });
-}
+  if (resultCode < 0) {
+    this.onError_(remoting.Error.NETWORK_FAILURE,
+                  'Failed to start TLS: ' + resultCode);
+    return;
+  }
+
+  this.tryRead_();
+  this.loginHandler_.onTlsStarted();
+};
 
 /**
  * @param {string} jid
  * @param {remoting.XmppStreamParser} streamParser
  * @private
  */
 remoting.XmppConnection.prototype.onHandshakeDone_ =
     function(jid, streamParser) {
   this.jid_ = jid;
   this.streamParser_ = streamParser;
@@ skipping 10 matching lines @@
   if (this.onIncomingStanzaCallback_) {
     this.onIncomingStanzaCallback_(stanza);
   }
 };
 
 /**
  * @param {string} text
  * @private
  */
 remoting.XmppConnection.prototype.onParserError_ = function(text) {
-  this.onError_(remoting.Error.UNEXPECTED, text);
+  this.onError_(remoting.Error.unexpected(), text);
 }
 
 /**
  * @param {!remoting.Error} error
  * @param {string} text
  * @private
  */
 remoting.XmppConnection.prototype.onError_ = function(error, text) {
   console.error(text);
   this.error_ = error;
-  base.dispose(this.socket_);
-  this.socket_ = null;
+  this.closeSocket_();
   this.setState_(remoting.SignalStrategy.State.FAILED);
 };
 
 /**
+ * @private
+ */
+remoting.XmppConnection.prototype.closeSocket_ = function() {
+  if (this.socketId_ != -1) {
+    chrome.socket.destroy(this.socketId_);
+    this.socketId_ = -1;
+  }
+};
+
+/**
  * @param {remoting.SignalStrategy.State} newState
  * @private
  */
 remoting.XmppConnection.prototype.setState_ = function(newState) {
   if (this.state_ != newState) {
     this.state_ = newState;
     this.onStateChangedCallback_(this.state_);
   }
 };