Style cleanup: Rename callback -> onDone in chromoting webapp.

remoting/webapp/host_dispatcher.js

 // Copyright 2013 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
  * This class provides an interface between the HostController and either the
  * NativeMessaging Host or the Host NPAPI plugin, depending on whether or not
  * NativeMessaging is supported. Since the test for NativeMessaging support is
  * asynchronous, this class stores any requests on a queue, pending the result
@@ skipping 53 matching lines @@
 };
 
 /** @enum {number} */
 remoting.HostDispatcher.State = {
   UNKNOWN: 0,
   NATIVE_MESSAGING: 1,
   NPAPI: 2
 };
 
 /**
- * @param {function(string):void} callback
+ * @param {function(string):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getHostName = function(callback, onError) {
+remoting.HostDispatcher.prototype.getHostName = function(onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getHostName.bind(this, callback, onError));
+          this.getHostName.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.getHostName(callback, onError);
+      this.nativeMessagingHost_.getHostName(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.getHostName(callback);
+        this.npapiHost_.getHostName(onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
  * @param {string} hostId
  * @param {string} pin
- * @param {function(string):void} callback
+ * @param {function(string):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getPinHash = function(hostId, pin, callback,
-                                                        onError) {
+remoting.HostDispatcher.prototype.getPinHash =
+    function(hostId, pin, onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getPinHash.bind(this, hostId, pin, callback, onError));
+          this.getPinHash.bind(this, hostId, pin, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.getPinHash(hostId, pin, callback, onError);
+      this.nativeMessagingHost_.getPinHash(hostId, pin, onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.getPinHash(hostId, pin, callback);
+        this.npapiHost_.getPinHash(hostId, pin, onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
- * @param {function(string, string):void} callback
+ * @param {function(string, string):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.generateKeyPair = function(callback,
-                                                             onError) {
+remoting.HostDispatcher.prototype.generateKeyPair = function(onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.generateKeyPair.bind(this, callback, onError));
+          this.generateKeyPair.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.generateKeyPair(callback, onError);
+      this.nativeMessagingHost_.generateKeyPair(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.generateKeyPair(callback);
+        this.npapiHost_.generateKeyPair(onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
  * @param {Object} config
- * @param {function(remoting.HostController.AsyncResult):void} callback
+ * @param {function(remoting.HostController.AsyncResult):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.updateDaemonConfig = function(config,
-                                                                callback,
-                                                                onError) {
+remoting.HostDispatcher.prototype.updateDaemonConfig =
+    function(config, onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.updateDaemonConfig.bind(this, config, callback, onError));
+          this.updateDaemonConfig.bind(this, config, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.updateDaemonConfig(config, callback, onError);
+      this.nativeMessagingHost_.updateDaemonConfig(config, onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.updateDaemonConfig(JSON.stringify(config), callback);
+        this.npapiHost_.updateDaemonConfig(JSON.stringify(config), onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
- * @param {function(Object):void} callback
+ * @param {function(Object):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getDaemonConfig = function(callback,
-                                                             onError) {
+remoting.HostDispatcher.prototype.getDaemonConfig = function(onDone, onError) {
   /**
    * Converts the config string from the NPAPI plugin to an Object, to pass to
-   * |callback|.
+   * |onDone|.
    * @param {string} configStr
    * @return {void}
    */
   function callbackForNpapi(configStr) {
     var config = jsonParseSafe(configStr);
     if (typeof(config) != 'object') {
       onError(remoting.Error.UNEXPECTED);
     } else {
-      callback(/** @type {Object} */ (config));
+      onDone(/** @type {Object} */ (config));
     }
   }
 
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getDaemonConfig.bind(this, callback, onError));
+          this.getDaemonConfig.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.getDaemonConfig(callback, onError);
+      this.nativeMessagingHost_.getDaemonConfig(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
         this.npapiHost_.getDaemonConfig(callbackForNpapi);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
- * @param {function(string):void} callback
+ * @param {function(string):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getDaemonVersion = function(callback,
-                                                              onError) {
+remoting.HostDispatcher.prototype.getDaemonVersion = function(onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getDaemonVersion.bind(this, callback, onError));
+          this.getDaemonVersion.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      callback(this.nativeMessagingHost_.getDaemonVersion());
+      onDone(this.nativeMessagingHost_.getDaemonVersion());
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.getDaemonVersion(callback);
+        this.npapiHost_.getDaemonVersion(onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
- * @param {function(boolean, boolean, boolean):void} callback
+ * @param {function(boolean, boolean, boolean):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getUsageStatsConsent = function(callback,
-                                                                  onError) {
+remoting.HostDispatcher.prototype.getUsageStatsConsent =
+    function(onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getUsageStatsConsent.bind(this, callback, onError));
+          this.getUsageStatsConsent.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.getUsageStatsConsent(callback, onError);
+      this.nativeMessagingHost_.getUsageStatsConsent(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.getUsageStatsConsent(callback);
+        this.npapiHost_.getUsageStatsConsent(onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
  * @param {Object} config
  * @param {boolean} consent
- * @param {function(remoting.HostController.AsyncResult):void} callback
+ * @param {function(remoting.HostController.AsyncResult):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.startDaemon = function(config, consent,
-                                                         callback, onError) {
+remoting.HostDispatcher.prototype.startDaemon =
+    function(config, consent, onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.startDaemon.bind(this, config, consent, callback, onError));
+          this.startDaemon.bind(this, config, consent, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.startDaemon(config, consent, callback, onError);
+      this.nativeMessagingHost_.startDaemon(config, consent, onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.startDaemon(JSON.stringify(config), consent, callback);
+        this.npapiHost_.startDaemon(JSON.stringify(config), consent, onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
- * @param {function(remoting.HostController.AsyncResult):void} callback
+ * @param {function(remoting.HostController.AsyncResult):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.stopDaemon = function(callback, onError) {
+remoting.HostDispatcher.prototype.stopDaemon = function(onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
-      this.pendingRequests_.push(this.stopDaemon.bind(this, callback, onError));
+      this.pendingRequests_.push(this.stopDaemon.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.stopDaemon(callback, onError);
+      this.nativeMessagingHost_.stopDaemon(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
-        this.npapiHost_.stopDaemon(callback);
+        this.npapiHost_.stopDaemon(onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
 
 /**
- * @param {function(remoting.HostController.State):void} callback
+ * @param {function(remoting.HostController.State):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getDaemonState = function(callback, onError) {
+remoting.HostDispatcher.prototype.getDaemonState = function(onDone, onError) {
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getDaemonState.bind(this, callback, onError));
+          this.getDaemonState.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.getDaemonState(callback, onError);
+      this.nativeMessagingHost_.getDaemonState(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       // Call the callback directly, since NPAPI exposes the state directly as
       // a field member, rather than an asynchronous method.
       var state = this.npapiHost_.daemonState;
       if (state === undefined) {
         onError(remoting.Error.MISSING_PLUGIN);
       } else {
-        callback(state);
+        onDone(state);
       }
       break;
   }
 };
 
 /**
- * @param {function(Array.<remoting.PairedClient>):void} callback
+ * @param {function(Array.<remoting.PairedClient>):void} onDone
  * @param {function(remoting.Error):void} onError
  * @return {void}
  */
-remoting.HostDispatcher.prototype.getPairedClients = function(callback,
-                                                              onError) {
+remoting.HostDispatcher.prototype.getPairedClients = function(onDone, onError) {
   /**
    * Converts the JSON string from the NPAPI plugin to Array.<PairedClient>, to
-   * pass to |callback|.
+   * pass to |onDone|.
    * @param {string} pairedClientsJson
    * @return {void}
    */
   function callbackForNpapi(pairedClientsJson) {
     var pairedClients = remoting.PairedClient.convertToPairedClientArray(
         jsonParseSafe(pairedClientsJson));
     if (pairedClients != null) {
-      callback(pairedClients);
+      onDone(pairedClients);
     } else {
       onError(remoting.Error.UNEXPECTED);
     }
   }
 
   switch (this.state_) {
     case remoting.HostDispatcher.State.UNKNOWN:
       this.pendingRequests_.push(
-          this.getPairedClients.bind(this, callback, onError));
+          this.getPairedClients.bind(this, onDone, onError));
       break;
     case remoting.HostDispatcher.State.NATIVE_MESSAGING:
-      this.nativeMessagingHost_.getPairedClients(callback, onError);
+      this.nativeMessagingHost_.getPairedClients(onDone, onError);
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
         this.npapiHost_.getPairedClients(callbackForNpapi);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };
@@ skipping 41 matching lines @@
       break;
     case remoting.HostDispatcher.State.NPAPI:
       try {
         this.npapiHost_.deletePairedClient(client, onDone);
       } catch (err) {
         onError(remoting.Error.MISSING_PLUGIN);
       }
       break;
   }
 };