Rename ReactUpdates.setImmediate to 'asap'

src/browser/ui/dom/components/ReactDOMInput.js

@@ -125,10 +125,10 @@ var ReactDOMInput = ReactCompositeComponent.createClass({
     if (onChange) {
       returnValue = onChange.call(this, event);
     }
-    // Here we use setImmediate to wait until all updates have propagated, which
+    // Here we use asap to wait until all updates have propagated, which
     // is important when using controlled components within layers:
     // https://github.com/facebook/react/issues/1698
-    ReactUpdates.setImmediate(forceUpdateIfMounted, this);
+    ReactUpdates.asap(forceUpdateIfMounted, this);
 
     var name = this.props.name;
     if (this.props.type === 'radio' && name != null) {
@@ -169,7 +169,7 @@ var ReactDOMInput = ReactCompositeComponent.createClass({
         // If this is a controlled radio button group, forcing the input that
         // was previously checked to update will cause it to be come re-checked
         // as appropriate.
-        ReactUpdates.setImmediate(forceUpdateIfMounted, otherInstance);
+        ReactUpdates.asap(forceUpdateIfMounted, otherInstance);
       }
     }
 

src/browser/ui/dom/components/ReactDOMSelect.js

@@ -180,7 +180,7 @@ var ReactDOMSelect = ReactCompositeComponent.createClass({
     }
 
     this._pendingValue = selectedValue;
-    ReactUpdates.setImmediate(updateWithPendingValueIfMounted, this);
+    ReactUpdates.asap(updateWithPendingValueIfMounted, this);
     return returnValue;
   }
 

src/browser/ui/dom/components/ReactDOMTextarea.js

@@ -135,7 +135,7 @@ var ReactDOMTextarea = ReactCompositeComponent.createClass({
     if (onChange) {
       returnValue = onChange.call(this, event);
     }
-    ReactUpdates.setImmediate(forceUpdateIfMounted, this);
+    ReactUpdates.asap(forceUpdateIfMounted, this);
     return returnValue;
   }
 

src/core/ReactUpdates.js

@@ -29,8 +29,8 @@ var mixInto = require('mixInto');
 var warning = require('warning');
 
 var dirtyComponents = [];
-var setImmediateCallbackQueue = CallbackQueue.getPooled();
-var setImmediateEnqueued = false;
+var asapCallbackQueue = CallbackQueue.getPooled();
+var asapEnqueued = false;
 
 var batchingStrategy = null;
 
@@ -172,18 +172,18 @@ var flushBatchedUpdates = ReactPerf.measure(
     // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
     // array and perform any updates enqueued by mount-ready handlers (i.e.,
     // componentDidUpdate) but we need to check here too in order to catch
-    // updates enqueued by setState callbacks and setImmediate calls.
-    while (dirtyComponents.length || setImmediateEnqueued) {
+    // updates enqueued by setState callbacks and asap calls.
+    while (dirtyComponents.length || asapEnqueued) {
       if (dirtyComponents.length) {
         var transaction = ReactUpdatesFlushTransaction.getPooled();
         transaction.perform(runBatchedUpdates, null, transaction);
         ReactUpdatesFlushTransaction.release(transaction);
       }
 
-      if (setImmediateEnqueued) {
-        setImmediateEnqueued = false;
-        var queue = setImmediateCallbackQueue;
-        setImmediateCallbackQueue = CallbackQueue.getPooled();
+      if (asapEnqueued) {
+        asapEnqueued = false;
+        var queue = asapCallbackQueue;
+        asapCallbackQueue = CallbackQueue.getPooled();
         queue.notifyAll();
         CallbackQueue.release(queue);
       }
@@ -237,14 +237,14 @@ function enqueueUpdate(component, callback) {
  * Enqueue a callback to be run at the end of the current batching cycle. Throws
  * if no updates are currently being performed.
  */
-function setImmediate(callback, context) {
+function asap(callback, context) {
   invariant(
     batchingStrategy.isBatchingUpdates,
-    'ReactUpdates.setImmediate: Can\'t enqueue an immediate callback in a ' +
-    'context where updates are not being batched.'
+    'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' +
+    'updates are not being batched.'
   );
-  setImmediateCallbackQueue.enqueue(callback, context);
-  setImmediateEnqueued = true;
+  asapCallbackQueue.enqueue(callback, context);
+  asapEnqueued = true;
 }
 
 var ReactUpdatesInjection = {
@@ -286,7 +286,7 @@ var ReactUpdates = {
   enqueueUpdate: enqueueUpdate,
   flushBatchedUpdates: flushBatchedUpdates,
   injection: ReactUpdatesInjection,
-  setImmediate: setImmediate
+  asap: asap
 };
 
 module.exports = ReactUpdates;

src/core/__tests__/ReactUpdates-test.js

@@ -749,18 +749,18 @@ describe('ReactUpdates', function() {
     expect(callbackCount).toBe(1);
   });
 
-  it('calls setImmediate callbacks properly', function() {
+  it('calls asap callbacks properly', function() {
     var callbackCount = 0;
     var A = React.createClass({
       render: function() {
         return <div />;
       },
       componentDidUpdate: function() {
         var component = this;
-        ReactUpdates.setImmediate(function() {
+        ReactUpdates.asap(function() {
           expect(this).toBe(component);
           callbackCount++;
-          ReactUpdates.setImmediate(function() {
+          ReactUpdates.asap(function() {
             callbackCount++;
           });
           expect(callbackCount).toBe(1);
@@ -775,7 +775,7 @@ describe('ReactUpdates', function() {
     expect(callbackCount).toBe(2);
   });
 
-  it('calls setImmediate callbacks with queued updates', function() {
+  it('calls asap callbacks with queued updates', function() {
     var log = [];
     var A = React.createClass({
       getInitialState: () => ({updates: 0}),
@@ -785,18 +785,18 @@ describe('ReactUpdates', function() {
       },
       componentDidUpdate: function() {
         if (this.state.updates === 1) {
-          ReactUpdates.setImmediate(function() {
+          ReactUpdates.asap(function() {
             this.setState({updates: 2}, function() {
-              ReactUpdates.setImmediate(function() {
-                log.push('setImmediate-1.2');
+              ReactUpdates.asap(function() {
+                log.push('asap-1.2');
               });
               log.push('setState-cb');
             });
-            log.push('setImmediate-1.1');
+            log.push('asap-1.1');
           }, this);
         } else if (this.state.updates === 2) {
-          ReactUpdates.setImmediate(function() {
-            log.push('setImmediate-2');
+          ReactUpdates.asap(function() {
+            log.push('asap-2');
           });
         }
         log.push('didUpdate-' + this.state.updates);
@@ -811,16 +811,16 @@ describe('ReactUpdates', function() {
       // We do the first update...
       'render-1',
       'didUpdate-1',
-      // ...which calls a setImmediate and enqueues a second update...
-      'setImmediate-1.1',
-      // ...which runs and enqueues the setImmediate-2 log in its didUpdate...
+      // ...which calls asap and enqueues a second update...
+      'asap-1.1',
+      // ...which runs and enqueues the asap-2 log in its didUpdate...
       'render-2',
       'didUpdate-2',
       // ...and runs the setState callback, which enqueues the log for
-      // setImmediate-1.2.
+      // asap-1.2.
       'setState-cb',
-      'setImmediate-2',
-      'setImmediate-1.2'
+      'asap-2',
+      'asap-1.2'
     ]);
   });
 });