Simplify top-level blockers

After thinking about how to implement blockers in general, I figured
out how to simplify top-level blockers, too.

Author: acdlite

src/renderers/shared/fiber/ReactFiberCompleteWork.js

@@ -18,6 +18,7 @@ import type {HydrationContext} from 'ReactFiberHydrationContext';
 import type {FiberRoot} from 'ReactFiberRoot';
 import type {HostConfig} from 'ReactFiberReconciler';
 
+var {topLevelBlockedAt} = require('ReactFiberRoot');
 var {reconcileChildFibers} = require('ReactChildFiber');
 var {
   popContextProvider,
@@ -40,7 +41,7 @@ var {
   Fragment,
 } = ReactTypeOfWork;
 var {Placement, Ref, Update} = ReactTypeOfSideEffect;
-var {Never} = ReactFiberExpirationTime;
+var {NoWork, Never} = ReactFiberExpirationTime;
 
 var invariant = require('fbjs/lib/invariant');
 
@@ -219,6 +220,11 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
           // TODO: Delete this when we delete isMounted and findDOMNode.
           workInProgress.effectTag &= ~Placement;
         }
+
+        // Check if the root is blocked by a top-level update.
+        const blockedAt = topLevelBlockedAt(fiberRoot);
+        fiberRoot.isBlocked =
+          blockedAt !== NoWork && blockedAt <= renderExpirationTime;
         return null;
       }
       case HostComponent: {

src/renderers/shared/fiber/ReactFiberReconciler.js

@@ -355,8 +355,8 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
 
     if (isPrerender) {
       // Block the root from committing at this expiration time.
-      if (root.blockers === null) {
-        root.blockers = createUpdateQueue();
+      if (root.topLevelBlockers === null) {
+        root.topLevelBlockers = createUpdateQueue();
       }
       const block = {
         priorityLevel: null,
@@ -368,7 +368,7 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
         isTopLevelUnmount: false,
         next: null,
       };
-      insertUpdateIntoQueue(root.blockers, block, currentTime);
+      insertUpdateIntoQueue(root.topLevelBlockers, block, currentTime);
     }
 
     scheduleWork(current, expirationTime);
@@ -382,11 +382,11 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
   WorkNode.prototype.commit = function() {
     const root = this._reactRootContainer;
     const expirationTime = this._expirationTime;
-    const blockers = root.blockers;
-    if (blockers === null) {
+    const topLevelBlockers = root.topLevelBlockers;
+    if (topLevelBlockers === null) {
       return;
     }
-    processUpdateQueue(blockers, null, null, null, expirationTime);
+    processUpdateQueue(topLevelBlockers, null, null, null, expirationTime);
     expireWork(root, expirationTime);
   };
   WorkNode.prototype.then = function(callback) {

src/renderers/shared/fiber/ReactFiberRoot.js

@@ -25,11 +25,14 @@ export type FiberRoot = {
   current: Fiber,
   // Determines if this root has already been added to the schedule for work.
   isScheduled: boolean,
+  // A queue that represents times at which the root is blocked by a
+  // top-level update.
+  topLevelBlockers: UpdateQueue<null> | null,
   // The time at which this root completed.
   completedAt: ExpirationTime,
-  // A queue that represents times at which this root is blocked
+  // If this root completed, isBlocked indicates whether it's blocked
   // from committing.
-  blockers: UpdateQueue<null> | null,
+  isBlocked: boolean,
   // A queue of callbacks that fire once their corresponding expiration time
   // has completed. Only fired once.
   completionCallbacks: UpdateQueue<null> | null,
@@ -45,16 +48,12 @@ export type FiberRoot = {
   hydrate: boolean,
 };
 
-exports.isRootBlocked = function(
-  root: FiberRoot,
-  expirationTime: ExpirationTime,
-) {
-  const blockers = root.blockers;
-  if (blockers === null) {
-    return false;
+exports.topLevelBlockedAt = function(root: FiberRoot) {
+  const topLevelBlockers = root.topLevelBlockers;
+  if (topLevelBlockers === null) {
+    return NoWork;
   }
-  const blockedAt = getUpdateQueueExpirationTime(blockers);
-  return blockedAt !== NoWork && blockedAt <= expirationTime;
+  return getUpdateQueueExpirationTime(topLevelBlockers);
 };
 
 exports.createFiberRoot = function(containerInfo: any): FiberRoot {
@@ -66,8 +65,9 @@ exports.createFiberRoot = function(containerInfo: any): FiberRoot {
     containerInfo: containerInfo,
     isScheduled: false,
     completedAt: NoWork,
-    blockers: null,
+    isBlocked: false,
     completionCallbacks: null,
+    topLevelBlockers: null,
     forceExpire: null,
     nextScheduledRoot: null,
     context: null,

src/renderers/shared/fiber/ReactFiberScheduler.js

@@ -52,7 +52,6 @@ var {ReactCurrentOwner} = require('ReactGlobalSharedState');
 var getComponentName = require('getComponentName');
 
 var {createWorkInProgress} = require('ReactFiber');
-var {isRootBlocked} = require('ReactFiberRoot');
 var {onCommitRoot} = require('ReactFiberDevToolsHook');
 
 var {
@@ -335,12 +334,15 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
             'is likely caused by a bug in React. Please file an issue.',
         );
       } else {
-        earliestExpirationRoot.completedAt = NoWork;
         nextUnitOfWork = createWorkInProgress(
           earliestExpirationRoot.current,
           earliestExpirationTime,
         );
       }
+
+      earliestExpirationRoot.completedAt = NoWork;
+      earliestExpirationRoot.isBlocked = false;
+
       if (earliestExpirationRoot !== nextRenderedTree) {
         // We've switched trees. Reset the nested update counter.
         nestedUpdateCount = 0;
@@ -360,53 +362,18 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
   // TODO: Find a better name for this function. It also schedules completion
   // callbacks, if a root is blocked.
   function shouldWorkOnRoot(root: FiberRoot): ExpirationTime {
-    const completedAt = root.completedAt;
     const expirationTime = root.current.expirationTime;
-
     if (expirationTime === NoWork) {
       // There's no work in this tree.
       return NoWork;
     }
-
-    if (completedAt !== NoWork) {
-      // The root completed but was blocked from committing.
-      if (expirationTime < completedAt) {
-        // We have work that expires earlier than the completed root.
-        return expirationTime;
-      }
-
-      // If the expiration time of the pending work is equal to the time at
-      // which we completed the work-in-progress, it's possible additional
-      // work was scheduled that happens to fall within the same expiration
-      // bucket. We need to check the work-in-progress fiber.
-      if (expirationTime === completedAt) {
-        const workInProgress = root.current.alternate;
-        if (
-          workInProgress !== null &&
-          (workInProgress.expirationTime !== NoWork &&
-            workInProgress.expirationTime <= expirationTime)
-        ) {
-          // We have more work. Restart the completed tree.
-          root.completedAt = NoWork;
-          return expirationTime;
-        }
-      }
-
-      // There have been no higher priority updates since we completed the root.
-      // If it's still blocked, return NoWork, as if it has no more work. If it's
-      // no longer blocked, return the time at which it completed so that we
-      // can commit it.
-      if (isRootBlocked(root, completedAt)) {
-        // We usually process completion callbacks right after a root is
-        // completed. But this root already completed, and it's possible that
-        // we received new completion callbacks since then.
-        processCompletionCallbacks(root, completedAt);
-        return NoWork;
-      }
-
-      return completedAt;
+    if (root.isBlocked) {
+      // We usually process completion callbacks right after a root is
+      // completed. But this root already completed, and it's possible that
+      // we received new completion callbacks since then.
+      processCompletionCallbacks(root, root.completedAt);
+      return NoWork;
     }
-
     return expirationTime;
   }
 
@@ -817,16 +784,12 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
         workInProgress = returnFiber;
         continue;
       } else {
+        // We've reached the root. Mark it as complete.
         const root = workInProgress.stateNode;
-        // We've reached the root. Mark the root as complete. Depending on how
-        // much time we have left, we'll either commit it now or in the
-        // next frame.
-        if (isRootBlocked(root, nextRenderExpirationTime)) {
-          // The root is blocked from committing. Mark it as complete so we
-          // know we can commit it later without starting new work.
-          root.completedAt = nextRenderExpirationTime;
-        } else {
-          // The root is not blocked, so we can commit it now.
+        root.completedAt = nextRenderExpirationTime;
+        // If the root isn't blocked, it's ready to commit. If it is blocked,
+        // we'll come back to it later.
+        if (!root.isBlocked) {
           pendingCommit = workInProgress;
         }
         processCompletionCallbacks(root, nextRenderExpirationTime);
@@ -1509,25 +1472,6 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
     }
   }
 
-  function scheduleRoot(root: FiberRoot, expirationTime: ExpirationTime) {
-    if (expirationTime === NoWork) {
-      return;
-    }
-
-    if (!root.isScheduled) {
-      root.isScheduled = true;
-      if (lastScheduledRoot) {
-        // Schedule ourselves to the end.
-        lastScheduledRoot.nextScheduledRoot = root;
-        lastScheduledRoot = root;
-      } else {
-        // We're the only work scheduled.
-        nextScheduledRoot = root;
-        lastScheduledRoot = root;
-      }
-    }
-  }
-
   function scheduleUpdate(
     fiber: Fiber,
     partialState: mixed,
@@ -1549,6 +1493,7 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
       isReplace,
       isForced,
       nextCallback: null,
+      isTopLevelUnmount: false,
       next: null,
     };
     insertUpdateIntoFiber(fiber, update, currentTime);
@@ -1594,35 +1539,45 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
     }
 
     let node = fiber;
-    let shouldContinue = true;
-    while (node !== null && shouldContinue) {
-      // Walk the parent path to the root and update each node's expiration
-      // time. Once we reach a node whose expiration matches (and whose
-      // alternate's expiration matches) we can exit safely knowing that the
-      // rest of the path is correct.
-      shouldContinue = false;
+    while (node !== null) {
       if (
         node.expirationTime === NoWork ||
         node.expirationTime > expirationTime
       ) {
-        // Expiration time did not match. Update and keep going.
-        shouldContinue = true;
         node.expirationTime = expirationTime;
       }
       if (node.alternate !== null) {
         if (
           node.alternate.expirationTime === NoWork ||
           node.alternate.expirationTime > expirationTime
         ) {
-          // Expiration time did not match. Update and keep going.
-          shouldContinue = true;
           node.alternate.expirationTime = expirationTime;
         }
       }
       if (node.return === null) {
         if (node.tag === HostRoot) {
           const root: FiberRoot = (node.stateNode: any);
-          scheduleRoot(root, expirationTime);
+
+          // Add the root to the work schedule.
+          if (expirationTime !== NoWork) {
+            root.isBlocked = false;
+            if (!root.isScheduled) {
+              root.isScheduled = true;
+              if (lastScheduledRoot) {
+                // Schedule ourselves to the end.
+                lastScheduledRoot.nextScheduledRoot = root;
+                lastScheduledRoot = root;
+              } else {
+                // We're the only work scheduled.
+                nextScheduledRoot = root;
+                lastScheduledRoot = root;
+              }
+            }
+          }
+
+          // If we're not current performing work, we need to either start
+          // working now (if the update is synchronous) or schedule a callback
+          // to perform work later.
           if (!isPerformingWork) {
             const priorityLevel = expirationTimeToPriorityLevel(
               mostRecentCurrentTime,
@@ -1774,6 +1729,7 @@ module.exports = function<T, P, I, TI, PI, C, CX, PL>(
       'Cannot commit while already performing work.',
     );
     root.forceExpire = expirationTime;
+    root.isBlocked = false;
     try {
       performWork(TaskPriority, null);
     } finally {