Converted remoting.Error from an enum to a class

remoting/webapp/crd/js/it2me_helpee_channel.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.
 
 /**
  * @fileoverview
  *
  * It2MeHelpeeChannel relays messages between the Hangouts web page (Hangouts)
  * and the It2Me Native Messaging Host (It2MeHost) for the helpee (the Hangouts
  * participant who is receiving remoting assistance).
@@ skipping 170 matching lines @@
         this.handleDownloadHost_(message);
         return true;
       case MessageTypes.CONNECT:
         this.handleConnect_(message);
         return true;
       case MessageTypes.DISCONNECT:
         this.dispose();
         return true;
     }
     throw new Error('Unsupported message method=' + message.method);
-  } catch(/** @type {Error} */ error) {
-    this.sendErrorResponse_(message, error.message);
+  } catch(/** @type {!Error} */ error) {
+    this.sendErrorResponse_(message, error);
   }
   return false;
 };
 
 /**
  * Queries the |hostInstaller| for the installation status.
  *
  * @param {{method:string, data:Object<string,*>}} message
  * @private
  */
@@ skipping 17 matching lines @@
   );
 };
 
 /**
  * @param {{method:string, data:Object<string,*>}} message
  * @private
  */
 remoting.It2MeHelpeeChannel.prototype.handleDownloadHost_ = function(message) {
   try {
     this.hostInstaller_.download();
-  } catch (/** @type {*} */ e) {
-    var error = /** @type {Error} */ (e);
-    this.sendErrorResponse_(message, error.message);
+  } catch (/** @type {!Error} */ error) {
+    this.sendErrorResponse_(message, error);
   }
 };
 
 /**
  * Disconnect the session if the |hangoutPort| gets disconnected.
  * @private
  */
 remoting.It2MeHelpeeChannel.prototype.onHangoutDisconnect_ = function() {
   this.dispose();
 };
@@ skipping 14 matching lines @@
   }
 
   var that = this;
   this.showConfirmDialog_(bounds)
       .then(this.initializeHost_.bind(this))
       .then(this.fetchOAuthToken_.bind(this))
       .then(this.fetchEmail_.bind(this))
       /** @param {{email:string, token:string}|Promise} result */
       .then(function(result) {
         that.connectToHost_(result.email, result.token);
-      /** @param {*} reason */
-      }).catch(function(reason) {
-        that.sendErrorResponse_(message, /** @type {Error} */ (reason));
+      }).catch(function(/** !Error */ reason) {

[Jamie, 2015/03/02 18:28:10]

Missing @type?

Also, I thought we had problems with 'catch' as a function name? Is that fixed
in the new jscompile?

[John Williams, 2015/03/02 22:01:37]

Yeah, it's fixed now, and the abbreviates type syntax works here because it's a
function.  It doesn't work in real "catch" clauses, though.

+        that.sendErrorResponse_(message, reason);
         that.dispose();
       });
 };
 
 /**
  * Prompts the user before starting the It2Me Native Messaging Host.  This
  * ensures that even if Hangouts is compromised, an attacker cannot start the
  * host without explicit user confirmation.
  *
  * @param {Bounds} bounds Bounds of the hangout window
@@ skipping 21 matching lines @@
       /*i18n-content*/'HANGOUTS_CONFIRM_DIALOG_MESSAGE_2');
   var message2 = l10n.getTranslationOrError(
       /*i18n-content*/'HANGOUTS_CONFIRM_DIALOG_MESSAGE_3');
   var message = base.escapeHTML(messageHeader) + '\n' +
                 '- ' + base.escapeHTML(message1) + '\n' +
                 '- ' + base.escapeHTML(message2) + '\n';
 
   if(window.confirm(message)) {
     return Promise.resolve();
   } else {
-    return Promise.reject(new Error(remoting.Error.CANCELLED));
+    return Promise.reject(remoting.Error.CANCELLED);
   }
 };
 
 /**
  * @param {Bounds} bounds the bounds of the Hangouts Window.  If set, the
  *   confirm dialog will be centered within |bounds|.
  * @return {Promise} A promise that will resolve if the user accepts remote
  *   assistance or reject otherwise.
  * @private
  */
@@ skipping 33 matching lines @@
 
 /**
  * @return {!Promise<string>} Promise that resolves with the OAuth token as the
  * value.
  */
 remoting.It2MeHelpeeChannel.prototype.fetchOAuthToken_ = function() {
   if (base.isAppsV2()) {
     return remoting.identity.getToken();
   } else {
       var onError = function(/** * */ error) {
-        if (error === remoting.Error.NOT_AUTHENTICATED) {
+        if (error instanceof remoting.Error &&
+            /** @type {!remoting.Error} */ (error).tag ===
+            remoting.Error.Tag.NOT_AUTHENTICATED) {
           return new Promise(function(resolve, reject) {
             remoting.oauth2.doAuthRedirect(function() {
               remoting.identity.getToken().then(resolve);
             });
           });
         }
-        throw Error(remoting.Error.NOT_AUTHENTICATED);
+        throw remoting.Error.NOT_AUTHENTICATED;
       };
     return /** @type {!Promise<string>} */ (
         remoting.identity.getToken().catch(onError));
   }
 };
 
 /**
  * @param {string|Promise} token
  * @return {Promise} Promise that resolves with the access token and the email
  *   of the user.
@@ skipping 23 matching lines @@
     this.onHostStateChanged_.bind(this),
     base.doNothing, // Ignore |onNatPolicyChanged|.
     console.log.bind(console), // Forward logDebugInfo to console.log.
     remoting.settings.XMPP_SERVER_FOR_IT2ME_HOST,
     remoting.settings.XMPP_SERVER_USE_TLS,
     remoting.settings.DIRECTORY_BOT_JID,
     this.onHostConnectError_);
 };
 
 /**
- * @param {remoting.Error} error
+ * @param {!remoting.Error} error
  * @private
  */
 remoting.It2MeHelpeeChannel.prototype.onHostConnectError_ = function(error) {
   this.sendErrorResponse_(null, error);
 };
 
 /**
  * @param {remoting.HostSession.State} state
  * @private
  */
@@ skipping 23 matching lines @@
     case HostState.INVALID_DOMAIN_ERROR:
       this.sendErrorResponse_(null, remoting.Error.INVALID_HOST_DOMAIN);
       break;
     default:
       // It is safe to ignore other state changes.
   }
 };
 
 /**
  * @param {?{method:string, data:Object<string,*>}} incomingMessage
- * @param {string|Error} error
+ * @param {!remoting.Error|!Error} error
  * @private
  */
 remoting.It2MeHelpeeChannel.prototype.sendErrorResponse_ =
     function(incomingMessage, error) {
+  /** @type {string} */
+  var errorMessage;
+
   if (error instanceof Error) {
-    error = error.message;
+    errorMessage = error.message;
+  } else {
+    errorMessage = error.tag;
   }
 
   console.error('Error responding to message method:' +
                 (incomingMessage ? incomingMessage.method : 'null') +
-                ' error:' + error);
+                ' error:' + errorMessage);
   this.hangoutPort_.postMessage({
     method: remoting.It2MeHelpeeChannel.HangoutMessageTypes.ERROR,
-    message: error,
+    message: errorMessage,
     request: incomingMessage
   });
 };