react-native-tvos 0.87.1-1 → 0.88.0-0

package/ReactCommon/react/timing/tests/PrimitivesTest.cpp

@@ -7,10 +7,21 @@
 
 #include <gtest/gtest.h>
 
+#include <array>
+
 #include "../primitives.h"
 
 namespace facebook::react {
 
+// Nanosecond counts that are not a whole number of milliseconds, spanning the
+// magnitudes a monotonic clock reports (seconds to weeks since boot).
+constexpr std::array<int64_t, 5> kRoundTripNanoseconds{
+    1,
+    999'999,
+    1'000'001,
+    12'345'678'901,
+    537'648'854'729'250};
+
 TEST(HighResDuration, CorrectlyConvertsToDOMHighResTimeStamp) {
   EXPECT_EQ(
       HighResDuration::fromNanoseconds(10).toDOMHighResTimeStamp(), 0.00001);
@@ -30,6 +41,48 @@ TEST(HighResDuration, CorrectlyConvertsToDOMHighResTimeStamp) {
       HighResDuration::fromMilliseconds(10).toDOMHighResTimeStamp(), 10.0);
 }
 
+TEST(HighResDuration, CorrectlyConvertsFromDOMHighResTimeStamp) {
+  EXPECT_EQ(
+      HighResDuration::fromDOMHighResTimeStamp(0.00001).toNanoseconds(), 10);
+  EXPECT_EQ(
+      HighResDuration::fromDOMHighResTimeStamp(1.000001).toNanoseconds(),
+      1000001);
+  EXPECT_EQ(
+      HighResDuration::fromDOMHighResTimeStamp(-1.000001).toNanoseconds(),
+      -1000001);
+  EXPECT_EQ(HighResDuration::fromDOMHighResTimeStamp(0).toNanoseconds(), 0);
+}
+
+TEST(HighResDuration, RoundTripsThroughDOMHighResTimeStamp) {
+  // A DOMHighResTimeStamp is a double holding milliseconds, so converting back
+  // to nanoseconds has to round: neither conversion is exact, and truncating
+  // would drop a nanosecond whenever the result lands just below the original
+  // value.
+  for (int64_t nanoseconds : kRoundTripNanoseconds) {
+    for (int64_t signedNanoseconds : {nanoseconds, -nanoseconds}) {
+      auto duration = HighResDuration::fromNanoseconds(signedNanoseconds);
+      EXPECT_EQ(
+          HighResDuration::fromDOMHighResTimeStamp(
+              duration.toDOMHighResTimeStamp()),
+          duration)
+          << "duration of " << signedNanoseconds << "ns did not round trip";
+    }
+  }
+}
+
+TEST(HighResTimeStamp, RoundTripsThroughDOMHighResTimeStamp) {
+  for (int64_t nanoseconds : kRoundTripNanoseconds) {
+    auto timestamp = HighResTimeStamp::fromChronoSteadyClockTimePoint(
+        std::chrono::steady_clock::time_point(
+            std::chrono::nanoseconds(nanoseconds)));
+    EXPECT_EQ(
+        HighResTimeStamp::fromDOMHighResTimeStamp(
+            timestamp.toDOMHighResTimeStamp()),
+        timestamp)
+        << "timestamp of " << nanoseconds << "ns did not round trip";
+  }
+}
+
 TEST(HighResDuration, ComparisonOperators) {
   auto duration1 = HighResDuration::fromNanoseconds(10);
   auto duration2 = HighResDuration::fromNanoseconds(20);

package/ReactCommon/react/utils/React-utils.podspec

@@ -54,4 +54,6 @@ Pod::Spec.new do |s|
   add_rncore_dependency(s)
 
   add_dependency(s, "React-debug")
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/react/utils/hash_combine.h

@@ -7,7 +7,9 @@
 
 #pragma once
 
+#include <cstdint>
 #include <functional>
+#include <optional>
 #include <type_traits>
 
 namespace facebook::react {
@@ -32,4 +34,38 @@ std::size_t hash_combine(const T &v, const Args &...args)
   return seed;
 }
 
+/*
+ * Combines a run of optional fields into `seed` as a single presence bitmask followed by the
+ * engaged values only.
+ *
+ * Each `hash_combine` step mixes into the previous seed, so it forms a dependency chain the CPU
+ * cannot overlap and an unset field still costs a full link. The optionals are hashed into an
+ * independent seed and merged into the preceding seed once, allowing both chains to overlap.
+ * Folding presence into one word keeps unused fields off the optional chain: a further optional
+ * costs a bit in the mask rather than a link.
+ *
+ * The mask is what keeps this collision-free. Skipping disengaged fields on its own would make the
+ * same value in two different slots hash identically.
+ *
+ * Both packs are expanded from the same parameter pack, so the mask's bit order cannot drift out
+ * of sync with the order the values are combined.
+ */
+template <Hashable... Ts>
+  requires(sizeof...(Ts) <= 32)
+void hash_combine_optionals(std::size_t &seed, const std::optional<Ts> &...optionals)
+{
+  std::uint32_t presence = 0;
+  std::uint32_t bit = 1;
+  ((presence |= optionals.has_value() ? bit : 0u, bit <<= 1), ...);
+  std::size_t optionalsSeed = presence;
+
+  auto combineIfEngaged = [&optionalsSeed](const auto &optional) {
+    if (optional.has_value()) {
+      hash_combine(optionalsSeed, *optional);
+    }
+  };
+  (combineIfEngaged(optionals), ...);
+  hash_combine(seed, optionalsSeed);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/utils/tests/hash_combineTests.cpp

@@ -8,6 +8,12 @@
 #include <gtest/gtest.h>
 #include <react/utils/hash_combine.h>
 
+#include <array>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+
 struct Person {
   std::string firstName;
   std::string lastName;
@@ -79,4 +85,122 @@ TEST(hash_combineTests, testCustomTypes) {
   EXPECT_NE(hash_combine(person1), hash_combine(person2));
 }
 
+TEST(hash_combineTests, optionalsCombinePresenceBeforeEngagedValues) {
+  std::optional<int> first{17};
+  std::optional<std::string> second;
+  std::optional<bool> third{true};
+
+  std::size_t actual = 41;
+  hash_combine_optionals(actual, first, second, third);
+
+  std::size_t optionalsHash = std::uint32_t{0b101};
+  hash_combine(optionalsHash, *first, *third);
+  std::size_t expected = 41;
+  hash_combine(expected, optionalsHash);
+  EXPECT_EQ(actual, expected);
+}
+
+TEST(hash_combineTests, disengagedOptionalsOnlyCombinePresence) {
+  std::optional<int> first;
+  std::optional<std::string> second;
+
+  std::size_t actual = 41;
+  hash_combine_optionals(actual, first, second);
+
+  std::size_t expected = 41;
+  hash_combine(expected, std::uint32_t{0});
+  EXPECT_EQ(actual, expected);
+}
+
+TEST(hash_combineTests, optionalStringContentsAffectProvidedSeed) {
+  std::optional<std::string> react{"react"};
+  std::optional<std::string> reactNative{"react native"};
+
+  std::size_t reactHash = 41;
+  hash_combine_optionals(reactHash, react);
+
+  std::size_t optionalsHash = std::uint32_t{1};
+  hash_combine(optionalsHash, *react);
+  std::size_t expected = 41;
+  hash_combine(expected, optionalsHash);
+  EXPECT_EQ(reactHash, expected);
+
+  std::size_t reactNativeHash = 41;
+  hash_combine_optionals(reactNativeHash, reactNative);
+  EXPECT_NE(reactHash, reactNativeHash);
+}
+
+TEST(hash_combineTests, emptyOptionalStringDiffersFromDisengaged) {
+  std::optional<std::string> emptyString{""};
+  std::optional<std::string> disengaged;
+
+  std::size_t emptyStringHash = 41;
+  hash_combine_optionals(emptyStringHash, emptyString);
+
+  std::size_t disengagedHash = 41;
+  hash_combine_optionals(disengagedHash, disengaged);
+
+  EXPECT_NE(emptyStringHash, disengagedHash);
+}
+
+TEST(hash_combineTests, optionalPositionAffectsHash) {
+  std::optional<int> engaged{17};
+  std::optional<int> disengaged;
+
+  std::size_t firstPosition = 0;
+  hash_combine_optionals(firstPosition, engaged, disengaged);
+
+  std::size_t secondPosition = 0;
+  hash_combine_optionals(secondPosition, disengaged, engaged);
+
+  EXPECT_NE(firstPosition, secondPosition);
+}
+
+namespace {
+
+struct Unhashable {};
+
+template <typename... Ts>
+concept CanHashCombineOptionals =
+    requires(std::size_t& seed, const std::optional<Ts>&... optionals) {
+      hash_combine_optionals(seed, optionals...);
+    };
+
+template <std::size_t... Indices>
+constexpr bool canHashOptionalCount(
+    std::index_sequence<Indices...> /*unused*/) {
+  return requires(std::size_t& seed, const std::optional<int>& optional) {
+    hash_combine_optionals(seed, ((void)Indices, optional)...);
+  };
+}
+
+static_assert(CanHashCombineOptionals<int, std::string, bool>);
+static_assert(!CanHashCombineOptionals<Unhashable>);
+static_assert(canHashOptionalCount(std::make_index_sequence<32>{}));
+static_assert(!canHashOptionalCount(std::make_index_sequence<33>{}));
+
+template <std::size_t... Indices>
+void combineArrayOptionals(
+    std::size_t& seed,
+    const std::array<std::optional<int>, 32>& optionals,
+    std::index_sequence<Indices...> /*unused*/) {
+  hash_combine_optionals(seed, optionals[Indices]...);
+}
+
+} // namespace
+
+TEST(hash_combineTests, supportsHighestPresenceBit) {
+  std::array<std::optional<int>, 32> optionals;
+  optionals.back() = 17;
+
+  std::size_t actual = 41;
+  combineArrayOptionals(actual, optionals, std::make_index_sequence<32>{});
+
+  std::size_t optionalsHash = std::uint32_t{1} << 31;
+  hash_combine(optionalsHash, 17);
+  std::size_t expected = 41;
+  hash_combine(expected, optionalsHash);
+  EXPECT_EQ(actual, expected);
+}
+
 } // namespace facebook::react

package/ReactCommon/reactperflogger/React-perflogger.podspec

@@ -39,4 +39,6 @@ Pod::Spec.new do |s|
 
   add_rn_third_party_dependencies(s)
   add_rncore_dependency(s)
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/runtimeexecutor/React-runtimeexecutor.podspec

@@ -53,4 +53,5 @@ Pod::Spec.new do |s|
   add_dependency(s, "React-utils", :additional_framework_paths => ["react/utils/platform/ios"])
 
 
+  mark_as_react_native_build(s)
 end

package/ReactCommon/yoga/Yoga.podspec

@@ -63,4 +63,6 @@ Pod::Spec.new do |spec|
   all_header_files = File.join('ReactCommon/yoga', all_header_files) if ENV['INSTALL_YOGA_WITHOUT_PATH_OPTION']
   spec.private_header_files = Dir.glob(all_header_files).sort - Dir.glob(public_header_files).sort
   spec.preserve_paths = [all_header_files]
+
+  mark_as_react_native_build(spec)
 end

package/ReactCommon/yoga/yoga/algorithm/CalculateLayout.cpp

@@ -6,9 +6,11 @@
  */
 
 #include <algorithm>
+#include <array>
 #include <atomic>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 #include <cstring>
 
 #include <yoga/Yoga.h>
@@ -35,6 +37,172 @@ namespace facebook::yoga {
 
 std::atomic<uint32_t> gCurrentGenerationCount(0);
 
+static bool hasAutoHorizontalMargin(const Style& style) {
+  for (const auto direction : {Direction::LTR, Direction::RTL}) {
+    if (style.flexStartMarginIsAuto(FlexDirection::Row, direction) ||
+        style.flexEndMarginIsAuto(FlexDirection::Row, direction)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool isColumnStretchEdge(
+    const yoga::Node* const owner,
+    const yoga::Node* const child) {
+  if (owner == nullptr || child == nullptr) {
+    return false;
+  }
+  const auto& ownerStyle = owner->style();
+  const auto& childStyle = child->style();
+  const auto childWidth = child->getProcessedDimension(Dimension::Width);
+  return ownerStyle.display() == Display::Flex &&
+      isColumn(ownerStyle.flexDirection()) &&
+      ownerStyle.flexWrap() == Wrap::NoWrap &&
+      childStyle.positionType() != PositionType::Absolute &&
+      !childStyle.aspectRatio().isDefined() &&
+      (childWidth.isAuto() || childWidth.isUndefined()) &&
+      !hasAutoHorizontalMargin(childStyle) &&
+      resolveChildAlignment(owner, child) == Align::Stretch;
+}
+
+static bool isInColumnStretchScrollSubtree(const yoga::Node* const node) {
+  auto current = node;
+  while (current != nullptr) {
+    auto owner = current->getOwner();
+    while (owner != nullptr && owner->style().display() == Display::Contents) {
+      owner = owner->getOwner();
+    }
+    if (owner == nullptr || !isColumnStretchEdge(owner, current)) {
+      return false;
+    }
+    if (owner->style().overflow() == Overflow::Scroll) {
+      return true;
+    }
+    current = owner;
+  }
+  return false;
+}
+
+static bool isNonZeroLength(const Style::Length& length) {
+  return length.isAuto() ||
+      (length.value().isDefined() && length.value().unwrap() != 0.0f);
+}
+
+static bool hasNonZeroVerticalSpacing(const Style& style) {
+  constexpr std::array<Edge, 4> verticalEdges = {
+      Edge::Top, Edge::Bottom, Edge::Vertical, Edge::All};
+  for (const auto edge : verticalEdges) {
+    if (isNonZeroLength(style.margin(edge)) ||
+        isNonZeroLength(style.padding(edge)) ||
+        isNonZeroLength(style.border(edge))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool hasPercentageLength(const Style& style) {
+  constexpr std::array<Edge, 9> edges = {
+      Edge::Left,
+      Edge::Top,
+      Edge::Right,
+      Edge::Bottom,
+      Edge::Start,
+      Edge::End,
+      Edge::Horizontal,
+      Edge::Vertical,
+      Edge::All};
+  for (const auto edge : edges) {
+    if (style.margin(edge).isPercent() || style.position(edge).isPercent() ||
+        style.padding(edge).isPercent() || style.border(edge).isPercent()) {
+      return true;
+    }
+  }
+
+  constexpr std::array<Dimension, 2> dimensions = {
+      Dimension::Width, Dimension::Height};
+  for (const auto dimension : dimensions) {
+    if (style.dimension(dimension).isPercent() ||
+        style.minDimension(dimension).isPercent() ||
+        style.maxDimension(dimension).isPercent()) {
+      return true;
+    }
+  }
+
+  return style.flexBasis().isPercent() ||
+      style.gap(Gutter::Column).isPercent() ||
+      style.gap(Gutter::Row).isPercent() || style.gap(Gutter::All).isPercent();
+}
+
+static bool hasNonZeroFlex(const yoga::Node& node) {
+  const auto& style = node.style();
+  const auto flex = style.flex();
+  const auto flexGrow = style.flexGrow();
+  const auto flexShrink = style.flexShrink();
+  const auto config = node.getConfig();
+  const bool canGrow = flexGrow.isDefined()
+      ? flexGrow.unwrap() != 0.0f
+      : flex.isDefined() && flex.unwrap() > 0.0f;
+  const bool canShrink = flexShrink.isDefined()
+      ? flexShrink.unwrap() != 0.0f
+      : (config != nullptr && config->useWebDefaults()) ||
+          (flex.isDefined() && flex.unwrap() < 0.0f);
+  return canGrow || canShrink;
+}
+
+static bool isHeightFitContentIndependent(const yoga::Node& node) {
+  const auto& style = node.style();
+  const auto height = style.dimension(Dimension::Height);
+  const auto flexBasis = style.flexBasis();
+  const bool hasRelativePercentPosition =
+      style.position(Edge::Top).isPercent() ||
+      style.position(Edge::Bottom).isPercent() ||
+      style.position(Edge::Vertical).isPercent() ||
+      style.position(Edge::All).isPercent();
+  return !node.hasMeasureFunc() && !node.hasMinContentMeasureFunc() &&
+      !node.hasBaselineFunc() && !node.isReferenceBaseline() &&
+      (height.isAuto() || height.isUndefined()) &&
+      style.minDimension(Dimension::Height).isUndefined() &&
+      style.maxDimension(Dimension::Height).isUndefined() &&
+      (flexBasis.isAuto() || flexBasis.isUndefined()) &&
+      !hasNonZeroFlex(node) && style.boxSizing() == BoxSizing::BorderBox &&
+      !style.aspectRatio().isDefined() &&
+      style.positionType() != PositionType::Absolute &&
+      style.overflow() != Overflow::Scroll &&
+      style.display() == Display::Flex && isColumn(style.flexDirection()) &&
+      style.alignItems() == Align::Stretch &&
+      (style.alignSelf() == Align::Auto ||
+       style.alignSelf() == Align::Stretch) &&
+      style.justifyContent() == Justify::FlexStart &&
+      style.flexWrap() == Wrap::NoWrap && !style.gap(Gutter::All).isDefined() &&
+      !style.gap(Gutter::Row).isDefined() && !hasRelativePercentPosition &&
+      !hasNonZeroVerticalSpacing(style) && !hasPercentageLength(style);
+}
+
+static bool canSkipHeightFitContent(const yoga::Node* const root) {
+  if (root == nullptr) {
+    return false;
+  }
+
+  constexpr std::size_t maxPendingNodes = 64;
+  std::array<const yoga::Node*, maxPendingNodes> stack{root};
+  std::size_t stackSize = 1;
+  while (stackSize > 0) {
+    const auto node = stack[--stackSize];
+    if (node == nullptr || !isHeightFitContentIndependent(*node)) {
+      return false;
+    }
+    for (const auto child : node->getLayoutChildren()) {
+      if (stackSize == stack.size()) {
+        return false;
+      }
+      stack[stackSize++] = child;
+    }
+  }
+  return true;
+}
+
 void constrainMaxSizeForMode(
     const yoga::Node* node,
     Direction direction,
@@ -98,12 +266,8 @@ static void computeFlexBasisForChild(
       node->getConfig()->isExperimentalFeatureEnabled(
           ExperimentalFeature::FixFlexBasisFitContent);
 
-  bool useResolvedFlexBasis =
+  const bool useResolvedFlexBasis =
       resolvedFlexBasis.isDefined() && yoga::isDefined(mainAxisSize);
-  if (fixFlexBasisFitContent && resolvedFlexBasis.isDefined() &&
-      resolvedFlexBasis.unwrap() > 0) {
-    useResolvedFlexBasis = true;
-  }
 
   if (useResolvedFlexBasis) {
     if (child->getLayout().computedFlexBasis.isUndefined() ||
@@ -175,32 +339,27 @@ static void computeFlexBasisForChild(
       }
     }
 
-    // For height in the main axis (column direction): when the
-    // FixFlexBasisFitContent feature is enabled, skip FitContent for
-    // non-measure container children inside scroll subtrees. This makes the
-    // flex basis independent of content-determined heights, preventing
-    // unnecessary re-measurement cascades when a sibling changes size in a
-    // ScrollView, while preserving viewport bounds for wrappers outside the
-    // scroll subtree.
-    //
-    // We only optimize the height (column) axis because text wrapping depends
-    // on width constraints propagating through container nodes. Removing
-    // FitContent from the width axis would cause text inside nested
-    // containers to stop wrapping.
-    bool applyHeightFitContent =
-        isMainAxisRow || node->style().overflow() != Overflow::Scroll;
+    // A zero-intrinsic-height column subtree has the same layout with an
+    // unbounded height, allowing its measurement cache to survive unrelated
+    // size changes elsewhere in a vertical scroll subtree.
+    const bool parentDoesNotScroll =
+        node != nullptr && node->style().overflow() != Overflow::Scroll;
+    bool applyHeightFitContent = isMainAxisRow || parentDoesNotScroll;
     if (fixFlexBasisFitContent) {
-      bool nodeHasScrollAncestor = false;
-      for (auto owner = node->getOwner(); owner != nullptr;
-           owner = owner->getOwner()) {
-        if (owner->style().overflow() == Overflow::Scroll) {
-          nodeHasScrollAncestor = true;
-          break;
-        }
+      const bool childHadOverflow = child != nullptr && child->isDirty() &&
+          child->getLayout().hadOverflow();
+      const bool hasHeightIndependentSubtree = node != nullptr &&
+          child != nullptr && !isMainAxisRow && parentDoesNotScroll &&
+          yoga::isUndefined(childHeight) && yoga::isDefined(height) &&
+          isColumnStretchEdge(node, child) &&
+          isInColumnStretchScrollSubtree(node) &&
+          canSkipHeightFitContent(child);
+      if (hasHeightIndependentSubtree && childHadOverflow) {
+        child->setLayoutHadOverflow(false);
+      }
+      if (hasHeightIndependentSubtree) {
+        applyHeightFitContent = false;
       }
-      applyHeightFitContent = isMainAxisRow ||
-          ((child->hasMeasureFunc() || !nodeHasScrollAncestor) &&
-           node->style().overflow() != Overflow::Scroll);
     }
     if (applyHeightFitContent && yoga::isUndefined(childHeight) &&
         yoga::isDefined(height)) {
@@ -945,8 +1104,15 @@ static float distributeFreeSpaceSecondPass(
       if (flexShrinkScaledFactor != 0) {
         float childSize = YGUndefined;
 
+        // Use a relative epsilon guard instead of exact equality: after the
+        // first pass removes all constrained items,
+        // totalFlexShrinkScaledFactors may be near-zero rather than exactly 0
+        // due to floating-point cancellation.  Dividing by a near-zero value
+        // produces a gigantic childSize that overwhelms the min/max clamp.
+        const float shrinkFactorMagnitude =
+            std::abs(flexLine.layout.totalFlexShrinkScaledFactors);
         if (yoga::isDefined(flexLine.layout.totalFlexShrinkScaledFactors) &&
-            flexLine.layout.totalFlexShrinkScaledFactors == 0) {
+            shrinkFactorMagnitude < 1e-6f) {
           childSize = childFlexBasis + flexShrinkScaledFactor;
         } else {
           childSize = childFlexBasis +
@@ -1565,6 +1731,12 @@ static void calculateLayoutImpl(
   // Set the resolved resolution in the node's layout.
   const Direction direction = node->resolveDirection(ownerDirection);
   node->setLayoutDirection(direction);
+  const bool fixFlexBasisFitContent =
+      node->getConfig()->isExperimentalFeatureEnabled(
+          ExperimentalFeature::FixFlexBasisFitContent);
+  if (fixFlexBasisFitContent && performLayout) {
+    node->setLayoutHadOverflow(false);
+  }
 
   const FlexDirection flexRowDirection =
       resolveDirection(FlexDirection::Row, direction);
@@ -1680,9 +1852,9 @@ static void calculateLayoutImpl(
   // At this point we know we're going to perform work. Ensure that each child
   // has a mutable copy.
   node->cloneChildrenIfNeeded();
-  // Reset layout flags, as they could have changed.
-  node->setLayoutHadOverflow(false);
-
+  if (!fixFlexBasisFitContent || !performLayout) {
+    node->setLayoutHadOverflow(false);
+  }
   // Clean and update all display: contents nodes with a direct path to the
   // current node as they will not be traversed
   cleanupContentsNodesRecursively(node, performLayout);
@@ -1741,53 +1913,14 @@ static void calculateLayoutImpl(
 
   // STEP 3: DETERMINE FLEX BASIS FOR EACH ITEM
 
-  // When this node is measured with MaxContent (FixFlexBasisFitContent
-  // behavior), availableInnerHeight is NaN.
-  // To preserve percentage resolution for descendants, derive a definite
-  // owner-size from the parent-provided ownerHeight.
-  float ownerWidthForChildren = availableInnerWidth;
-  float ownerHeightForChildren = availableInnerHeight;
-
-  if (node->getConfig()->isExperimentalFeatureEnabled(
-          ExperimentalFeature::FixFlexBasisFitContent)) {
-    const auto* owner = node->getOwner();
-    const bool isChildOfScrollContainer =
-        owner != nullptr && owner->style().overflow() == Overflow::Scroll;
-
-    if (!isChildOfScrollContainer) {
-      if (yoga::isUndefined(ownerWidthForChildren) &&
-          yoga::isDefined(ownerWidth)) {
-        ownerWidthForChildren = calculateAvailableInnerDimension(
-            node,
-            direction,
-            Dimension::Width,
-            ownerWidth - marginAxisRow,
-            paddingAndBorderAxisRow,
-            ownerWidth,
-            ownerWidth);
-      }
-      if (yoga::isUndefined(ownerHeightForChildren) &&
-          yoga::isDefined(ownerHeight)) {
-        ownerHeightForChildren = calculateAvailableInnerDimension(
-            node,
-            direction,
-            Dimension::Height,
-            ownerHeight - marginAxisColumn,
-            paddingAndBorderAxisColumn,
-            ownerHeight,
-            ownerWidth);
-      }
-    }
-  }
-
   // Computed basis + margins + gap
   float totalMainDim = 0;
   totalMainDim += computeFlexBasisForChildren(
       node,
       availableInnerWidth,
       availableInnerHeight,
-      ownerWidthForChildren,
-      ownerHeightForChildren,
+      availableInnerWidth,
+      availableInnerHeight,
       widthSizingMode,
       heightSizingMode,
       direction,
@@ -2724,7 +2857,8 @@ void calculateLayout(
   // Increment the generation count. This will force the recursive routine to
   // visit all dirty nodes at least once. Subsequent visits will be skipped if
   // the input parameters don't change.
-  gCurrentGenerationCount.fetch_add(1, std::memory_order_relaxed);
+  const uint32_t currentGenerationCount =
+      gCurrentGenerationCount.fetch_add(1, std::memory_order_relaxed) + 1;
   node->processDimensions();
   const Direction direction = node->resolveDirection(ownerDirection);
   float width = YGUndefined;
@@ -2781,6 +2915,11 @@ void calculateLayout(
     heightSizingMode = yoga::isUndefined(height) ? SizingMode::MaxContent
                                                  : SizingMode::StretchFit;
   }
+  const uint32_t generationCount =
+      node->getConfig()->isExperimentalFeatureEnabled(
+          ExperimentalFeature::FixFlexBasisFitContent)
+      ? currentGenerationCount
+      : gCurrentGenerationCount.load(std::memory_order_relaxed);
   if (calculateLayoutInternal(
           node,
           width,
@@ -2794,7 +2933,7 @@ void calculateLayout(
           LayoutPassReason::kInitial,
           markerData,
           0, // tree root
-          gCurrentGenerationCount.load(std::memory_order_relaxed))) {
+          generationCount)) {
     node->setPosition(node->getLayout().direction(), ownerWidth, ownerHeight);
     roundLayoutResultsToPixelGrid(node, 0.0f, 0.0f);
   }

package/ReactCommon/yoga/yoga/algorithm/PixelGrid.cpp

@@ -128,6 +128,9 @@ void roundLayoutResultsToPixelGrid(
   }
 
   for (yoga::Node* child : node->getChildren()) {
+    if (child->getOwner() != node) {
+      continue;
+    }
     roundLayoutResultsToPixelGrid(child, absoluteNodeLeft, absoluteNodeTop);
   }
 }