domain: add arguments for the function in domain.run()

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 args, i, len ret;
+
   this.enter();
-  var ret = fn.call(this);
+  if (arguments.length >= 2) {
+    len = arguments.length;
+    args = new Array(len - 1);
+
+    for (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++;