I still think this line is wrong.  `tickDepth` and `nextTickLength` (or `nextTickIndex`) aren't even measuring the same thing.  They're different "dimensions".  Example:

```javascript
// tickDepth = 0
process.nextTick(function() {
  // tickDepth = 1
  process.nextTick(function() {
    // tickDepth = 2
    process.nextTick(function() {
      // tickDepth = 3
    });
  });
});
```

Compare with:

```javascript
// tickDepth = 0
// nextTickLength = 0
process.nextTick(fn);
// tickDepth = 0
// nextTickLength = 1
process.nextTick(fn);
// tickDepth = 0
// nextTickLength = 2
process.nextTick(fn);
// tickDepth = 0
// nextTickLength = 3
```

This addition should not be there.

The `tickDepth` is designed to prevent infinite recursive use of `process.nextTick`.  Consider this function:

```javascript
function f() {
  process.nextTick(f);
}
```

This will run forever.  In order to make it not block all I/O, we watch the tick depth (which increments when a nextTick is called from within a nextTick callback, and reset to 0 at the end of each tick).  And when the tickDepth gets too high, it prints a warning, and defers the tick to the spinner.

If we add 2 nextTicks from within the function, why should it warn twice as early?  The tickDepth is orthogonal to nextTickLength, and a growing nextTickLength (or index) should not affect when the warning prints.

Consider:

```javascript
function g() {
  process.nextTick(h);
  process.nextTick(g);
}
function h() {}
```

Why should `g()` cause a warning twice as fast as `f()`?  They should both warn at the same tickDepth, regardless of the nextTickLength or index.