Recall how we talked about determining the optimal way to flush updates (from the rootmost points downward)? We don't really need to solve that problem now, but by factoring out the pending updates into a separate queue module, we could accomplish the following:

1. Make it possible to optimize the processing of flushing according to our plan - at a later point in time. In order to flush optimally, there must be global knowledge of which instances need updating and that cannot be tracked on individual instances.
2. Keep this module relatively tight and organized. You may also be able to eliminate the need to track `_hasPendingUpdate` here, and won't have to deal with tracking the list of callbacks here.


````
    ensureNeedsUpdate: function(callback) {
      ReactUpdates.ensureNeedsUpdate(this, callback);  // Anything passed must implement {performPendingUpdate: func}
    },

   // Only invoked when ReactUpdates *knows* we need to update.
   // We invoke `onComplete` when we're done updating.
   // ReactUpdates provides `onComplete` which cycles through the list of callbacks and invokes them.
   // ReactUpdates automatically marks us as not needing update before invoking `performPendingUpdate` so that...
   // if any of the callbacks in the list mark us dirty again, ReactUpdates keeps repeating the process in the same
   // tick. We should detect anything over say 4 repetitions and throw (probably some kind of an infinite update loop).
   performPendingUpdate(onComplete) {
       
   }
`````