@samitouri / QOS-React-1 / commits / 0d1ae5d753

cleanup enableProfilerNestedUpdateScheduledHook feature flag (#28509)

## Summary Looks like this was added years ago for instrumentation at meta that never ended up rolling out. Should be safe to clean up. ## How did you test this change? `yarn test`

Noah Lemen committed Mar 11, 2024 at 11:37 UTC 0d1ae5d753044fae99bc37a7815aa947447de3f8
10 files changed -504
packages/react-reconciler/src/ReactFiberWorkLoop.js
-36
@@ -30,7 +30,6 @@ import {
30 enableProfilerTimer,
31 enableProfilerCommitHooks,
32 enableProfilerNestedUpdatePhase,
33 - enableProfilerNestedUpdateScheduledHook,
33 enableDebugTracing,
34 enableSchedulingProfiler,
35 disableSchedulerTimeoutInWorkLoop,
@@ -107,7 +106,6 @@ import {
106 ForwardRef,
107 MemoComponent,
108 SimpleMemoComponent,
110 - Profiler,
109 HostComponent,
110 HostHoistable,
111 HostSingleton,
@@ -581,10 +579,6 @@ let hasUncaughtError = false;
579 let firstUncaughtError = null;
580 let legacyErrorBoundariesThatAlreadyFailed: Set<mixed> | null = null;
581
584 -// Only used when enableProfilerNestedUpdateScheduledHook is true;
585 -// to track which root is currently committing layout effects.
586 -let rootCommittingMutationOrLayoutEffects: FiberRoot | null = null;
587 -
582 let rootDoesHavePassiveEffects: boolean = false;
583 let rootWithPendingPassiveEffects: FiberRoot | null = null;
584 let pendingPassiveEffectsLanes: Lanes = NoLanes;
@@ -807,26 +801,6 @@ export function scheduleUpdateOnFiber(
801
802 warnIfUpdatesNotWrappedWithActDEV(fiber);
803
810 - if (enableProfilerTimer && enableProfilerNestedUpdateScheduledHook) {
811 - if (
812 - (executionContext & CommitContext) !== NoContext &&
813 - root === rootCommittingMutationOrLayoutEffects
814 - ) {
815 - if (fiber.mode & ProfileMode) {
816 - let current: null | Fiber = fiber;
817 - while (current !== null) {
818 - if (current.tag === Profiler) {
819 - const {id, onNestedUpdateScheduled} = current.memoizedProps;
820 - if (typeof onNestedUpdateScheduled === 'function') {
821 - onNestedUpdateScheduled(id);
822 - }
823 - }
824 - current = current.return;
825 - }
826 - }
827 - }
828 - }
829 -
804 if (enableTransitionTracing) {
805 const transition = ReactCurrentBatchConfig.transition;
806 if (transition !== null && transition.name != null) {
@@ -2938,12 +2912,6 @@ function commitRootImpl(
2912 recordCommitTime();
2913 }
2914
2941 - if (enableProfilerTimer && enableProfilerNestedUpdateScheduledHook) {
2942 - // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
2943 - // Updates scheduled during ref detachment should also be flagged.
2944 - rootCommittingMutationOrLayoutEffects = root;
2945 - }
2946 -
2915 // The next phase is the mutation phase, where we mutate the host tree.
2916 commitMutationEffects(root, finishedWork, lanes);
2917
@@ -2982,10 +2950,6 @@ function commitRootImpl(
2950 markLayoutEffectsStopped();
2951 }
2952
2985 - if (enableProfilerTimer && enableProfilerNestedUpdateScheduledHook) {
2986 - rootCommittingMutationOrLayoutEffects = null;
2987 - }
2988 -
2953 // Tell Scheduler to yield at the end of the frame, so the browser has an
2954 // opportunity to paint.
2955 requestPaint();
packages/react/src/__tests__/ReactProfiler-test.internal.js
-456
@@ -26,7 +26,6 @@ function loadModules({
26 enableProfilerTimer = true,
27 enableProfilerCommitHooks = true,
28 enableProfilerNestedUpdatePhase = true,
29 - enableProfilerNestedUpdateScheduledHook = false,
29 replayFailedUnitOfWorkWithInvokeGuardedCallback = false,
30 useNoopRenderer = false,
31 } = {}) {
@@ -36,8 +35,6 @@ function loadModules({
35 ReactFeatureFlags.enableProfilerCommitHooks = enableProfilerCommitHooks;
36 ReactFeatureFlags.enableProfilerNestedUpdatePhase =
37 enableProfilerNestedUpdatePhase;
39 - ReactFeatureFlags.enableProfilerNestedUpdateScheduledHook =
40 - enableProfilerNestedUpdateScheduledHook;
38 ReactFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback =
39 replayFailedUnitOfWorkWithInvokeGuardedCallback;
40
@@ -2319,456 +2316,3 @@ describe(`onPostCommit`, () => {
2316 expect(call[3]).toBe(11221221); // commit start time (before mutations or effects)
2317 });
2318 });
2322 -
2323 -describe(`onNestedUpdateScheduled`, () => {
2324 - beforeEach(() => {
2325 - jest.resetModules();
2326 -
2327 - loadModules({
2328 - enableProfilerNestedUpdateScheduledHook: true,
2329 - useNoopRenderer: true,
2330 - });
2331 - });
2332 -
2333 - it('is not called when the legacy render API is used to schedule an update', () => {
2334 - const onNestedUpdateScheduled = jest.fn();
2335 -
2336 - ReactNoop.renderLegacySyncRoot(
2337 - <React.Profiler
2338 - id="test"
2339 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2340 - <div>initial</div>
2341 - </React.Profiler>,
2342 - );
2343 -
2344 - ReactNoop.renderLegacySyncRoot(
2345 - <React.Profiler
2346 - id="test"
2347 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2348 - <div>update</div>
2349 - </React.Profiler>,
2350 - );
2351 -
2352 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2353 - });
2354 -
2355 - it('is not called when the root API is used to schedule an update', () => {
2356 - const onNestedUpdateScheduled = jest.fn();
2357 -
2358 - ReactNoop.render(
2359 - <React.Profiler
2360 - id="test"
2361 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2362 - <div>initial</div>
2363 - </React.Profiler>,
2364 - );
2365 -
2366 - ReactNoop.render(
2367 - <React.Profiler
2368 - id="test"
2369 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2370 - <div>update</div>
2371 - </React.Profiler>,
2372 - );
2373 -
2374 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2375 - });
2376 -
2377 - it('is called when a function component schedules an update during a layout effect', async () => {
2378 - function Component() {
2379 - const [didMount, setDidMount] = React.useState(false);
2380 - React.useLayoutEffect(() => {
2381 - setDidMount(true);
2382 - }, []);
2383 - Scheduler.log(`Component:${didMount}`);
2384 - return didMount;
2385 - }
2386 -
2387 - const onNestedUpdateScheduled = jest.fn();
2388 -
2389 - await act(() => {
2390 - ReactNoop.render(
2391 - <React.Profiler
2392 - id="test"
2393 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2394 - <Component />
2395 - </React.Profiler>,
2396 - );
2397 - });
2398 -
2399 - assertLog(['Component:false', 'Component:true']);
2400 - expect(onNestedUpdateScheduled).toHaveBeenCalledTimes(1);
2401 - expect(onNestedUpdateScheduled.mock.calls[0][0]).toBe('test');
2402 - });
2403 -
2404 - it('is called when a function component schedules a batched update during a layout effect', async () => {
2405 - function Component() {
2406 - const [didMount, setDidMount] = React.useState(false);
2407 - React.useLayoutEffect(() => {
2408 - ReactNoop.batchedUpdates(() => {
2409 - setDidMount(true);
2410 - });
2411 - }, []);
2412 - Scheduler.log(`Component:${didMount}`);
2413 - return didMount;
2414 - }
2415 -
2416 - const onNestedUpdateScheduled = jest.fn();
2417 - const onRender = jest.fn();
2418 -
2419 - ReactNoop.render(
2420 - <React.Profiler
2421 - id="root"
2422 - onNestedUpdateScheduled={onNestedUpdateScheduled}
2423 - onRender={onRender}>
2424 - <Component />
2425 - </React.Profiler>,
2426 - );
2427 - await waitForAll(['Component:false', 'Component:true']);
2428 -
2429 - expect(onRender).toHaveBeenCalledTimes(2);
2430 - expect(onRender.mock.calls[0][1]).toBe('mount');
2431 - expect(onRender.mock.calls[1][1]).toBe('nested-update');
2432 -
2433 - expect(onNestedUpdateScheduled).toHaveBeenCalledTimes(1);
2434 - expect(onNestedUpdateScheduled.mock.calls[0][0]).toBe('root');
2435 - });
2436 -
2437 - it('bubbles up and calls all ancestor Profilers', async () => {
2438 - function Component() {
2439 - const [didMount, setDidMount] = React.useState(false);
2440 - React.useLayoutEffect(() => {
2441 - setDidMount(true);
2442 - }, []);
2443 - Scheduler.log(`Component:${didMount}`);
2444 - return didMount;
2445 - }
2446 - const onNestedUpdateScheduledOne = jest.fn();
2447 - const onNestedUpdateScheduledTwo = jest.fn();
2448 - const onNestedUpdateScheduledThree = jest.fn();
2449 -
2450 - await act(() => {
2451 - ReactNoop.render(
2452 - <React.Profiler
2453 - id="one"
2454 - onNestedUpdateScheduled={onNestedUpdateScheduledOne}>
2455 - <React.Profiler
2456 - id="two"
2457 - onNestedUpdateScheduled={onNestedUpdateScheduledTwo}>
2458 - <>
2459 - <Component />
2460 - <React.Profiler
2461 - id="three"
2462 - onNestedUpdateScheduled={onNestedUpdateScheduledThree}
2463 - />
2464 - </>
2465 - </React.Profiler>
2466 - </React.Profiler>,
2467 - );
2468 - });
2469 -
2470 - assertLog(['Component:false', 'Component:true']);
2471 - expect(onNestedUpdateScheduledOne).toHaveBeenCalledTimes(1);
2472 - expect(onNestedUpdateScheduledOne.mock.calls[0][0]).toBe('one');
2473 - expect(onNestedUpdateScheduledTwo).toHaveBeenCalledTimes(1);
2474 - expect(onNestedUpdateScheduledTwo.mock.calls[0][0]).toBe('two');
2475 - expect(onNestedUpdateScheduledThree).not.toHaveBeenCalled();
2476 - });
2477 -
2478 - it('is not called when an update is scheduled for another doort during a layout effect', async () => {
2479 - const setStateRef = React.createRef(null);
2480 -
2481 - function ComponentRootOne() {
2482 - const [state, setState] = React.useState(false);
2483 - setStateRef.current = setState;
2484 - Scheduler.log(`ComponentRootOne:${state}`);
2485 - return state;
2486 - }
2487 -
2488 - function ComponentRootTwo() {
2489 - React.useLayoutEffect(() => {
2490 - setStateRef.current(true);
2491 - }, []);
2492 - Scheduler.log('ComponentRootTwo');
2493 - return null;
2494 - }
2495 -
2496 - const onNestedUpdateScheduled = jest.fn();
2497 -
2498 - await act(() => {
2499 - ReactNoop.renderToRootWithID(
2500 - <React.Profiler
2501 - id="test"
2502 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2503 - <ComponentRootOne />
2504 - </React.Profiler>,
2505 - 1,
2506 - );
2507 -
2508 - ReactNoop.renderToRootWithID(
2509 - <React.Profiler
2510 - id="test"
2511 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2512 - <ComponentRootTwo />
2513 - </React.Profiler>,
2514 - 2,
2515 - );
2516 - });
2517 -
2518 - assertLog([
2519 - 'ComponentRootOne:false',
2520 - 'ComponentRootTwo',
2521 - 'ComponentRootOne:true',
2522 - ]);
2523 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2524 - });
2525 -
2526 - it('is not called when a function component schedules an update during a passive effect', async () => {
2527 - function Component() {
2528 - const [didMount, setDidMount] = React.useState(false);
2529 - React.useEffect(() => {
2530 - setDidMount(true);
2531 - }, []);
2532 - Scheduler.log(`Component:${didMount}`);
2533 - return didMount;
2534 - }
2535 -
2536 - const onNestedUpdateScheduled = jest.fn();
2537 -
2538 - await act(() => {
2539 - ReactNoop.render(
2540 - <React.Profiler
2541 - id="test"
2542 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2543 - <Component />
2544 - </React.Profiler>,
2545 - );
2546 - });
2547 -
2548 - assertLog(['Component:false', 'Component:true']);
2549 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2550 - });
2551 -
2552 - it('is not called when a function component schedules an update outside of render', async () => {
2553 - const updateFnRef = React.createRef(null);
2554 -
2555 - function Component() {
2556 - const [state, setState] = React.useState(false);
2557 - updateFnRef.current = () => setState(true);
2558 - Scheduler.log(`Component:${state}`);
2559 - return state;
2560 - }
2561 -
2562 - const onNestedUpdateScheduled = jest.fn();
2563 -
2564 - await act(() => {
2565 - ReactNoop.render(
2566 - <React.Profiler
2567 - id="test"
2568 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2569 - <Component />
2570 - </React.Profiler>,
2571 - );
2572 - });
2573 - assertLog(['Component:false']);
2574 -
2575 - await act(() => {
2576 - updateFnRef.current();
2577 - });
2578 - assertLog(['Component:true']);
2579 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2580 - });
2581 -
2582 - it('it is not called when a component schedules an update during render', async () => {
2583 - function Component() {
2584 - const [state, setState] = React.useState(false);
2585 - if (state === false) {
2586 - setState(true);
2587 - }
2588 - Scheduler.log(`Component:${state}`);
2589 - return state;
2590 - }
2591 -
2592 - const onNestedUpdateScheduled = jest.fn();
2593 -
2594 - await act(() => {
2595 - ReactNoop.render(
2596 - <React.Profiler
2597 - id="test"
2598 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2599 - <Component />
2600 - </React.Profiler>,
2601 - );
2602 - });
2603 -
2604 - assertLog(['Component:false', 'Component:true']);
2605 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2606 - });
2607 -
2608 - it('it is called when a component schedules an update from a ref callback', async () => {
2609 - function Component({mountChild}) {
2610 - const [refAttached, setRefAttached] = React.useState(false);
2611 - const [refDetached, setRefDetached] = React.useState(false);
2612 - const refSetter = React.useCallback(ref => {
2613 - if (ref !== null) {
2614 - setRefAttached(true);
2615 - } else {
2616 - setRefDetached(true);
2617 - }
2618 - }, []);
2619 - Scheduler.log(`Component:${refAttached}:${refDetached}`);
2620 - return mountChild ? <div ref={refSetter} /> : null;
2621 - }
2622 -
2623 - const onNestedUpdateScheduled = jest.fn();
2624 -
2625 - await act(() => {
2626 - ReactNoop.render(
2627 - <React.Profiler
2628 - id="test"
2629 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2630 - <Component mountChild={true} />
2631 - </React.Profiler>,
2632 - );
2633 - });
2634 -
2635 - assertLog(['Component:false:false', 'Component:true:false']);
2636 - expect(onNestedUpdateScheduled).toHaveBeenCalledTimes(1);
2637 - expect(onNestedUpdateScheduled.mock.calls[0][0]).toBe('test');
2638 -
2639 - await act(() => {
2640 - ReactNoop.render(
2641 - <React.Profiler
2642 - id="test"
2643 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2644 - <Component mountChild={false} />
2645 - </React.Profiler>,
2646 - );
2647 - });
2648 -
2649 - assertLog(['Component:true:false', 'Component:true:true']);
2650 - expect(onNestedUpdateScheduled).toHaveBeenCalledTimes(2);
2651 - expect(onNestedUpdateScheduled.mock.calls[1][0]).toBe('test');
2652 - });
2653 -
2654 - it('is called when a class component schedules an update from the componentDidMount lifecycles', async () => {
2655 - class Component extends React.Component {
2656 - state = {
2657 - value: false,
2658 - };
2659 - componentDidMount() {
2660 - this.setState({value: true});
2661 - }
2662 - render() {
2663 - const {value} = this.state;
2664 - Scheduler.log(`Component:${value}`);
2665 - return value;
2666 - }
2667 - }
2668 -
2669 - const onNestedUpdateScheduled = jest.fn();
2670 -
2671 - await act(() => {
2672 - ReactNoop.render(
2673 - <React.Profiler
2674 - id="test"
2675 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2676 - <Component />
2677 - </React.Profiler>,
2678 - );
2679 - });
2680 -
2681 - assertLog(['Component:false', 'Component:true']);
2682 - expect(onNestedUpdateScheduled).toHaveBeenCalledTimes(1);
2683 - expect(onNestedUpdateScheduled.mock.calls[0][0]).toBe('test');
2684 - });
2685 -
2686 - it('is called when a class component schedules an update from the componentDidUpdate lifecycles', async () => {
2687 - class Component extends React.Component {
2688 - state = {
2689 - nestedUpdateSheduled: false,
2690 - };
2691 - componentDidUpdate(prevProps, prevState) {
2692 - if (
2693 - this.props.scheduleNestedUpdate &&
2694 - !this.state.nestedUpdateSheduled
2695 - ) {
2696 - this.setState({nestedUpdateSheduled: true});
2697 - }
2698 - }
2699 - render() {
2700 - const {scheduleNestedUpdate} = this.props;
2701 - const {nestedUpdateSheduled} = this.state;
2702 - Scheduler.log(
2703 - `Component:${scheduleNestedUpdate}:${nestedUpdateSheduled}`,
2704 - );
2705 - return nestedUpdateSheduled;
2706 - }
2707 - }
2708 -
2709 - const onNestedUpdateScheduled = jest.fn();
2710 -
2711 - await act(() => {
2712 - ReactNoop.render(
2713 - <React.Profiler
2714 - id="test"
2715 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2716 - <Component scheduleNestedUpdate={false} />
2717 - </React.Profiler>,
2718 - );
2719 - });
2720 - assertLog(['Component:false:false']);
2721 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2722 -
2723 - await act(() => {
2724 - ReactNoop.render(
2725 - <React.Profiler
2726 - id="test"
2727 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2728 - <Component scheduleNestedUpdate={true} />
2729 - </React.Profiler>,
2730 - );
2731 - });
2732 -
2733 - assertLog(['Component:true:false', 'Component:true:true']);
2734 - expect(onNestedUpdateScheduled).toHaveBeenCalledTimes(1);
2735 - expect(onNestedUpdateScheduled.mock.calls[0][0]).toBe('test');
2736 - });
2737 -
2738 - it('is not called when a class component schedules an update outside of render', async () => {
2739 - const updateFnRef = React.createRef(null);
2740 -
2741 - class Component extends React.Component {
2742 - state = {
2743 - value: false,
2744 - };
2745 - render() {
2746 - const {value} = this.state;
2747 - updateFnRef.current = () => this.setState({value: true});
2748 - Scheduler.log(`Component:${value}`);
2749 - return value;
2750 - }
2751 - }
2752 -
2753 - const onNestedUpdateScheduled = jest.fn();
2754 -
2755 - await act(() => {
2756 - ReactNoop.render(
2757 - <React.Profiler
2758 - id="test"
2759 - onNestedUpdateScheduled={onNestedUpdateScheduled}>
2760 - <Component />
2761 - </React.Profiler>,
2762 - );
2763 - });
2764 - assertLog(['Component:false']);
2765 -
2766 - await act(() => {
2767 - updateFnRef.current();
2768 - });
2769 - assertLog(['Component:true']);
2770 - expect(onNestedUpdateScheduled).not.toHaveBeenCalled();
2771 - });
2772 -
2773 - // TODO Add hydration tests to ensure we don't have false positives called.
2774 -});
packages/shared/ReactFeatureFlags.js
-4
@@ -277,10 +277,6 @@ export const enableUpdaterTracking = __PROFILE__;
277 // Internal only.
278 export const enableGetInspectorDataForInstanceInProduction = false;
279
280 -// Profiler API accepts a function to be called when a nested update is scheduled.
281 -// This callback accepts the component type (class instance or function) the update is scheduled for.
282 -export const enableProfilerNestedUpdateScheduledHook = false;
283 -
280 export const consoleManagedByDevToolsDuringStrictMode = true;
281
282 export const enableDO_NOT_USE_disableStrictPassiveEffect = false;
packages/shared/forks/ReactFeatureFlags.native-fb.js
-1
@@ -40,7 +40,6 @@ export const enableSchedulingProfiler = __PROFILE__;
40 export const enableProfilerTimer = __PROFILE__;
41 export const enableProfilerCommitHooks = __PROFILE__;
42 export const enableProfilerNestedUpdatePhase = __PROFILE__;
43 -export const enableProfilerNestedUpdateScheduledHook = false;
43 export const enableUpdaterTracking = __PROFILE__;
44 export const enableCache = true;
45 export const enableLegacyCache = false;
packages/shared/forks/ReactFeatureFlags.native-oss.js
-1
@@ -18,7 +18,6 @@ export const replayFailedUnitOfWorkWithInvokeGuardedCallback = __DEV__;
18 export const enableProfilerTimer = __PROFILE__;
19 export const enableProfilerCommitHooks = __PROFILE__;
20 export const enableProfilerNestedUpdatePhase = __PROFILE__;
21 -export const enableProfilerNestedUpdateScheduledHook = false;
21 export const enableUpdaterTracking = __PROFILE__;
22 export const enableCache = true;
23 export const enableLegacyCache = false;
packages/shared/forks/ReactFeatureFlags.test-renderer.js
-1
@@ -18,7 +18,6 @@ export const replayFailedUnitOfWorkWithInvokeGuardedCallback = false;
18 export const enableProfilerTimer = __PROFILE__;
19 export const enableProfilerCommitHooks = __PROFILE__;
20 export const enableProfilerNestedUpdatePhase = __PROFILE__;
21 -export const enableProfilerNestedUpdateScheduledHook = false;
21 export const enableUpdaterTracking = false;
22 export const enableCache = true;
23 export const enableLegacyCache = __EXPERIMENTAL__;
packages/shared/forks/ReactFeatureFlags.test-renderer.native.js
-1
@@ -18,7 +18,6 @@ export const replayFailedUnitOfWorkWithInvokeGuardedCallback = false;
18 export const enableProfilerTimer = __PROFILE__;
19 export const enableProfilerCommitHooks = __PROFILE__;
20 export const enableProfilerNestedUpdatePhase = __PROFILE__;
21 -export const enableProfilerNestedUpdateScheduledHook = false;
21 export const enableUpdaterTracking = false;
22 export const enableCache = true;
23 export const enableLegacyCache = false;
packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
-1
@@ -18,7 +18,6 @@ export const replayFailedUnitOfWorkWithInvokeGuardedCallback = false;
18 export const enableProfilerTimer = __PROFILE__;
19 export const enableProfilerCommitHooks = __PROFILE__;
20 export const enableProfilerNestedUpdatePhase = __PROFILE__;
21 -export const enableProfilerNestedUpdateScheduledHook = false;
21 export const enableUpdaterTracking = false;
22 export const enableCache = true;
23 export const enableLegacyCache = true;
packages/shared/forks/ReactFeatureFlags.www-dynamic.js
-1
@@ -17,7 +17,6 @@ export const disableInputAttributeSyncing = __VARIANT__;
17 export const disableIEWorkarounds = __VARIANT__;
18 export const enableLegacyFBSupport = __VARIANT__;
19 export const enableUseRefAccessWarning = __VARIANT__;
20 -export const enableProfilerNestedUpdateScheduledHook = __VARIANT__;
20 export const disableSchedulerTimeoutInWorkLoop = __VARIANT__;
21 export const enableLazyContextPropagation = __VARIANT__;
22 export const forceConcurrentByDefaultForTesting = __VARIANT__;
packages/shared/forks/ReactFeatureFlags.www.js
-2
@@ -48,8 +48,6 @@ export const debugRenderPhaseSideEffectsForStrictMode = __DEV__;
48 export const enableProfilerTimer = __PROFILE__;
49 export const enableProfilerCommitHooks = __PROFILE__;
50 export const enableProfilerNestedUpdatePhase = __PROFILE__;
51 -export const enableProfilerNestedUpdateScheduledHook: boolean =
52 - __PROFILE__ && dynamicFeatureFlags.enableProfilerNestedUpdateScheduledHook;
51 export const enableUpdaterTracking = __PROFILE__;
52
53 export const enableSuspenseAvoidThisFallback = true;