domain: forward args to .run(fn)

Adds the feature to define arguments for the function called in
domain.run(), this is supposed to be useful when a function is called from
another context and some values from the current context are needed as
arguments, it's similar to the callback from setTimeout or setInterval.

PR-URL: #15
Reviewed-By: Chris Dickinson <christopher.s.dickinson@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>

Author: micnic

benchmark/misc/domain-fn-args.js

@@ -0,0 +1,43 @@
+var common = require('../common.js');
+var domain = require('domain');
+
+var bench = common.createBenchmark(main, {
+  arguments: [0, 1, 2, 3],
+  n: [10]
+});
+
+var bdomain = domain.create();
+var gargs = [1, 2, 3];
+
+function main(conf) {
+
+  var args, ret, n = +conf.n;
+  var arguments = gargs.slice(0, conf.arguments);
+  bench.start();
+
+  bdomain.enter();
+  for (var i = 0; i < n; i++) {
+    if (arguments.length >= 2) {
+      args = Array.prototype.slice.call(arguments, 1);
+      ret = fn.apply(this, args);
+    } else {
+      ret = fn.call(this);
+    }
+  }
+  bdomain.exit();
+
+  bench.end(n);
+}
+
+function fn(a, b, c) {
+  if (!a)
+    a = 1;
+
+  if (!b)
+    b = 2;
+
+  if (!c)
+    c = 3;
+
+  return a + b + c;
+}

doc/api/domain.markdown

@@ -260,13 +260,14 @@ uncaught exceptions to the active Domain object.
 Domain is a child class of [EventEmitter][].  To handle the errors that it
 catches, listen to its `error` event.
 
-### domain.run(fn)
+### domain.run(fn[, arg][, ...])
 
 * `fn` {Function}
 
 Run the supplied function in the context of the domain, implicitly
 binding all event emitters, timers, and lowlevel requests that are
-created in that context.
+created in that context. Optionally, arguments can be passed to
+the function.
 
 This is the most basic way to use a domain.
 

lib/domain.js

@@ -195,9 +195,23 @@ Domain.prototype.remove = function(ee) {
 Domain.prototype.run = function(fn) {
   if (this._disposed)
     return;
+
+  var ret;
+
   this.enter();
-  var ret = fn.call(this);
+  if (arguments.length >= 2) {
+    var len = arguments.length;
+    var args = new Array(len - 1);
+
+    for (var i = 1; i < len; i++)
+      args[i - 1] = arguments[i];
+
+    ret = fn.apply(this, args);
+  } else {
+    ret = fn.call(this);
+  }
   this.exit();
+
   return ret;
 };
 

test/simple/test-domain.js

@@ -258,6 +258,13 @@ var result = d.run(function () {
 assert.equal(result, 'return value');
 
 
+// check if the executed function take in count the applied parameters
+result = d.run(function (a, b) {
+  return a + ' ' + b;
+}, 'return', 'value');
+assert.equal(result, 'return value');
+
+
 var fst = fs.createReadStream('stream for nonexistent file')
 d.add(fst)
 expectCaught++;