Refactored HostDaemonFacade so that replies to requests are handled in

remoting/webapp/crd/js/host_daemon_facade.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
  * Class to communicate with the host daemon via Native Messaging.
  */
 
 'use strict';
@@ skipping 66 matching lines @@
 };
 
 /**
  * Connects to the native messaging host and sends a hello message.
  *
  * @return {Promise} A promise that fulfills when the connection attempt
  *     succeeds or fails.
  * @private
  */
 remoting.HostDaemonFacade.prototype.connectNative_ = function() {
+  var that = this;
   try {
     this.port_ = chrome.runtime.connectNative(
         'com.google.chrome.remote_desktop');
     this.port_.onMessage.addListener(this.onIncomingMessageCallback_);
     this.port_.onDisconnect.addListener(this.onDisconnectCallback_);
-    return this.postMessageInternal_({type: 'hello'});
+    return this.postMessageInternal_({type: 'hello'}).then(function(reply) {
+      that.version_ = base.getStringAttr(reply, 'version');
+      // Old versions of the native messaging host do not return this list.
+      // Those versions default to the empty list of supported features.
+      that.supportedFeatures_ =
+          base.getArrayAttr(reply, 'supportedFeatures', []);
+    });
   } catch (/** @type {*} */ err) {
     console.log('Native Messaging initialization failed: ', err);
     throw remoting.Error.unexpected();
   }
 };
 
 /**
  * Type used for entries of |pendingReplies_| list.
  *
  * @param {string} type Type of the originating request.
@@ skipping 21 matching lines @@
     return that.supportedFeatures_.indexOf(feature) >= 0;
   }, function () {
     return false;
   });
 };
 
 /**
  * Initializes that the Daemon if necessary and posts the supplied message.
  *
  * @param {{type: string}} message The message to post.
- * @return {!Promise}
+ * @return {!Promise<!Object>}
  * @private
  */
 remoting.HostDaemonFacade.prototype.postMessage_ =
     function(message) {
   /** @type {remoting.HostDaemonFacade} */
   var that = this;
   return this.initialize_().then(function() {
     return that.postMessageInternal_(message);
   }, function() {
     throw that.error_;
   });
 };
 
 /**
  * Attaches a new ID to the supplied message, and posts it to the
  * Native Messaging port, adding a Deferred object to the list of
  * pending replies.  |message| should have its 'type' field set, and
  * any other fields set depending on the message type.
  *
  * @param {{type: string}} message The message to post.
- * @return {!Promise}
+ * @return {!Promise<!Object>}
  * @private
  */
 remoting.HostDaemonFacade.prototype.postMessageInternal_ = function(message) {
   var id = this.nextId_++;
   message['id'] = id;
   var deferred = new base.Deferred();
   this.pendingReplies_[id] = new remoting.HostDaemonFacade.PendingReply(
     message.type + 'Response', deferred);
   this.port_.postMessage(message);
   return deferred.promise();
@@ skipping 18 matching lines @@
     console.error('NativeMessaging: unexpected id: ', id);
     return;
   }
   delete this.pendingReplies_[id];
 
   try {
     var type = base.getStringAttr(message, 'type');
     if (type != reply.type) {
       throw 'Expected reply type: ' + reply.type + ', got: ' + type;
     }
-
-    reply.deferred.resolve(this.handleIncomingMessage_(message));
+    reply.deferred.resolve(message);
   } catch (/** @type {*} */ e) {
     console.error('Error while processing native message', e);
     reply.deferred.reject(remoting.Error.unexpected());
   }
 };
 
 /**
- * Handler for incoming Native Messages.
- *
- * TODO(jrw) Consider refactoring so each method handles its own
- * response, e.g.:
- *
- * remoting.HostDaemonFacade.prototype.generateKeyPair = function() {
- *   this.postMessage_({type: 'generateKeyPair'}).then(function(message) {
- *     return {
- *       privateKey: base.getStringAttr(message, 'privateKey'),
- *       publicKey: base.getStringAttr(message, 'publicKey')
- *     }
- *   });
- * };
- *
- * @param {Object} message The received message.
- * @return {*}
- * @private
- */
-remoting.HostDaemonFacade.prototype.handleIncomingMessage_ =
-    function(message) {
-  var type = base.getStringAttr(message, 'type');
-
-  switch (type) {
-    case 'helloResponse':
-      this.version_ = base.getStringAttr(message, 'version');
-      // Old versions of the native messaging host do not return this list.
-      // Those versions default to the empty list of supported features.
-      this.supportedFeatures_ =
-          base.getArrayAttr(message, 'supportedFeatures', []);
-      return null;
-
-    case 'getHostNameResponse':
-      return base.getStringAttr(message, 'hostname');
-
-    case 'getPinHashResponse':
-      return base.getStringAttr(message, 'hash');
-
-    case 'generateKeyPairResponse':
-      return {
-        privateKey: base.getStringAttr(message, 'privateKey'),
-        publicKey: base.getStringAttr(message, 'publicKey')
-      };
-
-    case 'updateDaemonConfigResponse':
-      return remoting.HostController.AsyncResult.fromString(
-          base.getStringAttr(message, 'result'));
-
-    case 'getDaemonConfigResponse':
-      return base.getObjectAttr(message, 'config');
-
-    case 'getUsageStatsConsentResponse':
-      return {
-        supported: base.getBooleanAttr(message, 'supported'),
-        allowed: base.getBooleanAttr(message, 'allowed'),
-        setByPolicy: base.getBooleanAttr(message, 'setByPolicy')
-      };
-
-    case 'startDaemonResponse':
-    case 'stopDaemonResponse':
-      return remoting.HostController.AsyncResult.fromString(
-          base.getStringAttr(message, 'result'));
-
-    case 'getDaemonStateResponse':
-      return remoting.HostController.State.fromString(
-        base.getStringAttr(message, 'state'));
-
-    case 'getPairedClientsResponse':
-      var pairedClients = remoting.PairedClient.convertToPairedClientArray(
-          message['pairedClients']);
-      if (pairedClients != null) {
-        return pairedClients;
-      } else {
-        throw 'No paired clients!';
-      }
-
-    case 'clearPairedClientsResponse':
-    case 'deletePairedClientResponse':
-      return base.getBooleanAttr(message, 'result');
-
-    case 'getHostClientIdResponse':
-      return base.getStringAttr(message, 'clientId');
-
-    case 'getCredentialsFromAuthCodeResponse':
-      var userEmail = base.getStringAttr(message, 'userEmail');
-      var refreshToken = base.getStringAttr(message, 'refreshToken');
-      if (userEmail && refreshToken) {
-        return {
-          userEmail: userEmail,
-          refreshToken: refreshToken
-        };
-      } else {
-        throw 'Missing userEmail or refreshToken';
-      }
-
-    case 'getRefreshTokenFromAuthCodeResponse':
-      var refreshToken = base.getStringAttr(message, 'refreshToken');
-      if (refreshToken) {
-        return refreshToken;
-      } else {
-        throw 'Missing refreshToken';
-      }
-
-    default:
-      throw 'Unexpected native message: ' + message;
-  }
-};
-
-/**
  * @return {void} Nothing.
  * @private
  */
 remoting.HostDaemonFacade.prototype.onDisconnect_ = function() {
   console.error('Native Message port disconnected');
 
   this.port_.onDisconnect.removeListener(this.onDisconnectCallback_);
   this.port_.onMessage.removeListener(this.onIncomingMessageCallback_);
   this.port_ = null;
 
@@ skipping 11 matching lines @@
     pendingReplies[num_id].deferred.reject(this.error_);
   }
 }
 
 /**
  * Gets local hostname.
  *
  * @return {!Promise<string>}
  */
 remoting.HostDaemonFacade.prototype.getHostName = function() {
-  return this.postMessage_({type: 'getHostName'});
+  return this.postMessage_({type: 'getHostName'}).then(function(reply) {
+    return base.getStringAttr(reply, 'hostname');
+  });
 };
 
 /**
  * Calculates PIN hash value to be stored in the config, passing the resulting
  * hash value base64-encoded to the callback.
  *
  * @param {string} hostId The host ID.
  * @param {string} pin The PIN.
  * @return {!Promise<string>}
  */
 remoting.HostDaemonFacade.prototype.getPinHash = function(hostId, pin) {
   return this.postMessage_({
       type: 'getPinHash',
       hostId: hostId,
       pin: pin
+  }).then(function(reply) {
+    return base.getStringAttr(reply, 'hash');
   });
 };
 
 /**
  * Generates new key pair to use for the host. The specified callback is called
  * when the key is generated. The key is returned in format understood by the
  * host (PublicKeyInfo structure encoded with ASN.1 DER, and then BASE64).
  *
  * @return {!Promise<remoting.KeyPair>}
  */
 remoting.HostDaemonFacade.prototype.generateKeyPair = function() {
-  return this.postMessage_({type: 'generateKeyPair'});
+  return this.postMessage_({type: 'generateKeyPair'}).then(function(reply) {
+    return {
+      privateKey: base.getStringAttr(reply, 'privateKey'),
+      publicKey: base.getStringAttr(reply, 'publicKey')
+    };
+  });
 };
 
 /**
  * Updates host config with the values specified in |config|. All
  * fields that are not specified in |config| remain
  * unchanged. Following parameters cannot be changed using this
  * function: host_id, xmpp_login. Error is returned if |config|
  * includes these parameters. Changes take effect before the callback
  * is called.
  *
  * TODO(jrw): Consider conversion exceptions to AsyncResult values.
  *
  * @param {Object} config The new config parameters.
  * @return {!Promise<remoting.HostController.AsyncResult>}
  */
 remoting.HostDaemonFacade.prototype.updateDaemonConfig = function(config) {
   return this.postMessage_({
       type: 'updateDaemonConfig',
       config: config
+  }).then(function(reply) {
+    return remoting.HostController.AsyncResult.fromString(
+        base.getStringAttr(reply, 'result'));
   });
 };
 
 /**
  * Loads daemon config. The config is passed as a JSON formatted string to the
  * callback.
  * @return {!Promise<Object>}
  */
 remoting.HostDaemonFacade.prototype.getDaemonConfig = function() {
-  return this.postMessage_({type: 'getDaemonConfig'});
+  return this.postMessage_({type: 'getDaemonConfig'}).then(function(reply) {
+    return base.getObjectAttr(reply, 'config');
+  });
 };
 
 /**
  * Retrieves daemon version. The version is returned as a dotted decimal
  * string of the form major.minor.build.patch.
  *
  * @return {!Promise<string>}
  */
 remoting.HostDaemonFacade.prototype.getDaemonVersion = function() {
   /** @type {remoting.HostDaemonFacade} */
   var that = this;
   return this.initialize_().then(function() {
     return that.version_;
   }, function() {
     throw that.error_;
   });
 };
 
 /**
  * Get the user's consent to crash reporting. The consent flags are passed to
  * the callback as booleans: supported, allowed, set-by-policy.
  *
  * @return {!Promise<remoting.UsageStatsConsent>}
  */
 remoting.HostDaemonFacade.prototype.getUsageStatsConsent = function() {
-  return this.postMessage_({type: 'getUsageStatsConsent'});
+  return this.postMessage_({type: 'getUsageStatsConsent'}).
+      then(function(reply) {
+        return {
+          supported: base.getBooleanAttr(reply, 'supported'),
+          allowed: base.getBooleanAttr(reply, 'allowed'),
+          setByPolicy: base.getBooleanAttr(reply, 'setByPolicy')
+        };
+      });
 };
 
 /**
  * Starts the daemon process with the specified configuration.
  *
  * TODO(jrw): Consider conversion exceptions to AsyncResult values.
  *
  * @param {Object} config Host configuration.
  * @param {boolean} consent Consent to report crash dumps.
  * @return {!Promise<remoting.HostController.AsyncResult>}
  */
 remoting.HostDaemonFacade.prototype.startDaemon = function(config, consent) {
   return this.postMessage_({
       type: 'startDaemon',
       config: config,
       consent: consent
+  }).then(function(reply) {
+    return remoting.HostController.AsyncResult.fromString(
+        base.getStringAttr(reply, 'result'));
   });
 };
 
 /**
  * Stops the daemon process.
  *
  * TODO(jrw): Consider conversion exceptions to AsyncResult values.
  *
  * @return {!Promise<remoting.HostController.AsyncResult>}
  */
 remoting.HostDaemonFacade.prototype.stopDaemon =
     function() {
-  return this.postMessage_({type: 'stopDaemon'});
+  return this.postMessage_({type: 'stopDaemon'}).then(function(reply) {
+    return remoting.HostController.AsyncResult.fromString(
+        base.getStringAttr(reply, 'result'));
+  });
 };
 
 /**
  * Gets the installed/running state of the Host process.
  *
  * @return {!Promise<remoting.HostController.State>}
  */
 remoting.HostDaemonFacade.prototype.getDaemonState = function() {
-  return this.postMessage_({type: 'getDaemonState'});
+  return this.postMessage_({type: 'getDaemonState'}).then(function(reply) {
+    return remoting.HostController.State.fromString(
+        base.getStringAttr(reply, 'state'));
+ });
 };
 
 /**
  * Retrieves the list of paired clients.
  *
  * @return {!Promise<Array<remoting.PairedClient>>}
  */
 remoting.HostDaemonFacade.prototype.getPairedClients = function() {
-  return this.postMessage_({type: 'getPairedClients'});
+  return this.postMessage_({type: 'getPairedClients'}).then(function(reply) {
+    var pairedClients =remoting.PairedClient.convertToPairedClientArray(
+        reply['pairedClients']);
+    if (pairedClients != null) {
+      return pairedClients;
+    } else {
+      throw remoting.Error.unexpected('No paired clients!');
+    }
+  });
 };
 
 /**
  * Clears all paired clients from the registry.
  *
  * @return {!Promise<boolean>}
  */
 remoting.HostDaemonFacade.prototype.clearPairedClients = function() {
-  return this.postMessage_({type: 'clearPairedClients'});
+  return this.postMessage_({type: 'clearPairedClients'}).then(function(reply) {
+    return base.getBooleanAttr(reply, 'result');
+  });
 };
 
 /**
  * Deletes a paired client referenced by client id.
  *
  * @param {string} client Client to delete.
  * @return {!Promise<boolean>}
  */
 remoting.HostDaemonFacade.prototype.deletePairedClient = function(client) {
   return this.postMessage_({
     type: 'deletePairedClient',
     clientId: client
+  }).then(function(reply) {
+    return base.getBooleanAttr(reply, 'result');
   });
 };
 
 /**
  * Gets the API keys to obtain/use service account credentials.
  *
  * @return {!Promise<string>}
  */
 remoting.HostDaemonFacade.prototype.getHostClientId = function() {
-  return this.postMessage_({type: 'getHostClientId'});
+  return this.postMessage_({type: 'getHostClientId'}).then(function(reply) {
+    return base.getStringAttr(reply, 'clientId');
+  });
 };
 
 /**
  * @param {string} authorizationCode OAuth authorization code.
  * @return {!Promise<{remoting.XmppCredentials}>}
  */
 remoting.HostDaemonFacade.prototype.getCredentialsFromAuthCode =
     function(authorizationCode) {
   return this.postMessage_({
     type: 'getCredentialsFromAuthCode',
     authorizationCode: authorizationCode
+  }).then(function(reply) {
+    var userEmail = base.getStringAttr(reply, 'userEmail');
+    var refreshToken = base.getStringAttr(reply, 'refreshToken');
+    if (userEmail && refreshToken) {
+      return {
+        userEmail: userEmail,
+        refreshToken: refreshToken
+      };
+    } else {
+      throw remoting.Error.unexpected('Missing userEmail or refreshToken');
+    }
   });
 };
 
 /**
  * @param {string} authorizationCode OAuth authorization code.
  * @return {!Promise<string>}
  */
 remoting.HostDaemonFacade.prototype.getRefreshTokenFromAuthCode =
     function(authorizationCode) {
   return this.postMessage_({
     type: 'getRefreshTokenFromAuthCode',
     authorizationCode: authorizationCode
+  }).then(function(reply) {
+    var refreshToken = base.getStringAttr(reply, 'refreshToken');
+    if (refreshToken) {
+      return refreshToken
+    } else {
+      throw remoting.Error.unexpected('Missing refreshToken');
+    }
   });
 };