Eliminated named constants for instances of remoting.Error.

remoting/webapp/base/js/application.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
  * Interface abstracting the Application functionality.
  */
 
 'use strict';
@@ skipping 76 matching lines @@
   remoting.initGlobalObjects();
   remoting.initIdentity();
 
   this.delegate_.init();
 
   var that = this;
   remoting.identity.getToken().then(
       this.delegate_.start.bind(this.delegate_, this.getSessionConnector())
   ).catch(remoting.Error.handler(
       function(/** !remoting.Error */ error) {
-        if (error == remoting.Error.CANCELLED) {
+        if (error.hasTag(remoting.Error.Tag.CANCELLED)) {

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

TBH, I have no problem with == (or === since it seems like the old code wasn't
consistent) here, but if you feel it's better encapsulated by hasTag, then the
tag member should probably be private.

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

I wanted to discourage == or === in new code since it's easy to forget that
Error objects and error tags aren't comparable, and the compiler offers to help.

I had to add a getting and move some code from another file to make this work. 
What do you think of the result?

[Jamie, 2015/03/13 17:56:16]

What does the compiler do if you try to use == between a Error and a tag?
I think a straight getter would be cleaner. See my comments on that file.

[John Williams, 2015/03/13 19:30:29]

Nothing :-)  It compiles it just fine, but the comparison will always be false. 
Might be worth a feature request to the compiler team.

           that.exit();
         } else {
           that.delegate_.signInFailed(error);
         }
       }
     )
   );
 };
 
 /**
  * Quit the application.
  */
 remoting.Application.prototype.exit = function() {
   this.delegate_.handleExit();
   chrome.app.window.current().close();
 };
 
 /** Disconnect the remoting client. */
 remoting.Application.prototype.disconnect = function() {
   if (remoting.clientSession) {
-    remoting.clientSession.disconnect(remoting.Error.NONE);
+    remoting.clientSession.disconnect(remoting.Error.none());
     console.log('Disconnected.');
   }
 };
 
 /**
  * Called when a new session has been connected.
  *
  * @param {remoting.ClientSession} clientSession
  * @return {void} Nothing.
  */
@@ skipping 100 matching lines @@
 remoting.Application.prototype.onClientStateChange_ = function(state) {
   switch (state.current) {
     case remoting.ClientSession.State.CLOSED:
       console.log('Connection closed by host');
       this.onDisconnected();
       break;
     case remoting.ClientSession.State.FAILED:
       var error = remoting.clientSession.getError();
       console.error('Client plugin reported connection failed: ' + error);
       if (error === null) {
-        error = remoting.Error.UNEXPECTED;
+        error = remoting.Error.unexpected();
       }
       this.onError(error);
       break;
 
     default:
       console.error('Unexpected client plugin state: ' + state.current);
       // This should only happen if the web-app and client plugin get out of
       // sync, so MISSING_PLUGIN is a suitable error.
-      this.onError(remoting.Error.MISSING_PLUGIN);
+      this.onError(new remoting.Error(remoting.Error.Tag.MISSING_PLUGIN));
       break;
   }
 
   base.dispose(this.sessionConnectedHooks_);
   this.sessionConnectedHooks_= null;
   remoting.clientSession.dispose();
   remoting.clientSession = null;
 };
 
 /** @private */
@@ skipping 101 matching lines @@
  * Perform any application-specific cleanup before exiting. This is called in
  * lieu of start() if the user declines the app permissions, and will usually
  * be called immediately prior to exiting, although delegates should not rely
  * on this.
  */
 remoting.Application.Delegate.prototype.handleExit = function() {};
 
 
 /** @type {remoting.Application} */
 remoting.app = null;