From cda1a384260886b5cf84056885dfc9169441248e Mon Sep 17 00:00:00 2001
From: Benjamin Thomas <benjamin@benjaminthomas.org>
Date: Wed, 1 Sep 2010 05:01:38 -0600
Subject: [PATCH] Fix bug in process._tickCallback where callbacks can get
 abandoned.

Change process._tickCallback so that if a callback throws an error but
there are other callbacks after it, we indicate that
process._tickCallback needs to be ran again.

Currently, if a callback in process._tickCallback throws an error, and
that error is caught by an uncaughtException handler and
process.nextTick is never called again, then any other callbacks already
added to the nextTickQueue won't be called again.

Updated the next-tick-errors test to catch this scenario.
---
 src/node.js                          |  5 ++++-
 test/simple/test-next-tick-errors.js | 11 +++--------
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/node.js b/src/node.js
index a4ec922adc..e9d2db3eff 100644
--- a/src/node.js
+++ b/src/node.js
@@ -52,11 +52,14 @@ process._tickCallback = function () {
 
   try {
     for (var i = 0; i < l; i++) {
-        nextTickQueue[i]();
+      nextTickQueue[i]();
     }
   }
   catch(e) {
     nextTickQueue.splice(0, i+1);
+    if (i+1 < l) {
+      process._needTickCallback();
+    }
     throw e;
   }
 
diff --git a/test/simple/test-next-tick-errors.js b/test/simple/test-next-tick-errors.js
index 421baa999a..8ae3f5e543 100644
--- a/test/simple/test-next-tick-errors.js
+++ b/test/simple/test-next-tick-errors.js
@@ -13,7 +13,8 @@ process.nextTick(function() {
 });
 
 // This nextTick function should remain in the queue when the first one
-// is removed.
+// is removed.  It should be called if the error in the first one is
+// caught (which we do in this test).
 process.nextTick(function() {
   order.push('C');
 });
@@ -22,12 +23,6 @@ process.addListener('uncaughtException', function() {
   if (!exceptionHandled) {
     exceptionHandled = true;
     order.push('B');
-    // We call process.nextTick here to make sure the nextTick queue is
-    // processed again. If everything goes according to plan then when the queue
-    // gets ran there will be two functions with this being the second.
-    process.nextTick(function() {
-      order.push('D');
-    });
   }
   else {
     // If we get here then the first process.nextTick got called twice
@@ -36,6 +31,6 @@ process.addListener('uncaughtException', function() {
 });
 
 process.addListener('exit', function() {
-  assert.deepEqual(['A','B','C','D'], order);
+  assert.deepEqual(['A','B','C'], order);
 });