Updated remoting.xhr API to use promises. Removed access to the native

remoting/webapp/crd/js/host_controller.js

 // Copyright (c) 2012 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 || {};
 
 /** @constructor */
@@ skipping 140 matching lines @@
   /**
    * @param {string} hostName
    * @param {string} publicKey
    * @param {remoting.HostController.AsyncResult} result
    */
   function onStarted(hostName, publicKey, result) {
     if (result == remoting.HostController.AsyncResult.OK) {
       remoting.hostList.onLocalHostStarted(hostName, newHostId, publicKey);
       onDone();
     } else if (result == remoting.HostController.AsyncResult.CANCELLED) {
-      onStartError(remoting.Error.CANCELLED);
+      onStartError(new remoting.Error(remoting.Error.Tag.CANCELLED));
     } else {
-      onStartError(remoting.Error.UNEXPECTED);
+      onStartError(remoting.Error.unexpected());
     }
   }
 
   /**
    * @param {string} hostName
    * @param {string} publicKey
    * @param {string} privateKey
    * @param {?string} xmppLogin
    * @param {?string} refreshToken
    * @param {?string} clientBaseJid
@@ skipping 53 matching lines @@
     that.getClientBaseJid_(
         onClientBaseJid.bind(
             null, hostName, publicKey, privateKey, email, refreshToken),
         onStartError);
   }
 
   /**
    * @param {string} hostName
    * @param {string} publicKey
    * @param {string} privateKey
-   * @param {XMLHttpRequest} xhr
+   * @param {!remoting.Xhr.Response} response
    */
   function onRegistered(
-      hostName, publicKey, privateKey, xhr) {
-    var success = (xhr.status == 200);
+      hostName, publicKey, privateKey, response) {
+    var success = (response.status == 200);
 
     if (success) {
-      var result = base.jsonParseSafe(xhr.responseText);
+      var result = base.jsonParseSafe(response.getText());
       if ('data' in result && 'authorizationCode' in result['data']) {
         that.hostDaemonFacade_.getCredentialsFromAuthCode(
             result['data']['authorizationCode'],
             onServiceAccountCredentials.bind(
                 null, hostName, publicKey, privateKey),
             onError);
       } else {
         // No authorization code returned, use regular user credential flow.
         remoting.identity.getEmail().then(
             function(/** string */ email) {
               that.hostDaemonFacade_.getPinHash(
                   newHostId, hostPin, startHostWithHash.bind(
                       null, hostName, publicKey, privateKey,
                       email, remoting.oauth2.getRefreshToken(), email),
                   onError);
             });
       }
     } else {
-      console.log('Failed to register the host. Status: ' + xhr.status +
-                  ' response: ' + xhr.responseText);
-      onError(remoting.Error.REGISTRATION_FAILED);
+      console.log('Failed to register the host. Status: ' + response.status +
+                  ' response: ' + response.getText());
+      onError(new remoting.Error(remoting.Error.Tag.REGISTRATION_FAILED));
     }
   }
 
   /**
    * @param {string} hostName
    * @param {string} privateKey
    * @param {string} publicKey
    * @param {?string} hostClientId
    * @param {string} oauthToken
    */
   function doRegisterHost(
       hostName, privateKey, publicKey, hostClientId, oauthToken) {
     var newHostDetails = { data: {
        hostId: newHostId,
        hostName: hostName,
        publicKey: publicKey
     } };
 
-    remoting.xhr.start({
+    new remoting.Xhr({
       method: 'POST',
       url: remoting.settings.DIRECTORY_API_BASE_URL + '/@me/hosts',
       urlParams: {
         hostClientId: hostClientId
       },
-      onDone: onRegistered.bind(null, hostName, publicKey, privateKey),
       jsonContent: newHostDetails,
       oauthToken: oauthToken
-    });
+    }).start().then(onRegistered.bind(null, hostName, publicKey, privateKey));
   }
 
   /**
    * @param {string} hostName
    * @param {string} privateKey
    * @param {string} publicKey
    * @param {string} hostClientId
    */
   function onHostClientId(
       hostName, privateKey, publicKey, hostClientId) {
@@ skipping 63 matching lines @@
       return;
     }
     onDone();
   }
 
   /** @param {remoting.HostController.AsyncResult} result */
   function onStopped(result) {
     if (result == remoting.HostController.AsyncResult.OK) {
       that.getLocalHostId(unregisterHost);
     } else if (result == remoting.HostController.AsyncResult.CANCELLED) {
-      onError(remoting.Error.CANCELLED);
+      onError(new remoting.Error(remoting.Error.Tag.CANCELLED));
     } else {
-      onError(remoting.Error.UNEXPECTED);
+      onError(remoting.Error.unexpected());
     }
   }
 
   this.hostDaemonFacade_.stopDaemon(onStopped, onError);
 };
 
 /**
  * Check the host configuration is valid (non-null, and contains both host_id
  * and xmpp_login keys).
  * @param {Object} config The host configuration.
@@ skipping 14 matching lines @@
 remoting.HostController.prototype.updatePin = function(newPin, onDone,
                                                        onError) {
   /** @type {remoting.HostController} */
   var that = this;
 
   /** @param {remoting.HostController.AsyncResult} result */
   function onConfigUpdated(result) {
     if (result == remoting.HostController.AsyncResult.OK) {
       onDone();
     } else if (result == remoting.HostController.AsyncResult.CANCELLED) {
-      onError(remoting.Error.CANCELLED);
+      onError(new remoting.Error(remoting.Error.Tag.CANCELLED));
     } else {
-      onError(remoting.Error.UNEXPECTED);
+      onError(remoting.Error.unexpected());
     }
   }
 
   /** @param {string} pinHash */
   function updateDaemonConfigWithHash(pinHash) {
     var newConfig = {
       host_secret_hash: pinHash
     };
     that.hostDaemonFacade_.updateDaemonConfig(newConfig, onConfigUpdated,
                                             onError);
   }
 
   /** @param {Object} config */
   function onConfig(config) {
     if (!isHostConfigValid_(config)) {
-      onError(remoting.Error.UNEXPECTED);
+      onError(remoting.Error.unexpected());
       return;
     }
     /** @type {string} */
     var hostId = config['host_id'];
     that.hostDaemonFacade_.getPinHash(
         hostId, newPin, updateDaemonConfigWithHash, onError);
   }
 
   // TODO(sergeyu): When crbug.com/121518 is fixed: replace this call
   // with an unprivileged version if that is necessary.
   this.hostDaemonFacade_.getDaemonConfig(onConfig, onError);
 };
 
 /**
  * Get the state of the local host.
  *
  * @param {function(remoting.HostController.State):void} onDone Completion
  *     callback.
  */
 remoting.HostController.prototype.getLocalHostState = function(onDone) {
   /** @param {!remoting.Error} error */
   function onError(error) {
-    onDone((error.tag == remoting.Error.Tag.MISSING_PLUGIN) ?
+    onDone((error.hasTag(remoting.Error.Tag.MISSING_PLUGIN)) ?
                remoting.HostController.State.NOT_INSTALLED :
                remoting.HostController.State.UNKNOWN);
   }
   this.hostDaemonFacade_.getDaemonState(onDone, onError);
 };
 
 /**
  * Get the id of the local host, or null if it is not registered.
  *
  * @param {function(string?):void} onDone Completion callback.
@@ skipping 102 matching lines @@
   function connectSignalingWithTokenAndEmail(token, email) {
     signalStrategy.connect(remoting.settings.XMPP_SERVER, email, token);
   }
 
   remoting.identity.getToken().then(
       connectSignalingWithToken, remoting.Error.handler(onError));
 };
 
 /** @type {remoting.HostController} */
 remoting.hostController = null;