Converted remoting.Error from an enum to a class

remoting/webapp/crd/js/xmpp_login_handler.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 133 matching lines @@
 /**
  * @param {Element} stanza
  * @private
  */
 remoting.XmppLoginHandler.prototype.onStanza_ = function(stanza) {
   switch (this.state_) {
     case remoting.XmppLoginHandler.State.WAIT_STREAM_HEADER:
       if (stanza.querySelector('features>starttls')) {
         this.state_ = remoting.XmppLoginHandler.State.WAIT_STARTTLS_RESPONSE;
       } else {
-        this.onError_(remoting.Error.UNEXPECTED, "Server doesn't support TLS.");
+        this.onError_(
+            remoting.Error.unexpected(),
+            "Server doesn't support TLS.");
       }
       break;
 
     case remoting.XmppLoginHandler.State.WAIT_STARTTLS_RESPONSE:
       if (stanza.localName == "proceed") {
         this.state_ = remoting.XmppLoginHandler.State.STARTING_TLS;
         this.startTlsCallback_();
       } else {
-        this.onError_(remoting.Error.UNEXPECTED,
+        this.onError_(remoting.Error.unexpected(),
                       "Failed to start TLS: " +
                           (new XMLSerializer().serializeToString(stanza)));
       }
       break;
 
     case remoting.XmppLoginHandler.State.WAIT_STREAM_HEADER_AFTER_TLS:
       var mechanisms = Array.prototype.map.call(
           stanza.querySelectorAll('features>mechanisms>mechanism'),
           /** @param {Element} m */
           function(m) { return m.textContent; });
       if (mechanisms.indexOf("X-OAUTH2")) {
-        this.onError_(remoting.Error.UNEXPECTED,
+        this.onError_(remoting.Error.unexpected(),
                       "OAuth2 is not supported by the server.");
         return;
       }
 
       this.state_ = remoting.XmppLoginHandler.State.WAIT_AUTH_RESULT;
 
       break;
 
     case remoting.XmppLoginHandler.State.WAIT_AUTH_RESULT:
       if (stanza.localName == 'success') {
         this.state_ =
             remoting.XmppLoginHandler.State.WAIT_STREAM_HEADER_AFTER_AUTH;
         this.startStream_(
             '<iq type="set" id="0">' +
               '<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind">' +
                 '<resource>chromoting</resource>'+
               '</bind>' +
             '</iq>' +
             '<iq type="set" id="1">' +
               '<session xmlns="urn:ietf:params:xml:ns:xmpp-session"/>' +
             '</iq>');
       } else {
-        this.onError_(remoting.Error.AUTHENTICATION_FAILED,
-                      'Failed to authenticate: ' +
-                          (new XMLSerializer().serializeToString(stanza)));
+        this.onError_(
+            new remoting.Error(remoting.Error.Tag.AUTHENTICATION_FAILED),
+            'Failed to authenticate: ' +
+              (new XMLSerializer().serializeToString(stanza)));
       }
       break;
 
     case remoting.XmppLoginHandler.State.WAIT_STREAM_HEADER_AFTER_AUTH:
       if (stanza.querySelector('features>bind')) {
         this.state_ = remoting.XmppLoginHandler.State.WAIT_BIND_RESULT;
       } else {
-        this.onError_(remoting.Error.UNEXPECTED,
+        this.onError_(remoting.Error.unexpected(),
                       "Server doesn't support bind after authentication.");
       }
       break;
 
     case remoting.XmppLoginHandler.State.WAIT_BIND_RESULT:
       var jidElement = stanza.querySelector('iq>bind>jid');
       if (stanza.getAttribute('id') != '0' ||
           stanza.getAttribute('type') != 'result' || !jidElement) {
-        this.onError_(remoting.Error.UNEXPECTED,
+        this.onError_(remoting.Error.unexpected(),
                       'Received unexpected response to bind: ' +
                           (new XMLSerializer().serializeToString(stanza)));
         return;
       }
       this.jid_ = jidElement.textContent;
       this.state_ = remoting.XmppLoginHandler.State.WAIT_SESSION_IQ_RESULT;
       break;
 
     case remoting.XmppLoginHandler.State.WAIT_SESSION_IQ_RESULT:
       if (stanza.getAttribute('id') != '1' ||
           stanza.getAttribute('type') != 'result') {
-        this.onError_(remoting.Error.UNEXPECTED,
+        this.onError_(remoting.Error.unexpected(),
                       'Failed to start session: ' +
                           (new XMLSerializer().serializeToString(stanza)));
         return;
       }
       this.state_ = remoting.XmppLoginHandler.State.DONE;
       this.onHandshakeDoneCallback_(this.jid_, this.streamParser_);
       break;
 
     default:
       base.debug.assert(false);
@@ skipping 16 matching lines @@
              'xmlns:auth="http://www.google.com/talk/protocol/auth">' +
         cookie +
       '</auth>');
 };
 
 /**
  * @param {string} text
  * @private
  */
 remoting.XmppLoginHandler.prototype.onParserError_ = function(text) {
-  this.onError_(remoting.Error.UNEXPECTED, text);
+  this.onError_(remoting.Error.unexpected(), text);
 }
 
 /**
  * @param {string} firstMessage Message to send after stream header.
  * @private
  */
 remoting.XmppLoginHandler.prototype.startStream_ = function(firstMessage) {
   this.sendMessageCallback_('<stream:stream to="' + this.server_ +
                             '" version="1.0" xmlns="jabber:client" ' +
                             'xmlns:stream="http://etherx.jabber.org/streams">' +
                             firstMessage);
   this.streamParser_ = new remoting.XmppStreamParser();
   this.streamParser_.setCallbacks(this.onStanza_.bind(this),
                                   this.onParserError_.bind(this));
 }
 
 /**
  * @param {!remoting.Error} error
  * @param {string} text
  * @private
  */
 remoting.XmppLoginHandler.prototype.onError_ = function(error, text) {
   if (this.state_ != remoting.XmppLoginHandler.State.ERROR) {
     this.onErrorCallback_(error, text);
     this.state_ = remoting.XmppLoginHandler.State.ERROR;
   } else {
     console.error(text);
   }
 }