Remove forceConcurrentByDefaultForTesting flag

packages/react-art/src/__tests__/ReactART-test.js

@@ -23,23 +23,15 @@ import Circle from 'react-art/Circle';
 import Rectangle from 'react-art/Rectangle';
 import Wedge from 'react-art/Wedge';
 
-const {act, waitFor} = require('internal-test-utils');
+const {act} = require('internal-test-utils');
 
 // Isolate DOM renderer.
 jest.resetModules();
 // share isomorphic
 jest.mock('scheduler', () => Scheduler);
 jest.mock('react', () => React);
-const ReactDOM = require('react-dom');
 const ReactDOMClient = require('react-dom/client');
 
-// Isolate the noop renderer
-jest.resetModules();
-// share isomorphic
-jest.mock('scheduler', () => Scheduler);
-jest.mock('react', () => React);
-const ReactNoop = require('react-noop-renderer');
-
 let Group;
 let Shape;
 let Surface;
@@ -397,58 +389,6 @@ describe('ReactART', () => {
     doClick(instance);
     expect(onClick2).toBeCalled();
   });
-
-  // @gate forceConcurrentByDefaultForTesting
-  it('can concurrently render with a "primary" renderer while sharing context', async () => {
-    const CurrentRendererContext = React.createContext(null);
-
-    function Yield(props) {
-      Scheduler.log(props.value);
-      return null;
-    }
-
-    let ops = [];
-    function LogCurrentRenderer() {
-      return (
-        <CurrentRendererContext.Consumer>
-          {currentRenderer => {
-            ops.push(currentRenderer);
-            return null;
-          }}
-        </CurrentRendererContext.Consumer>
-      );
-    }
-
-    ReactNoop.render(
-      <CurrentRendererContext.Provider value="Test">
-        <Yield value="A" />
-        <Yield value="B" />
-        <LogCurrentRenderer />
-        <Yield value="C" />
-      </CurrentRendererContext.Provider>,
-    );
-
-    await waitFor(['A']);
-
-    const root = ReactDOMClient.createRoot(container);
-    // We use flush sync here because we expect this to render in between
-    // while the concurrent render is yieldy where as act would flush both.
-    ReactDOM.flushSync(() => {
-      root.render(
-        <Surface>
-          <LogCurrentRenderer />
-          <CurrentRendererContext.Provider value="ART">
-            <LogCurrentRenderer />
-          </CurrentRendererContext.Provider>
-        </Surface>,
-      );
-    });
-
-    ops = [];
-    await waitFor(['B', 'C']);
-
-    expect(ops).toEqual(['Test']);
-  });
 });
 
 describe('ReactARTComponents', () => {

packages/react-dom/src/__tests__/ReactDOMNativeEventHeuristic-test.js

@@ -313,11 +313,7 @@ describe('ReactDOMNativeEventHeuristic-test', () => {
       expect(container.textContent).toEqual('not hovered');
 
       await waitFor(['hovered']);
-      if (gate(flags => flags.forceConcurrentByDefaultForTesting)) {
-        expect(container.textContent).toEqual('not hovered');
-      } else {
-        expect(container.textContent).toEqual('hovered');
-      }
+      expect(container.textContent).toEqual('hovered');
     });
     expect(container.textContent).toEqual('hovered');
   });

packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js

@@ -2551,14 +2551,7 @@ describe('ReactDOMServerPartialHydration', () => {
     suspend = true;
 
     await act(async () => {
-      if (gate(flags => flags.forceConcurrentByDefaultForTesting)) {
-        await waitFor(['Before']);
-        // This took a long time to render.
-        Scheduler.unstable_advanceTime(1000);
-        await waitFor(['After']);
-      } else {
-        await waitFor(['Before', 'After']);
-      }
+      await waitFor(['Before', 'After']);
 
       // This will cause us to skip the second row completely.
     });

packages/react-reconciler/src/ReactFiber.js

@@ -31,7 +31,6 @@ import {
   enableProfilerTimer,
   enableScopeAPI,
   enableLegacyHidden,
-  forceConcurrentByDefaultForTesting,
   allowConcurrentByDefault,
   enableTransitionTracing,
   enableDebugTracing,
@@ -534,11 +533,6 @@ export function createHostRootFiber(
       mode |= StrictLegacyMode | StrictEffectsMode;
     }
     if (
-      // We only use this flag for our repo tests to check both behaviors.
-      forceConcurrentByDefaultForTesting
-    ) {
-      mode |= ConcurrentUpdatesByDefaultMode;
-    } else if (
       // Only for internal experiments.
       allowConcurrentByDefault &&
       concurrentUpdatesByDefaultOverride
@@ -588,8 +582,8 @@ export function createFiberFromTypeAndProps(
       fiberTag = isHostHoistableType(type, pendingProps, hostContext)
         ? HostHoistable
         : isHostSingletonType(type)
-          ? HostSingleton
-          : HostComponent;
+        ? HostSingleton
+        : HostComponent;
     } else if (supportsResources) {
       const hostContext = getHostContext();
       fiberTag = isHostHoistableType(type, pendingProps, hostContext)

packages/react-reconciler/src/__tests__/ReactExpiration-test.js

@@ -115,54 +115,28 @@ describe('ReactExpiration', () => {
     }
   }
 
-  function flushNextRenderIfExpired() {
-    // This will start rendering the next level of work. If the work hasn't
-    // expired yet, React will exit without doing anything. If it has expired,
-    // it will schedule a sync task.
-    Scheduler.unstable_flushExpired();
-    // Flush the sync task.
-    ReactNoop.flushSync();
-  }
-
   it('increases priority of updates as time progresses', async () => {
-    if (gate(flags => flags.forceConcurrentByDefaultForTesting)) {
-      ReactNoop.render(<span prop="done" />);
-      expect(ReactNoop).toMatchRenderedOutput(null);
-
-      // Nothing has expired yet because time hasn't advanced.
-      flushNextRenderIfExpired();
-      expect(ReactNoop).toMatchRenderedOutput(null);
-      // Advance time a bit, but not enough to expire the low pri update.
-      ReactNoop.expire(4500);
-      flushNextRenderIfExpired();
-      expect(ReactNoop).toMatchRenderedOutput(null);
-      // Advance by another second. Now the update should expire and flush.
-      ReactNoop.expire(500);
-      flushNextRenderIfExpired();
-      expect(ReactNoop).toMatchRenderedOutput(<span prop="done" />);
-    } else {
-      ReactNoop.render(<Text text="Step 1" />);
-      React.startTransition(() => {
-        ReactNoop.render(<Text text="Step 2" />);
-      });
-      await waitFor(['Step 1']);
+    ReactNoop.render(<Text text="Step 1" />);
+    React.startTransition(() => {
+      ReactNoop.render(<Text text="Step 2" />);
+    });
+    await waitFor(['Step 1']);
 
-      expect(ReactNoop).toMatchRenderedOutput('Step 1');
+    expect(ReactNoop).toMatchRenderedOutput('Step 1');
 
-      // Nothing has expired yet because time hasn't advanced.
-      await unstable_waitForExpired([]);
-      expect(ReactNoop).toMatchRenderedOutput('Step 1');
+    // Nothing has expired yet because time hasn't advanced.
+    await unstable_waitForExpired([]);
+    expect(ReactNoop).toMatchRenderedOutput('Step 1');
 
-      // Advance time a bit, but not enough to expire the low pri update.
-      ReactNoop.expire(4500);
-      await unstable_waitForExpired([]);
-      expect(ReactNoop).toMatchRenderedOutput('Step 1');
+    // Advance time a bit, but not enough to expire the low pri update.
+    ReactNoop.expire(4500);
+    await unstable_waitForExpired([]);
+    expect(ReactNoop).toMatchRenderedOutput('Step 1');
 
-      // Advance by a little bit more. Now the update should expire and flush.
-      ReactNoop.expire(500);
-      await unstable_waitForExpired(['Step 2']);
-      expect(ReactNoop).toMatchRenderedOutput('Step 2');
-    }
+    // Advance by a little bit more. Now the update should expire and flush.
+    ReactNoop.expire(500);
+    await unstable_waitForExpired(['Step 2']);
+    expect(ReactNoop).toMatchRenderedOutput('Step 2');
   });
 
   it('two updates of like priority in the same event always flush within the same batch', async () => {
@@ -408,57 +382,36 @@ describe('ReactExpiration', () => {
     jest.resetModules();
     Scheduler = require('scheduler');
 
-    if (gate(flags => flags.forceConcurrentByDefaultForTesting)) {
-      // Before importing the renderer, advance the current time by a number
-      // larger than the maximum allowed for bitwise operations.
-      const maxSigned31BitInt = 1073741823;
-      Scheduler.unstable_advanceTime(maxSigned31BitInt * 100);
-      // Now import the renderer. On module initialization, it will read the
-      // current time.
-      ReactNoop = require('react-noop-renderer');
-      ReactNoop.render('Hi');
+    const InternalTestUtils = require('internal-test-utils');
+    waitFor = InternalTestUtils.waitFor;
+    assertLog = InternalTestUtils.assertLog;
+    unstable_waitForExpired = InternalTestUtils.unstable_waitForExpired;
 
-      // The update should not have expired yet.
-      flushNextRenderIfExpired();
-      await waitFor([]);
-      expect(ReactNoop).toMatchRenderedOutput(null);
-      // Advance the time some more to expire the update.
-      Scheduler.unstable_advanceTime(10000);
-      flushNextRenderIfExpired();
-      await waitFor([]);
-      expect(ReactNoop).toMatchRenderedOutput('Hi');
-    } else {
-      const InternalTestUtils = require('internal-test-utils');
-      waitFor = InternalTestUtils.waitFor;
-      assertLog = InternalTestUtils.assertLog;
-      unstable_waitForExpired = InternalTestUtils.unstable_waitForExpired;
-
-      // Before importing the renderer, advance the current time by a number
-      // larger than the maximum allowed for bitwise operations.
-      const maxSigned31BitInt = 1073741823;
-      Scheduler.unstable_advanceTime(maxSigned31BitInt * 100);
-
-      // Now import the renderer. On module initialization, it will read the
-      // current time.
-      ReactNoop = require('react-noop-renderer');
-      React = require('react');
-
-      ReactNoop.render(<Text text="Step 1" />);
-      React.startTransition(() => {
-        ReactNoop.render(<Text text="Step 2" />);
-      });
-      await waitFor(['Step 1']);
+    // Before importing the renderer, advance the current time by a number
+    // larger than the maximum allowed for bitwise operations.
+    const maxSigned31BitInt = 1073741823;
+    Scheduler.unstable_advanceTime(maxSigned31BitInt * 100);
+
+    // Now import the renderer. On module initialization, it will read the
+    // current time.
+    ReactNoop = require('react-noop-renderer');
+    React = require('react');
+
+    ReactNoop.render(<Text text="Step 1" />);
+    React.startTransition(() => {
+      ReactNoop.render(<Text text="Step 2" />);
+    });
+    await waitFor(['Step 1']);
 
-      // The update should not have expired yet.
-      await unstable_waitForExpired([]);
+    // The update should not have expired yet.
+    await unstable_waitForExpired([]);
 
-      expect(ReactNoop).toMatchRenderedOutput('Step 1');
+    expect(ReactNoop).toMatchRenderedOutput('Step 1');
 
-      // Advance the time some more to expire the update.
-      Scheduler.unstable_advanceTime(10000);
-      await unstable_waitForExpired(['Step 2']);
-      expect(ReactNoop).toMatchRenderedOutput('Step 2');
-    }
+    // Advance the time some more to expire the update.
+    Scheduler.unstable_advanceTime(10000);
+    await unstable_waitForExpired(['Step 2']);
+    expect(ReactNoop).toMatchRenderedOutput('Step 2');
   });
 
   it('should measure callback timeout relative to current time, not start-up time', async () => {

packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js

@@ -1540,39 +1540,21 @@ describe('ReactHooksWithNoopRenderer', () => {
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: (empty)" />);
 
         // Rendering again should flush the previous commit's effects
-        if (gate(flags => flags.forceConcurrentByDefaultForTesting)) {
+        React.startTransition(() => {
           ReactNoop.render(<Counter count={1} />, () =>
             Scheduler.log('Sync effect'),
           );
-        } else {
-          React.startTransition(() => {
-            ReactNoop.render(<Counter count={1} />, () =>
-              Scheduler.log('Sync effect'),
-            );
-          });
-        }
+        });
 
         await waitFor(['Schedule update [0]', 'Count: 0']);
 
-        if (gate(flags => flags.forceConcurrentByDefaultForTesting)) {
-          expect(ReactNoop).toMatchRenderedOutput(
-            <span prop="Count: (empty)" />,
-          );
-          await waitFor(['Sync effect']);
-          expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
-
-          ReactNoop.flushPassiveEffects();
-          assertLog(['Schedule update [1]']);
-          await waitForAll(['Count: 1']);
-        } else {
-          expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
-          await waitFor([
-            'Count: 0',
-            'Sync effect',
-            'Schedule update [1]',
-            'Count: 1',
-          ]);
-        }
+        expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
+        await waitFor([
+          'Count: 0',
+          'Sync effect',
+          'Schedule update [1]',
+          'Count: 1',
+        ]);
 
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
@@ -3446,10 +3428,14 @@ describe('ReactHooksWithNoopRenderer', () => {
       let totalRefUpdates = 0;
       function Counter(props, ref) {
         const [count, dispatch] = useReducer(reducer, 0);
-        useImperativeHandle(ref, () => {
-          totalRefUpdates++;
-          return {count, dispatch};
-        }, [count]);
+        useImperativeHandle(
+          ref,
+          () => {
+            totalRefUpdates++;
+            return {count, dispatch};
+          },
+          [count],
+        );
         return <Text text={'Count: ' + count} />;
       }