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 || {};
 
 /**
@@ skipping 28 matching lines @@
   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;
 };
 
 /**
  * @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
@@ skipping 80 matching lines @@
  * @param {number} result
  * @private
  */
 remoting.XmppConnection.prototype.onSocketConnected_ = function(result) {
   // Check if connection was destroyed.
   if (this.state_ != remoting.SignalStrategy.State.CONNECTING) {
     return;
   }
 
   if (result != 0) {
-    this.onError_(remoting.Error.NETWORK_FAILURE,
+    this.onError_(new remoting.Error(remoting.Error.Tag.NETWORK_FAILURE),
                   'Failed to connect to ' + this.server_ + ': ' +  result);
     return;
   }
 
   this.setState_(remoting.SignalStrategy.State.HANDSHAKE);
   this.loginHandler_.start();
 
   if (!this.startTlsPending_) {
     this.tryRead_();
   }
@@ skipping 20 matching lines @@
   base.debug.assert(this.readPending_);
   this.readPending_ = false;
 
   // Check if the socket was closed while reading.
   if (this.state_ != remoting.SignalStrategy.State.HANDSHAKE &&
       this.state_ != remoting.SignalStrategy.State.CONNECTED) {
     return;
   }
 
   if (readInfo.resultCode < 0) {
-    this.onError_(remoting.Error.NETWORK_FAILURE,
+    this.onError_(new remoting.Error(remoting.Error.Tag.NETWORK_FAILURE),
                   'Failed to receive from XMPP socket: ' + readInfo.resultCode);
     return;
   }
 
   if (this.state_ == remoting.SignalStrategy.State.HANDSHAKE) {
     this.loginHandler_.onDataReceived(readInfo.data);
   } else if (this.state_ == remoting.SignalStrategy.State.CONNECTED) {
     this.streamParser_.appendData(readInfo.data);
   }
 
@@ skipping 41 matching lines @@
   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,
+    this.onError_(new remoting.Error(remoting.Error.Tag.NETWORK_FAILURE),
                   'TCP write failed with error ' + writeInfo.bytesWritten);
     return;
   }
 
   base.debug.assert(this.sendQueue_.length > 0);
 
   var data = this.sendQueue_[0]
   base.debug.assert(writeInfo.bytesWritten <= data.byteLength);
   if (writeInfo.bytesWritten == data.byteLength) {
     this.sendQueue_.shift();
@@ skipping 18 matching lines @@
 
 /**
  * @param {number} resultCode
  * @private
  */
 remoting.XmppConnection.prototype.onTlsStarted_ = function(resultCode) {
   base.debug.assert(this.startTlsPending_);
   this.startTlsPending_ = false;
 
   if (resultCode < 0) {
-    this.onError_(remoting.Error.NETWORK_FAILURE,
+    this.onError_(new remoting.Error(remoting.Error.Tag.NETWORK_FAILURE),
                   'Failed to start TLS: ' + resultCode);
     return;
   }
 
   this.tryRead_();
   this.loginHandler_.onTlsStarted();
 };
 
 /**
  * @param {string} jid
@@ skipping 17 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;
@@ skipping 14 matching lines @@
 /**
  * @param {remoting.SignalStrategy.State} newState
  * @private
  */
 remoting.XmppConnection.prototype.setState_ = function(newState) {
   if (this.state_ != newState) {
     this.state_ = newState;
     this.onStateChangedCallback_(this.state_);
   }
 };