Run jshint over all JavaScript files

build_tools/naclprocess.js

 /*
  * Copyright (c) 2014 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+/* jshint evil: true */
+/* globals PipeServer */
+
 'use strict';
 
 // TODO(gdeepti): extend to multiple mounts.
 /**
  * Mount object contains the state of the local mount.
  */
 var g_mount = {
   // DirectoryEntry specified by the user
   entry: undefined,
 
@@ skipping 264 matching lines @@
         callback(getNaClArch.naclArch_);
       });
       return;
     } else {
       getNaClArch.naclArch_ = null;
     }
   }
   setTimeout(function() {
     callback(getNaClArch.naclArch_);
   }, 0);
-};
+}
 
 /**
  * Handles a stdout event.
  * @callback stdoutCallback
  * @param {string} msg The string sent to stdout.
  */
 
 /**
  * Listen for stdout from the spawned processes.
  * @param {stdoutCallback} callback The callback to be called on a stdout write.
@@ skipping 94 matching lines @@
   }
   return result;
 };
 
 /**
  * Makes the path in a NMF entry to fully specified path.
  * @private
  */
 NaClProcessManager.prototype.adjustNmfEntry_ = function(entry) {
   for (var arch in entry) {
+    var path;
     if (arch === 'portable') {
       if (entry[arch]['pnacl-translate'] === undefined ||
           entry[arch]['pnacl-translate']['url'] === undefined) {
         return;
       }
-      var path = entry[arch]['pnacl-translate']['url'];
+      path = entry[arch]['pnacl-translate']['url'];
     } else {
       if (entry[arch]['url'] === undefined) {
         return;
       }
-      var path = entry[arch]['url'];
+      path = entry[arch]['url'];
     }
 
     // Convert 'path' from the NaCl VFS into an HTML5 filesystem: URL
     var tmpMountPoint = '/tmp/';
     var httpMountPoint = '/mnt/http/';
     var fsname = '/persistent/';
     if (path.indexOf(tmpMountPoint) === 0) {
       // Strip the /tmp/ prefix
       path = path.replace(tmpMountPoint, '');
       fsname = '/temporary/';
@@ skipping 44 matching lines @@
     nacl_apipe_close: [this.pipeServer,
                        this.pipeServer.handleMessageAPipeClose],
     nacl_jseval: [this, this.handleMessageJSEval_],
     nacl_deadpid: [this, this.handleMessageDeadPid_],
     nacl_mountfs: [this,this.handleMessageMountFs_],
   };
 
   // TODO(channingh): Once pinned applications support "result" instead of
   // "pid", change calls to reply() to set "result."
   function reply(contents) {
-    var reply = {};
-    reply[msg['id']] = contents;
+    var message = {};
+    message[msg['id']] = contents;
     // Enable to debug message stream (disabled for speed).
     // console.log(src.pid + '> reply: ' + JSON.stringify(reply));
-    src.postMessage(reply);
+    src.postMessage(message);
   }
 
   if (msg['command'] && handlers[msg['command']]) {
     // Enable to debug message stream (disabled for speed).
     //console.log(src.pid + '> ' + msg['command'] + ': ' + JSON.stringify(msg));
     var handler = handlers[msg['command']];
     handler[1].call(handler[0], msg, reply, src);
   } else if (msg['mount_status'] == 'success') {
     // TODO(gdeepti): Remove monitoring mount status with strings.
     this.processes[src.pid].mounted = true;
@@ skipping 308 matching lines @@
  * @param {number} sid The session ID of the session to which the process
  *     group belongs.
  */
 NaClProcessManager.prototype.createProcessGroup_ = function(pid, sid) {
   if (this.processGroups[pid] !== undefined) {
     throw new Error('createProcessGroup_(): process group already exists');
   }
   this.processGroups[pid] = {
     sid: sid,
     processes: {}
-  }
+  };
   this.processGroups[pid].processes[pid] = true;
 };
 
 /**
  * Delete a process from the process group table. If a group has no more
  * processes, delete the group as well.
  * @private
  * @param {number} pid The process to be deleted.
  */
 NaClProcessManager.prototype.deleteProcessFromGroup_ = function(pid) {
@@ skipping 28 matching lines @@
   var pid = element.pid;
   var ppid = this.processes[pid].ppid;
   var pgid = this.processes[pid].pgid;
 
   this.pipeServer.deleteProcess(pid);
   this.deleteProcessFromGroup_(pid);
 
   // Reply to processes waiting on the exited process.
   var waitersToCheck = [pid, -1, -pgid];
   var reaped = false;
-  for (var i = 0; i < waitersToCheck.length; i++) {
-    var currPid = waitersToCheck[i];
-    if (this.waiters[currPid] === undefined) {
-      continue;
+  var waiters = this.waiters;
+  waitersToCheck.forEach(function(currPid) {
+    if (waiters[currPid] === undefined) {
+      return;
     }
-    var currPidWaiters = this.waiters[currPid];
+    var currPidWaiters = waiters[currPid];
     for (var j = 0; j < currPidWaiters.length; j++) {
       var waiter = currPidWaiters[j];
       if (waiter.srcPid === ppid) {
         waiter.reply(pid, code);
         reaped = true;
       }
     }
-    this.waiters[currPid] = currPidWaiters.filter(function(waiter) {
+    waiters[currPid] = currPidWaiters.filter(function(waiter) {
       return waiter.srcPid !== ppid;
     });
-    if (this.waiters[currPid].length === 0) {
-      delete this.waiters[currPid];
+    if (waiters[currPid].length === 0) {
+      delete waiters[currPid];
     }
-  }
+  });
   if (reaped) {
     this.deleteProcessEntry_(pid);
   } else {
     this.processes[pid].exitCode = code;
   }
 
   // Mark as terminated.
   element.pid = -1;
 
   // Clean up HTML elements.
@@ skipping 42 matching lines @@
  * @param {string} url The url to download and parse.
  * @callback typeCallback Called with 'nacl' or 'pnacl' on success.
  * @callback errorCallback Called with error message on failure.
  */
 NaClProcessManager.prototype.checkUrlNaClManifestType = function(
     url, typeCallback, errorCallback) {
   var self = this;
   var request = new XMLHttpRequest();
   request.open('GET', url, true);
   request.onload = function() {
+    var manifest;
     try {
-      var manifest = JSON.parse(request.responseText);
+      manifest = JSON.parse(request.responseText);
     } catch(e) {
       errorCallback('NaCl Manifest is not valid JSON at ' + url);
       return;
     }
     var kind = self.checkNaClManifestType_(manifest);
     if (kind === null) {
       errorCallback('NaCl Manifest has bad format at ' + url);
     } else {
       typeCallback(kind);
     }
@@ skipping 172 matching lines @@
 
     // If the application has set NaClTerm.argv and there were
     // no arguments set in the query parameters then add the default
     // NaClTerm.argv arguments.
     // TODO(bradnelson): Consider dropping this method of passing in parameters.
     if (args['arg0'] === undefined && args['arg1'] === undefined && argv) {
       var argn = 0;
       argv.forEach(function(arg) {
         var argname = 'arg' + argn;
         addParam(argname, arg);
-        argn = argn + 1
-      })
+        argn = argn + 1;
+      });
     }
 
     self.pipeServer.addProcessPipes(fg.pid, params);
 
     if (params[NaClProcessManager.ENV_SPAWN_MODE] ===
         NaClProcessManager.ENV_SPAWN_POPUP_VALUE) {
       var popup = new GraphicalPopup(
         fg,
         parseInt(params[NaClProcessManager.ENV_POPUP_WIDTH] ||
                  NaClProcessManager.POPUP_WIDTH_DEFAULT),
@@ skipping 104 matching lines @@
       }
     }
 
     if (finishedPid !== null) {
       reply(finishedPid, this.processes[finishedPid].exitCode);
       this.deleteProcessEntry_(finishedPid);
       return;
     }
   }
 
-  if ((options & NaClProcessManager.WNOHANG) != 0) {
+  if ((options & NaClProcessManager.WNOHANG) !== 0) {
     reply(0, 0);
     return;
   }
 
   // Add the waitpid call to the waiter list.
   if (!this.waiters[pid]) {
     this.waiters[pid] = [];
   }
   this.waiters[pid].push({
     reply: reply,
@@ skipping 83 matching lines @@
  * The (empty) HTML file to which the NaCl module is added.
  * @const
  */
 GraphicalPopup.HTML_FILE = 'graphical.html';
 
 /**
  * Focus the window in which this code is run.
  */
 GraphicalPopup.focusCurrentWindow = function() {
   chrome.app.window.current().focus();
-}
+};
 
 /**
  * This callback is called when the popup is closed.
  * @callback closedCallback
  */
 
 /**
  * Set a function to be called as a callback when the popup is closed.
  * @param {closedCallback} listener
  */
 GraphicalPopup.prototype.setClosedListener = function(listener) {
   if (this.win) {
     throw new Error("Cannot set closed listener after creating window.");
   }
   this.onClosed = listener;
-}
+};
 
 /**
  * Create the window.
  */
 GraphicalPopup.prototype.create = function() {
   var self =  this;
   chrome.app.window.create('graphical.html', {
     'bounds': {
       'width': self.width,
       'height': self.height
@@ skipping 33 matching lines @@
 GraphicalPopup.prototype.destroy = function() {
   if (this.win.contentWindow.focused) {
     GraphicalPopup.focusCurrentWindow();
   }
   this.win.onClosed.removeListener(this.onClosed);
   this.win.close();
 
   this.process = null;
   this.win = null;
 };