react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactCommon/reactperflogger/CMakeLists.txt

@@ -13,7 +13,12 @@ add_compile_options(
         -Wall
         -Wpedantic)
 
-file(GLOB reactperflogger_SRC CONFIGURE_DEPENDS reactperflogger/*.cpp)
-add_library(reactperflogger STATIC ${reactperflogger_SRC})
+
+file(GLOB reactperflogger_SRC CONFIGURE_DEPENDS
+        reactperflogger/*.cpp
+        fusebox/*.cpp)
+add_library(reactperflogger OBJECT ${reactperflogger_SRC})
 
 target_include_directories(reactperflogger PUBLIC .)
+
+target_link_libraries(reactperflogger folly_runtime)

package/ReactCommon/reactperflogger/React-perflogger.podspec

@@ -19,7 +19,13 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
-boost_compiler_flags = '-Wno-documentation'
+
+header_search_paths = [
+  "\"$(PODS_TARGET_SRCROOT)/..\"",
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+  "\"$(PODS_ROOT)/DoubleConversion\"",
+  "\"$(PODS_ROOT)/fmt/include\""
+]
 
 Pod::Spec.new do |s|
   s.name                   = "React-perflogger"
@@ -30,8 +36,15 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = "**/*.{cpp,h}"
+  s.source_files           = "reactperflogger/*.{cpp,h}", "fusebox/*.{cpp,h}"
   s.header_dir             = "reactperflogger"
   s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
   s.compiler_flags         = folly_compiler_flags
+  s.pod_target_xcconfig    = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
+  }
+
+  s.dependency "RCT-Folly", folly_version
+  s.dependency "DoubleConversion"
 end

package/ReactCommon/reactperflogger/fusebox/FuseboxTracer.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <folly/json.h>
+#include <fstream>
+#include <mutex>
+#include <unordered_map>
+
+#include "FuseboxTracer.h"
+
+namespace facebook::react {
+
+bool FuseboxTracer::isTracing() {
+  std::lock_guard lock(mutex_);
+  return tracing_;
+}
+
+bool FuseboxTracer::startTracing() {
+  std::lock_guard lock(mutex_);
+  if (tracing_) {
+    return false;
+  }
+  tracing_ = true;
+  return true;
+}
+
+bool FuseboxTracer::stopTracing(
+    const std::function<void(const folly::dynamic& eventsChunk)>&
+        resultCallback) {
+  std::lock_guard lock(mutex_);
+
+  if (!tracing_) {
+    return false;
+  }
+
+  tracing_ = false;
+  if (buffer_.empty()) {
+    return true;
+  }
+
+  auto traceEvents = folly::dynamic::array();
+  auto savedBuffer = std::move(buffer_);
+  buffer_.clear();
+
+  std::unordered_map<std::string, uint64_t> trackIdMap;
+  uint64_t nextTrack = 1000;
+
+  // Name the main process. Only one process is supported currently.
+  traceEvents.push_back(folly::dynamic::object(
+      "args", folly::dynamic::object("name", "Main App"))("cat", "__metadata")(
+      "name", "process_name")("ph", "M")("pid", 1000)("tid", 0)("ts", 0));
+
+  for (auto& event : savedBuffer) {
+    if (!trackIdMap.contains(event.track)) {
+      auto trackId = nextTrack++;
+      trackIdMap[event.track] = trackId;
+      // New track
+      traceEvents.push_back(folly::dynamic::object(
+          "args", folly::dynamic::object("name", event.track))(
+          "cat", "__metadata")("name", "thread_name")("ph", "M")("pid", 1000)(
+          "tid", trackId)("ts", 0));
+    }
+    auto trackId = trackIdMap[event.track];
+
+    // New event
+    traceEvents.push_back(folly::dynamic::object(
+        "args", folly::dynamic::object())("cat", "react.native")(
+        "dur", (event.end - event.start) * 1000)("name", event.name)("ph", "X")(
+        "ts", event.start * 1000)("pid", 1000)("tid", trackId));
+
+    if (traceEvents.size() >= 1000) {
+      resultCallback(traceEvents);
+      traceEvents = folly::dynamic::array();
+    }
+  }
+
+  if (traceEvents.size() >= 1) {
+    resultCallback(traceEvents);
+  }
+  return true;
+}
+
+void FuseboxTracer::addEvent(
+    const std::string_view& name,
+    uint64_t start,
+    uint64_t end,
+    const std::string_view& track) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+  buffer_.push_back(
+      BufferEvent{start, end, std::string(name), std::string(track)});
+}
+
+bool FuseboxTracer::stopTracingAndWriteToFile(const std::string& path) {
+  auto file = std::ofstream(path);
+  folly::dynamic traceEvents = folly::dynamic::array();
+  bool result = stopTracing([&traceEvents](const folly::dynamic& eventsChunk) {
+    traceEvents.insert(
+        traceEvents.end(), eventsChunk.begin(), eventsChunk.end());
+  });
+  file << folly::toJson(traceEvents) << std::endl;
+  file.close();
+  return result;
+}
+
+/* static */ FuseboxTracer& FuseboxTracer::getFuseboxTracer() {
+  static FuseboxTracer tracer;
+  return tracer;
+}
+
+} // namespace facebook::react

package/ReactCommon/reactperflogger/fusebox/FuseboxTracer.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <functional>
+#include <vector>
+#include "folly/dynamic.h"
+
+namespace facebook::react {
+
+struct BufferEvent {
+  uint64_t start;
+  uint64_t end;
+  std::string name;
+  std::string track;
+};
+
+class FuseboxTracer {
+ public:
+  FuseboxTracer(const FuseboxTracer&) = delete;
+
+  bool isTracing();
+  // Verifies that tracing isn't started and starts tracing all in one step.
+  // Returns true if we were able to successful start tracing.
+  bool startTracing();
+  // Verifies that we're tracing and dumps the trace all in one step to avoid
+  // TOCTOU bugs. Returns false if we're not tracing. No result callbacks
+  // are expected in that scenario.
+  bool stopTracing(const std::function<void(const folly::dynamic& eventsChunk)>&
+                       resultCallback);
+  bool stopTracingAndWriteToFile(const std::string& path);
+  void addEvent(
+      const std::string_view& name,
+      uint64_t start,
+      uint64_t end,
+      const std::string_view& track);
+
+  static FuseboxTracer& getFuseboxTracer();
+
+ private:
+  FuseboxTracer() {}
+
+  bool tracing_{false};
+  std::vector<BufferEvent> buffer_;
+  std::mutex mutex_;
+};
+
+} // namespace facebook::react

package/ReactCommon/reactperflogger/fusebox/tests/FuseboxTracerTest.cpp

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+
+#include <reactperflogger/fusebox/FuseboxTracer.h>
+
+using namespace ::testing;
+
+namespace facebook::react {
+
+namespace {
+
+class FuseboxTracerTest : public ::testing::Test {
+ protected:
+  FuseboxTracerTest() = default;
+
+  ~FuseboxTracerTest() override = default;
+
+  void SetUp() override {
+    stopTracingAndCollect();
+  }
+
+  void TearDown() override {
+    stopTracingAndCollect();
+  }
+
+  folly::dynamic stopTracingAndCollect() {
+    folly::dynamic trace = folly::dynamic::array;
+    FuseboxTracer::getFuseboxTracer().stopTracing(
+        [&trace](const folly::dynamic& eventsChunk) {
+          for (const auto& event : eventsChunk) {
+            trace.push_back(event);
+          }
+        });
+    return trace;
+  }
+};
+
+} // namespace
+
+TEST_F(FuseboxTracerTest, TracingOffByDefault) {
+  EXPECT_FALSE(FuseboxTracer::getFuseboxTracer().isTracing());
+}
+
+TEST_F(FuseboxTracerTest, TracingOn) {
+  FuseboxTracer::getFuseboxTracer().startTracing();
+  EXPECT_TRUE(FuseboxTracer::getFuseboxTracer().isTracing());
+  stopTracingAndCollect();
+}
+
+TEST_F(FuseboxTracerTest, DiscardEventWhenNotOn) {
+  EXPECT_FALSE(FuseboxTracer::getFuseboxTracer().isTracing());
+  EXPECT_EQ(stopTracingAndCollect().size(), 0);
+  FuseboxTracer::getFuseboxTracer().addEvent("test", 0, 0, "default track");
+  FuseboxTracer::getFuseboxTracer().addEvent("test", 0, 0, "default track");
+  EXPECT_EQ(stopTracingAndCollect().size(), 0);
+}
+
+TEST_F(FuseboxTracerTest, NoDefaultEvents) {
+  FuseboxTracer::getFuseboxTracer().startTracing();
+  EXPECT_EQ(stopTracingAndCollect().size(), 0);
+}
+
+TEST_F(FuseboxTracerTest, SimpleEvent) {
+  FuseboxTracer::getFuseboxTracer().startTracing();
+  FuseboxTracer::getFuseboxTracer().addEvent("test", 0, 0, "default track");
+  EXPECT_GE(stopTracingAndCollect().size(), 1);
+}
+
+TEST_F(FuseboxTracerTest, MultiEvents) {
+  FuseboxTracer::getFuseboxTracer().startTracing();
+  for (int i = 0; i < 10; i++) {
+    FuseboxTracer::getFuseboxTracer().addEvent("test", 0, 0, "default track");
+  }
+  EXPECT_GE(stopTracingAndCollect().size(), 10);
+  EXPECT_EQ(stopTracingAndCollect().size(), 0);
+}
+
+TEST_F(FuseboxTracerTest, ShouldEndTracingEvenIfThereIsNoEvents) {
+  FuseboxTracer::getFuseboxTracer().startTracing();
+  EXPECT_EQ(stopTracingAndCollect().size(), 0);
+  EXPECT_FALSE(FuseboxTracer::getFuseboxTracer().isTracing());
+}
+
+} // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/HermesPerfettoDataSource.cpp

@@ -15,6 +15,8 @@
 #include "HermesPerfettoDataSource.h"
 #include "ReactPerfetto.h"
 
+namespace facebook::react {
+
 namespace {
 
 const int SAMPLING_HZ = 100;
@@ -55,8 +57,18 @@ void flushSample(
     const std::vector<folly::dynamic>& stack,
     uint64_t start,
     uint64_t end) {
-  auto track = getPerfettoWebPerfTrack("JS Sampling");
-  for (const auto& frame : stack) {
+  auto track = getPerfettoWebPerfTrackSync("JS Sampling");
+  for (size_t i = 0; i < stack.size(); i++) {
+    const auto& frame = stack[i];
+    // Omit elements that are not the first 25 or the last 25
+    if (i > 25 && i < stack.size() - 25) {
+      if (i == 26) {
+        TRACE_EVENT_BEGIN(
+            "react-native", perfetto::DynamicString{"..."}, track, start);
+        TRACE_EVENT_END("react-native", track, end);
+      }
+      continue;
+    }
     std::string name = frame["name"].asString();
     TRACE_EVENT_BEGIN(
         "react-native", perfetto::DynamicString{name}, track, start);
@@ -98,7 +110,7 @@ void HermesPerfettoDataSource::OnStart(const StartArgs&) {
   TRACE_EVENT_INSTANT(
       "react-native",
       perfetto::DynamicString{"Profiling Started"},
-      getPerfettoWebPerfTrack("JS Sampling"),
+      getPerfettoWebPerfTrackSync("JS Sampling"),
       performanceNowToPerfettoTraceTime(0));
 }
 
@@ -115,6 +127,9 @@ void HermesPerfettoDataSource::OnStop(const StopArgs& a) {
   facebook::hermes::HermesRuntime::disableSamplingProfiler();
 }
 
-PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(HermesPerfettoDataSource);
+} // namespace facebook::react
+
+PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(
+    facebook::react::HermesPerfettoDataSource);
 
 #endif // WITH_PERFETTO

package/ReactCommon/reactperflogger/reactperflogger/HermesPerfettoDataSource.h

@@ -11,6 +11,8 @@
 
 #include <perfetto.h>
 
+namespace facebook::react {
+
 class HermesPerfettoDataSource
     : public perfetto::DataSource<HermesPerfettoDataSource> {
  public:
@@ -27,8 +29,14 @@ class HermesPerfettoDataSource
     dsd.set_name("com.facebook.hermes.profiler");
     HermesPerfettoDataSource::Register(dsd);
   }
+
+  constexpr static perfetto::BufferExhaustedPolicy kBufferExhaustedPolicy =
+      perfetto::BufferExhaustedPolicy::kStall;
 };
 
-PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS(HermesPerfettoDataSource);
+} // namespace facebook::react
+
+PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS(
+    facebook::react::HermesPerfettoDataSource);
 
 #endif // WITH_PERFETTO

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfetto.cpp

@@ -7,16 +7,24 @@
 
 #ifdef WITH_PERFETTO
 
+#include "ReactPerfetto.h"
+
 #include <perfetto.h>
 #include <unordered_map>
 
 #include "HermesPerfettoDataSource.h"
 #include "ReactPerfettoCategories.h"
 
+namespace facebook::react {
+
 std::once_flag perfettoInit;
 void initializePerfetto() {
   std::call_once(perfettoInit, []() {
     perfetto::TracingInitArgs args;
+    // Raise the size of the shared memory buffer. Since this
+    // is only used in tracing build, large buffers are okay
+    // for now.
+    args.shmem_size_hint_kb = 20 * 1024;
     args.backends |= perfetto::kSystemBackend;
     args.use_monotonic_clock = true;
     perfetto::Tracing::Initialize(args);
@@ -26,16 +34,24 @@ void initializePerfetto() {
   HermesPerfettoDataSource::RegisterDataSource();
 }
 
-perfetto::Track getPerfettoWebPerfTrack(const std::string& trackName) {
-  static std::unordered_map<std::string, perfetto::Track> tracks;
+static perfetto::Track createTrack(const std::string& trackName) {
   // Offset for custom perfetto tracks
   static uint64_t trackId = 0x5F3759DF;
+  auto track = perfetto::Track(trackId++);
+  auto desc = track.Serialize();
+  desc.set_name(trackName);
+  perfetto::TrackEvent::SetTrackDescriptor(track, desc);
+  return track;
+}
+
+perfetto::Track getPerfettoWebPerfTrackSync(const std::string& trackName) {
+  // In the case of marks we can reuse the same track saving some resources,
+  // because there's no risk of partial overlap that would break the timings.
+  static std::unordered_map<std::string, perfetto::Track> tracks;
+
   auto it = tracks.find(trackName);
   if (it == tracks.end()) {
-    auto track = perfetto::Track(trackId++);
-    auto desc = track.Serialize();
-    desc.set_name(trackName);
-    perfetto::TrackEvent::SetTrackDescriptor(track, desc);
+    auto track = createTrack(trackName);
     tracks.emplace(trackName, track);
     return track;
   } else {
@@ -43,6 +59,24 @@ perfetto::Track getPerfettoWebPerfTrack(const std::string& trackName) {
   }
 }
 
+perfetto::Track getPerfettoWebPerfTrackAsync(const std::string& trackName) {
+  // Note that, in the case of measures, we don't cache and reuse a track for a
+  // given name because Perfetto does not support partially overlapping measures
+  // in the same track.
+  //
+  // E.g.:
+  //   [.....]
+  //     [......]
+  // In that case, Perfetto would just cut subsequent measures as:
+  //  [.....]
+  //     [..]    <-- Part of this section is gone, so the timing is incorrect.
+  //
+  // There's a solution though. Perfetto does group different tracks with the
+  // same name together, so having a separate track for each async event allows
+  // overlap.
+  return createTrack(trackName);
+}
+
 // Perfetto's monotonic clock seems to match the std::chrono::steady_clock we
 // use in JSExecutor::performanceNow on Android platforms, but if that
 // assumption is incorrect we may need to manually offset perfetto timestamps.
@@ -53,4 +87,6 @@ uint64_t performanceNowToPerfettoTraceTime(double perfNowTime) {
   return static_cast<uint64_t>(perfNowTime * 1.e6);
 }
 
+} // namespace facebook::react
+
 #endif // WITH_PERFETTO

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfetto.h

@@ -13,10 +13,15 @@
 #include <reactperflogger/ReactPerfettoCategories.h>
 #include <string>
 
+namespace facebook::react {
+
 void initializePerfetto();
 
-perfetto::Track getPerfettoWebPerfTrack(const std::string& trackName);
+perfetto::Track getPerfettoWebPerfTrackSync(const std::string& trackName);
+perfetto::Track getPerfettoWebPerfTrackAsync(const std::string& trackName);
 
 uint64_t performanceNowToPerfettoTraceTime(double perfNowTime);
 
+} // namespace facebook::react
+
 #endif // WITH_PERFETTO

package/ReactCommon/runtimeexecutor/CMakeLists.txt

@@ -15,7 +15,7 @@ add_compile_options(
 
 file(GLOB_RECURSE runtimeexecutor_SRC CONFIGURE_DEPENDS *.cpp *.h)
 
-add_library(runtimeexecutor SHARED ${runtimeexecutor_SRC})
+add_library(runtimeexecutor OBJECT ${runtimeexecutor_SRC})
 
 target_include_directories(runtimeexecutor PUBLIC .)
 

package/ReactCommon/yoga/yoga/YGNodeStyle.cpp

@@ -205,6 +205,11 @@ void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
       node, scopedEnum(edge), value::percent(percent));
 }
 
+void YGNodeStyleSetPositionAuto(YGNodeRef node, YGEdge edge) {
+  updateStyle<&Style::position, &Style::setPosition>(
+      node, scopedEnum(edge), value::ofAuto());
+}
+
 YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
   return (YGValue)resolveRef(node)->style().position(scopedEnum(edge));
 }

package/ReactCommon/yoga/yoga/YGNodeStyle.h

@@ -71,8 +71,10 @@ YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float position);
 YG_EXPORT void
 YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float position);
 YG_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge);
+YG_EXPORT void YGNodeStyleSetPositionAuto(YGNodeRef node, YGEdge edge);
 
-YG_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
+YG_EXPORT
+void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
 YG_EXPORT void
 YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float margin);
 YG_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge);

package/ReactCommon/yoga/yoga/algorithm/AbsoluteLayout.cpp

@@ -154,7 +154,8 @@ static void positionAbsoluteChildLegacy(
          (parent->style().flexWrap() == Wrap::WrapReverse));
 
   if (child->style().isFlexEndPositionDefined(axis, direction) &&
-      !child->style().isFlexStartPositionDefined(axis, direction)) {
+      (!child->style().isFlexStartPositionDefined(axis, direction) ||
+       child->style().isFlexStartPositionAuto(axis, direction))) {
     child->setLayoutPosition(
         containingNode->getLayout().measuredDimension(dimension(axis)) -
             child->getLayout().measuredDimension(dimension(axis)) -
@@ -169,7 +170,8 @@ static void positionAbsoluteChildLegacy(
                 isAxisRow ? containingBlockWidth : containingBlockHeight),
         flexStartEdge(axis));
   } else if (
-      !child->style().isFlexStartPositionDefined(axis, direction) &&
+      (!child->style().isFlexStartPositionDefined(axis, direction) ||
+       child->style().isFlexStartPositionAuto(axis, direction)) &&
       shouldCenter) {
     child->setLayoutPosition(
         (parent->getLayout().measuredDimension(dimension(axis)) -
@@ -177,7 +179,8 @@ static void positionAbsoluteChildLegacy(
             2.0f,
         flexStartEdge(axis));
   } else if (
-      !child->style().isFlexStartPositionDefined(axis, direction) &&
+      (!child->style().isFlexStartPositionDefined(axis, direction) ||
+       child->style().isFlexStartPositionAuto(axis, direction)) &&
       shouldFlexEnd) {
     child->setLayoutPosition(
         (parent->getLayout().measuredDimension(dimension(axis)) -
@@ -223,7 +226,8 @@ static void positionAbsoluteChildImpl(
   // to the flex-start edge because this algorithm works by positioning on the
   // flex-start edge and then filling in the flex-end direction at the end if
   // necessary.
-  if (child->style().isInlineStartPositionDefined(axis, direction)) {
+  if (child->style().isInlineStartPositionDefined(axis, direction) &&
+      !child->style().isInlineStartPositionAuto(axis, direction)) {
     const float positionRelativeToInlineStart =
         child->style().computeInlineStartPosition(
             axis, direction, containingBlockSize) +
@@ -237,7 +241,9 @@ static void positionAbsoluteChildImpl(
         : positionRelativeToInlineStart;
 
     child->setLayoutPosition(positionRelativeToFlexStart, flexStartEdge(axis));
-  } else if (child->style().isInlineEndPositionDefined(axis, direction)) {
+  } else if (
+      child->style().isInlineEndPositionDefined(axis, direction) &&
+      !child->style().isInlineEndPositionAuto(axis, direction)) {
     const float positionRelativeToInlineStart =
         containingNode->getLayout().measuredDimension(dimension(axis)) -
         child->getLayout().measuredDimension(dimension(axis)) -
@@ -328,7 +334,10 @@ void layoutAbsoluteChild(
     if (child->style().isFlexStartPositionDefined(
             FlexDirection::Row, direction) &&
         child->style().isFlexEndPositionDefined(
-            FlexDirection::Row, direction)) {
+            FlexDirection::Row, direction) &&
+        !child->style().isFlexStartPositionAuto(
+            FlexDirection::Row, direction) &&
+        !child->style().isFlexEndPositionAuto(FlexDirection::Row, direction)) {
       childWidth =
           containingNode->getLayout().measuredDimension(Dimension::Width) -
           (containingNode->style().computeFlexStartBorder(
@@ -360,6 +369,10 @@ void layoutAbsoluteChild(
     if (child->style().isFlexStartPositionDefined(
             FlexDirection::Column, direction) &&
         child->style().isFlexEndPositionDefined(
+            FlexDirection::Column, direction) &&
+        !child->style().isFlexStartPositionAuto(
+            FlexDirection::Column, direction) &&
+        !child->style().isFlexEndPositionAuto(
             FlexDirection::Column, direction)) {
       childHeight =
           containingNode->getLayout().measuredDimension(Dimension::Height) -
@@ -474,7 +487,7 @@ void layoutAbsoluteChild(
       containingBlockHeight);
 }
 
-void layoutAbsoluteDescendants(
+bool layoutAbsoluteDescendants(
     yoga::Node* containingNode,
     yoga::Node* currentNode,
     SizingMode widthSizingMode,
@@ -486,6 +499,7 @@ void layoutAbsoluteDescendants(
     float currentNodeTopOffsetFromContainingBlock,
     float containingNodeAvailableInnerWidth,
     float containingNodeAvailableInnerHeight) {
+  bool hasNewLayout = false;
   for (auto child : currentNode->getChildren()) {
     if (child->style().display() == Display::None) {
       continue;
@@ -514,6 +528,8 @@ void layoutAbsoluteDescendants(
           currentDepth,
           generationCount);
 
+      hasNewLayout = hasNewLayout || child->getHasNewLayout();
+
       /*
        * At this point the child has its position set but only on its the
        * parent's flexStart edge. Additionally, this position should be
@@ -571,6 +587,13 @@ void layoutAbsoluteDescendants(
     } else if (
         child->style().positionType() == PositionType::Static &&
         !child->alwaysFormsContainingBlock()) {
+      // We may write new layout results for absolute descendants of "child"
+      // which are positioned relative to the current containing block instead
+      // of their parent. "child" may not be dirty, or have new constraints, so
+      // absolute positioning may be the first time during this layout pass that
+      // we need to mutate these descendents. Make sure the path of
+      // nodes to them is mutable before positioning.
+      child->cloneChildrenIfNeeded();
       const Direction childDirection =
           child->resolveDirection(currentNodeDirection);
       // By now all descendants of the containing block that are not absolute
@@ -582,19 +605,25 @@ void layoutAbsoluteDescendants(
           currentNodeTopOffsetFromContainingBlock +
           child->getLayout().position(PhysicalEdge::Top);
 
-      layoutAbsoluteDescendants(
-          containingNode,
-          child,
-          widthSizingMode,
-          childDirection,
-          layoutMarkerData,
-          currentDepth + 1,
-          generationCount,
-          childLeftOffsetFromContainingBlock,
-          childTopOffsetFromContainingBlock,
-          containingNodeAvailableInnerWidth,
-          containingNodeAvailableInnerHeight);
+      hasNewLayout = layoutAbsoluteDescendants(
+                         containingNode,
+                         child,
+                         widthSizingMode,
+                         childDirection,
+                         layoutMarkerData,
+                         currentDepth + 1,
+                         generationCount,
+                         childLeftOffsetFromContainingBlock,
+                         childTopOffsetFromContainingBlock,
+                         containingNodeAvailableInnerWidth,
+                         containingNodeAvailableInnerHeight) ||
+          hasNewLayout;
+
+      if (hasNewLayout) {
+        child->setHasNewLayout(hasNewLayout);
+      }
     }
   }
+  return hasNewLayout;
 }
 } // namespace facebook::yoga

package/ReactCommon/yoga/yoga/algorithm/AbsoluteLayout.h

@@ -24,7 +24,8 @@ void layoutAbsoluteChild(
     uint32_t depth,
     uint32_t generationCount);
 
-void layoutAbsoluteDescendants(
+// Returns if some absolute descendant has new layout
+bool layoutAbsoluteDescendants(
     yoga::Node* containingNode,
     yoga::Node* currentNode,
     SizingMode widthSizingMode,