Function ensureRootIsScheduled

lib/assets/react-source/development/react.js:25034–25098

(root)

	function ensureRootIsScheduled(root) {
	  var lastExpiredTime = root.lastExpiredTime;

	  if (lastExpiredTime !== NoWork) {
	    // Special case: Expired work should flush synchronously.
	    root.callbackExpirationTime = Sync;
	    root.callbackPriority = ImmediatePriority;
	    root.callbackNode = scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
	    return;
	  }

	  var expirationTime = getNextRootExpirationTimeToWorkOn(root);
	  var existingCallbackNode = root.callbackNode;

	  if (expirationTime === NoWork) {
	    // There's nothing to work on.
	    if (existingCallbackNode !== null) {
	      root.callbackNode = null;
	      root.callbackExpirationTime = NoWork;
	      root.callbackPriority = NoPriority;
	    }

	    return;
	  } // TODO: If this is an update, we already read the current time. Pass the
	  // time as an argument.


	  var currentTime = requestCurrentTimeForUpdate();
	  var priorityLevel = inferPriorityFromExpirationTime(currentTime, expirationTime); // If there's an existing render task, confirm it has the correct priority and
	  // expiration time. Otherwise, we'll cancel it and schedule a new one.

	  if (existingCallbackNode !== null) {
	    var existingCallbackPriority = root.callbackPriority;
	    var existingCallbackExpirationTime = root.callbackExpirationTime;

	    if ( // Callback must have the exact same expiration time.
	    existingCallbackExpirationTime === expirationTime && // Callback must have greater or equal priority.
	    existingCallbackPriority >= priorityLevel) {
	      // Existing callback is sufficient.
	      return;
	    } // Need to schedule a new task.
	    // TODO: Instead of scheduling a new task, we should be able to change the
	    // priority of the existing one.


	    cancelCallback(existingCallbackNode);
	  }

	  root.callbackExpirationTime = expirationTime;
	  root.callbackPriority = priorityLevel;
	  var callbackNode;

	  if (expirationTime === Sync) {
	    // Sync React callbacks are scheduled on a special internal queue
	    callbackNode = scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
	  } else {
	    callbackNode = scheduleCallback(priorityLevel, performConcurrentWorkOnRoot.bind(null, root), // Compute a task timeout based on the expiration time. This also affects
	    // ordering because tasks are processed in timeout order.