react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "MapBuffer.h"
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
 
 namespace facebook::react {
 
@@ -51,17 +52,27 @@ int32_t MapBuffer::getKeyBucket(Key key) const {
   return -1;
 }
 
+inline int32_t MapBuffer::getIntAtBucket(int32_t bucketIndex) const {
+  return *reinterpret_cast<const int32_t*>(
+      bytes_.data() + valueOffset(bucketIndex));
+}
+
 int32_t MapBuffer::getInt(Key key) const {
   auto bucketIndex = getKeyBucket(key);
   react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return 0;
+  }
 
-  return *reinterpret_cast<const int32_t*>(
-      bytes_.data() + valueOffset(bucketIndex));
+  return getIntAtBucket(bucketIndex);
 }
 
 int64_t MapBuffer::getLong(Key key) const {
   auto bucketIndex = getKeyBucket(key);
   react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return 0;
+  }
 
   return *reinterpret_cast<const int64_t*>(
       bytes_.data() + valueOffset(bucketIndex));
@@ -74,6 +85,9 @@ bool MapBuffer::getBool(Key key) const {
 double MapBuffer::getDouble(Key key) const {
   auto bucketIndex = getKeyBucket(key);
   react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return 0;
+  }
 
   return *reinterpret_cast<const double*>(
       bytes_.data() + valueOffset(bucketIndex));
@@ -86,56 +100,63 @@ int32_t MapBuffer::getDynamicDataOffset() const {
 }
 
 std::string MapBuffer::getString(Key key) const {
-  // TODO T83483191:Add checks to verify that offsets are under the boundaries
-  // of the map buffer
-  int32_t dynamicDataOffset = getDynamicDataOffset();
-  int32_t offset = getInt(key);
-  int32_t stringLength = *reinterpret_cast<const int32_t*>(
-      bytes_.data() + dynamicDataOffset + offset);
-  const uint8_t* stringPtr =
-      bytes_.data() + dynamicDataOffset + offset + sizeof(int);
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return "";
+  }
+
+  int32_t offset = getDynamicDataOffset() + getIntAtBucket(bucketIndex);
+  int32_t stringLength =
+      *reinterpret_cast<const int32_t*>(bytes_.data() + offset);
+  const uint8_t* stringPtr = bytes_.data() + offset + sizeof(int);
 
   return {stringPtr, stringPtr + stringLength};
 }
 
 MapBuffer MapBuffer::getMapBuffer(Key key) const {
-  // TODO T83483191: Add checks to verify that offsets are under the boundaries
-  // of the map buffer
-  int32_t dynamicDataOffset = getDynamicDataOffset();
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return MapBufferBuilder::EMPTY();
+  }
 
-  int32_t offset = getInt(key);
-  int32_t mapBufferLength = *reinterpret_cast<const int32_t*>(
-      bytes_.data() + dynamicDataOffset + offset);
+  int32_t offset = getDynamicDataOffset() + getIntAtBucket(bucketIndex);
+  int32_t mapBufferLength =
+      *reinterpret_cast<const int32_t*>(bytes_.data() + offset);
+  size_t maxLength = bytes_.size() - offset - sizeof(int32_t);
+  if (mapBufferLength > maxLength) {
+    mapBufferLength = maxLength;
+  }
 
   std::vector<uint8_t> value(mapBufferLength);
 
   memcpy(
-      value.data(),
-      bytes_.data() + dynamicDataOffset + offset + sizeof(int32_t),
-      mapBufferLength);
+      value.data(), bytes_.data() + offset + sizeof(int32_t), mapBufferLength);
 
   return MapBuffer(std::move(value));
 }
 
 std::vector<MapBuffer> MapBuffer::getMapBufferList(MapBuffer::Key key) const {
-  std::vector<MapBuffer> mapBufferList;
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return {};
+  }
 
-  int32_t dynamicDataOffset = getDynamicDataOffset();
-  int32_t offset = getInt(key);
-  int32_t mapBufferListLength = *reinterpret_cast<const int32_t*>(
-      bytes_.data() + dynamicDataOffset + offset);
+  std::vector<MapBuffer> mapBufferList;
+  int32_t offset = getDynamicDataOffset() + getIntAtBucket(bucketIndex);
+  int32_t mapBufferListLength =
+      *reinterpret_cast<const int32_t*>(bytes_.data() + offset);
   offset = offset + sizeof(uint32_t);
 
   int32_t curLen = 0;
   while (curLen < mapBufferListLength) {
-    int32_t mapBufferLength = *reinterpret_cast<const int32_t*>(
-        bytes_.data() + dynamicDataOffset + offset + curLen);
+    int32_t mapBufferLength =
+        *reinterpret_cast<const int32_t*>(bytes_.data() + offset + curLen);
     curLen = curLen + sizeof(uint32_t);
     std::vector<uint8_t> value(mapBufferLength);
-    memcpy(
-        value.data(),
-        bytes_.data() + dynamicDataOffset + offset + curLen,
-        mapBufferLength);
+    memcpy(value.data(), bytes_.data() + offset + curLen, mapBufferLength);
     mapBufferList.emplace_back(std::move(value));
     curLen = curLen + mapBufferLength;
   }

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.h

@@ -149,6 +149,8 @@ class MapBuffer {
 
   int32_t getKeyBucket(MapBuffer::Key key) const;
 
+  inline int32_t getIntAtBucket(int32_t bucketIndex) const;
+
   friend JReadableMapBuffer;
 };
 

package/ReactCommon/react/renderer/mounting/Differentiator.cpp

@@ -9,11 +9,10 @@
 
 #include <cxxreact/TraceSection.h>
 #include <react/debug/react_native_assert.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <algorithm>
 #include "internal/CullingContext.h"
+#include "internal/DiffMap.h"
 #include "internal/ShadowViewNodePair.h"
-#include "internal/TinyMap.h"
 #include "internal/sliceChildShadowNodeViewPairs.h"
 
 #include "ShadowView.h"
@@ -58,7 +57,7 @@ static std::ostream& operator<<(
 
 #ifdef DEBUG_LOGS_DIFFER
 template <typename KeyT, typename ValueT>
-static std::ostream& operator<<(std::ostream& out, TinyMap<KeyT, ValueT>& map) {
+static std::ostream& operator<<(std::ostream& out, DiffMap<KeyT, ValueT>& map) {
   auto it = map.begin();
   if (it != map.end()) {
     out << *it->second;
@@ -143,7 +142,7 @@ struct OrderedMutationInstructionContainer {
 static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
-    TinyMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
+    DiffMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
     std::vector<ShadowViewNodePair*>& oldChildPairs,
     Tag parentTag,
     const ShadowViewNodePair& oldPair,
@@ -164,11 +163,11 @@ static void calculateShadowViewMutationsFlattener(
     ReparentMode reparentMode,
     OrderedMutationInstructionContainer& mutationContainer,
     Tag parentTag,
-    TinyMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
+    DiffMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
     const ShadowViewNodePair& node,
     Tag parentTagForUpdate,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
+    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
+    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
     const CullingContext& cullingContextForUnvisitedOtherNodes,
     const CullingContext& cullingContext);
 
@@ -183,7 +182,7 @@ static void calculateShadowViewMutationsFlattener(
 static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
-    TinyMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
+    DiffMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
     std::vector<ShadowViewNodePair*>& oldChildPairs,
     Tag parentTag,
     const ShadowViewNodePair& oldPair,
@@ -232,7 +231,6 @@ static void updateMatchedPairSubtrees(
     // Unflattening
     else {
       // Construct unvisited nodes map
-      auto unvisitedOldChildPairs = TinyMap<Tag, ShadowViewNodePair*>{};
       // We don't know where all the children of oldChildPair are
       // within oldChildPairs, but we know that they're in the same
       // relative order. The reason for this is because of flattening
@@ -240,6 +238,8 @@ static void updateMatchedPairSubtrees(
       // interwoven with children from other nodes, etc.
       auto oldFlattenedNodes = sliceChildShadowNodeViewPairsFromViewNodePair(
           oldPair, scope, true, oldCullingContextCopy);
+      auto unvisitedOldChildPairs =
+          DiffMap<Tag, ShadowViewNodePair*>(oldFlattenedNodes.size());
       for (size_t i = 0, j = 0;
            i < oldChildPairs.size() && j < oldFlattenedNodes.size();
            i++) {
@@ -422,11 +422,11 @@ static void calculateShadowViewMutationsFlattener(
     ReparentMode reparentMode,
     OrderedMutationInstructionContainer& mutationContainer,
     Tag parentTag,
-    TinyMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
+    DiffMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
     const ShadowViewNodePair& node,
     Tag parentTagForUpdate,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
+    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
+    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
     const CullingContext& cullingContextForUnvisitedOtherNodes,
     const CullingContext& cullingContext) {
   // Step 1: iterate through entire tree
@@ -445,8 +445,8 @@ static void calculateShadowViewMutationsFlattener(
 
   // Views in other tree that are visited by sub-flattening or
   // sub-unflattening
-  TinyMap<Tag, ShadowViewNodePair*> subVisitedOtherNewNodes{};
-  TinyMap<Tag, ShadowViewNodePair*> subVisitedOtherOldNodes{};
+  DiffMap<Tag, ShadowViewNodePair*> subVisitedOtherNewNodes{};
+  DiffMap<Tag, ShadowViewNodePair*> subVisitedOtherOldNodes{};
   auto subVisitedNewMap =
       (parentSubVisitedOtherNewNodes != nullptr ? parentSubVisitedOtherNewNodes
                                                 : &subVisitedOtherNewNodes);
@@ -456,7 +456,7 @@ static void calculateShadowViewMutationsFlattener(
 
   // Candidates for full tree creation or deletion at the end of this function
   auto deletionCreationCandidatePairs =
-      TinyMap<Tag, const ShadowViewNodePair*>{};
+      DiffMap<Tag, const ShadowViewNodePair*>(treeChildren.size());
 
   for (size_t index = 0;
        index < treeChildren.size() && index < treeChildren.size();
@@ -471,7 +471,7 @@ static void calculateShadowViewMutationsFlattener(
              : subVisitedNewMap->end());
     auto subVisitedOtherOldIt =
         (unvisitedIt == unvisitedOtherNodes.end() &&
-                 (subVisitedNewMap->end() != nullptr)
+                 subVisitedOtherNewIt == subVisitedNewMap->end()
              ? subVisitedOldMap->find(treeChildPair.shadowView.tag)
              : subVisitedOldMap->end());
 
@@ -697,7 +697,7 @@ static void calculateShadowViewMutationsFlattener(
                   : adjustedOldCullingContext);
           // Construct unvisited nodes map
           auto unvisitedRecursiveChildPairs =
-              TinyMap<Tag, ShadowViewNodePair*>{};
+              DiffMap<Tag, ShadowViewNodePair*>(flattenedNodes.size());
           for (auto& flattenedNode : flattenedNodes) {
             auto& newChild = *flattenedNode;
 
@@ -756,9 +756,6 @@ static void calculateShadowViewMutationsFlattener(
             // loop of this function.
             for (auto& unvisitedRecursiveChildPair :
                  unvisitedRecursiveChildPairs) {
-              if (unvisitedRecursiveChildPair.first == 0) {
-                continue;
-              }
               auto& oldFlattenedNode = *unvisitedRecursiveChildPair.second;
 
               // Node unvisited - mark the entire subtree for deletion
@@ -820,9 +817,6 @@ static void calculateShadowViewMutationsFlattener(
   // subtrees if they were never visited during the execution of the above
   // loop and recursions.
   for (auto& deletionCreationCandidatePair : deletionCreationCandidatePairs) {
-    if (deletionCreationCandidatePair.first == 0) {
-      continue;
-    }
     auto& treeChildPair = *deletionCreationCandidatePair.second;
 
     // If node was visited during a flattening/unflattening recursion,
@@ -1042,9 +1036,10 @@ static void calculateShadowViewMutations(
     }
   } else {
     // Collect map of tags in the new list
-    auto newRemainingPairs = TinyMap<Tag, ShadowViewNodePair*>{};
-    auto newInsertedPairs = TinyMap<Tag, ShadowViewNodePair*>{};
-    auto deletionCandidatePairs = TinyMap<Tag, const ShadowViewNodePair*>{};
+    auto remainingCount = newChildPairs.size() - index;
+    auto newRemainingPairs = DiffMap<Tag, ShadowViewNodePair*>(remainingCount);
+    auto newInsertedPairs = DiffMap<Tag, ShadowViewNodePair*>(remainingCount);
+    auto deletionCandidatePairs = DiffMap<Tag, const ShadowViewNodePair*>{};
     for (; index < newChildPairs.size(); index++) {
       auto& newChildPair = *newChildPairs[index];
       newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
@@ -1243,10 +1238,6 @@ static void calculateShadowViewMutations(
     // list to make sure that a node was not reparented into an unflattened
     // node that occurs *after* it in the hierarchy, due to zIndex ordering.
     for (auto& deletionCandidatePair : deletionCandidatePairs) {
-      if (deletionCandidatePair.first == 0) {
-        continue;
-      }
-
       const auto& oldChildPair = *deletionCandidatePair.second;
 
       DEBUG_LOGS({
@@ -1285,14 +1276,6 @@ static void calculateShadowViewMutations(
     // Final step: generate Create instructions for entirely new
     // subtrees/nodes that are not the result of flattening or unflattening.
     for (auto& newInsertedPair : newInsertedPairs) {
-      // Erased elements of a TinyMap will have a Tag/key of 0 - skip those
-      // These *should* be removed by the map; there are currently no KNOWN
-      // cases where TinyMap will do the wrong thing, but there are not yet
-      // any unit tests explicitly for TinyMap, so this is safer for now.
-      if (newInsertedPair.first == 0) {
-        continue;
-      }
-
       const auto& newChildPair = *newInsertedPair.second;
 
       DEBUG_LOGS({

package/ReactCommon/react/renderer/mounting/ShadowTree.cpp

@@ -170,6 +170,37 @@ static std::shared_ptr<ShadowNode> progressState(
   });
 }
 
+/*
+ * Updates the layout context and layout metrics on the RootNode for commits
+ * coming from React. The RootNode is managed outside of it, and may have been
+ * modified concurrently with the React revision.
+ */
+static std::shared_ptr<RootShadowNode> progressRootLayoutInfo(
+    const std::shared_ptr<RootShadowNode>& shadowNode,
+    const RootShadowNode& baseShadowNode,
+    const ShadowTreeCommitOptions& commitOptions) {
+  if (commitOptions.source == ShadowTreeCommitSource::React ||
+      commitOptions.source == ShadowTreeCommitSource::ReactRevisionMerge) {
+    const auto& mainBranchRootProps = baseShadowNode.getConcreteProps();
+    const auto& jsBranchRootProps = shadowNode->getConcreteProps();
+
+    if (mainBranchRootProps.layoutConstraints ==
+            jsBranchRootProps.layoutConstraints &&
+        mainBranchRootProps.layoutContext == jsBranchRootProps.layoutContext) {
+      // The layout information kept in the JS branch is up to date.
+      return shadowNode;
+    }
+
+    const auto clonedNode = baseShadowNode.ShadowNode::clone(
+        {.children = std::make_shared<
+             const std::vector<std::shared_ptr<const ShadowNode>>>(
+             shadowNode->getChildren())});
+    return std::static_pointer_cast<RootShadowNode>(clonedNode);
+  }
+
+  return shadowNode;
+}
+
 ShadowTree::ShadowTree(
     SurfaceId surfaceId,
     const LayoutConstraints& layoutConstraints,
@@ -220,7 +251,7 @@ void ShadowTree::setCommitMode(CommitMode commitMode) const {
   auto revision = ShadowTreeRevision{};
 
   {
-    ShadowTree::UniqueLock lock = uniqueCommitLock();
+    ShadowTree::UniqueLock lock = uniqueRevisionLock();
 
     if (commitMode_ == commitMode) {
       return;
@@ -238,7 +269,7 @@ void ShadowTree::setCommitMode(CommitMode commitMode) const {
 }
 
 CommitMode ShadowTree::getCommitMode() const {
-  SharedLock lock = sharedCommitLock();
+  SharedLock lock = sharedRevisionLock();
   return commitMode_;
 }
 
@@ -262,7 +293,7 @@ CommitStatus ShadowTree::commit(
     }
 
     {
-      std::unique_lock lock(commitMutexRecursive_);
+      std::unique_lock lock(revisionMutexRecursive_);
       return tryCommit(transaction, commitOptions);
     }
   } else {
@@ -286,18 +317,32 @@ CommitStatus ShadowTree::tryCommit(
     const CommitOptions& commitOptions) const {
   TraceSection s("ShadowTree::commit");
 
+  auto isReactBranch = ReactNativeFeatureFlags::enableFabricCommitBranching() &&
+      commitOptions.source == CommitSource::React;
+
+  // Commits on the JS branch are never synchronous.
+  react_native_assert(!isReactBranch || !commitOptions.mountSynchronously);
+
   auto telemetry = TransactionTelemetry{};
   telemetry.willCommit();
 
   CommitMode commitMode;
   auto oldRevision = ShadowTreeRevision{};
+  auto oldRevisionForStateProgression = ShadowTreeRevision{};
   auto newRevision = ShadowTreeRevision{};
 
   {
     // Reading `currentRevision_` in shared manner.
-    SharedLock lock = sharedCommitLock();
+    SharedLock lock = sharedRevisionLock();
     commitMode = commitMode_;
-    oldRevision = currentRevision_;
+
+    if (isReactBranch && currentReactRevision_.has_value()) {
+      oldRevision = currentReactRevision_.value();
+    } else {
+      oldRevision = currentRevision_;
+    }
+
+    oldRevisionForStateProgression = currentRevision_;
   }
 
   const auto& oldRootShadowNode = oldRevision.rootShadowNode;
@@ -308,14 +353,21 @@ CommitStatus ShadowTree::tryCommit(
   }
 
   if (commitOptions.enableStateReconciliation) {
-    auto updatedNewRootShadowNode =
-        progressState(*newRootShadowNode, *oldRootShadowNode);
+    auto updatedNewRootShadowNode = progressState(
+        *newRootShadowNode, *oldRevisionForStateProgression.rootShadowNode);
     if (updatedNewRootShadowNode) {
       newRootShadowNode =
           std::static_pointer_cast<RootShadowNode>(updatedNewRootShadowNode);
     }
   }
 
+  if (ReactNativeFeatureFlags::enableFabricCommitBranching()) {
+    newRootShadowNode = progressRootLayoutInfo(
+        newRootShadowNode,
+        *oldRevisionForStateProgression.rootShadowNode,
+        commitOptions);
+  }
+
   // Run commit hooks.
   newRootShadowNode = delegate_.shadowTreeWillCommit(
       *this, oldRootShadowNode, newRootShadowNode, commitOptions);
@@ -336,9 +388,10 @@ CommitStatus ShadowTree::tryCommit(
 
   {
     // Updating `currentRevision_` in unique manner if it hasn't changed.
-    UniqueLock lock = uniqueCommitLock();
+    UniqueLock lock = uniqueRevisionLock(
+        /*defer*/ isReactBranch);
 
-    if (currentRevision_.number != oldRevision.number) {
+    if (!isReactBranch && currentRevision_.number != oldRevision.number) {
       return CommitStatus::Failed;
     }
 
@@ -364,12 +417,21 @@ CommitStatus ShadowTree::tryCommit(
         .number = newRevisionNumber,
         .telemetry = telemetry};
 
-    currentRevision_ = newRevision;
+    if (isReactBranch) {
+      // Lock the deferred lock to ensure that the new React revision is not
+      // reset during a scheduled merge.
+      std::visit([](auto& concreteLock) { concreteLock.lock(); }, lock);
+      currentReactRevision_ = newRevision;
+    } else {
+      currentRevision_ = newRevision;
+    }
   }
 
   emitLayoutEvents(affectedLayoutableNodes);
 
-  if (commitMode == CommitMode::Normal) {
+  if (isReactBranch) {
+    scheduleReactRevisionPromotion();
+  } else if (commitMode == CommitMode::Normal) {
     mount(std::move(newRevision), commitOptions.mountSynchronously);
   }
 
@@ -377,10 +439,15 @@ CommitStatus ShadowTree::tryCommit(
 }
 
 ShadowTreeRevision ShadowTree::getCurrentRevision() const {
-  SharedLock lock = sharedCommitLock();
+  SharedLock lock = sharedRevisionLock();
   return currentRevision_;
 }
 
+std::optional<ShadowTreeRevision> ShadowTree::getCurrentReactRevision() const {
+  SharedLock lock = sharedRevisionLock();
+  return currentReactRevision_;
+}
+
 void ShadowTree::mount(ShadowTreeRevision revision, bool mountSynchronously)
     const {
   mountingCoordinator_->push(std::move(revision));
@@ -388,6 +455,72 @@ void ShadowTree::mount(ShadowTreeRevision revision, bool mountSynchronously)
       mountingCoordinator_, mountSynchronously);
 }
 
+void ShadowTree::mergeReactRevision() const {
+  ShadowTreeRevision promotedRevision;
+
+  {
+    UniqueLock lock = uniqueRevisionLock(false);
+
+    if (!reactRevisionToBePromoted_.has_value()) {
+      return;
+    }
+
+    promotedRevision =
+        std::exchange(reactRevisionToBePromoted_, std::nullopt).value();
+  }
+
+  const auto mergedRevisionNumber = promotedRevision.number;
+
+  this->commit(
+      [revision = std::move(promotedRevision)](
+          const RootShadowNode& /*oldRootShadowNode*/) {
+        return std::make_shared<RootShadowNode>(
+            *revision.rootShadowNode, ShadowNodeFragment{});
+      },
+      {
+          .enableStateReconciliation = true,
+          .mountSynchronously = true,
+          .source = CommitSource::ReactRevisionMerge,
+      });
+
+  {
+    UniqueLock commitLock = uniqueRevisionLock(
+        /*defer*/ false);
+
+    // If the current react revision is the same as the one that was just
+    // merged, clear it.
+    if (currentReactRevision_.has_value() &&
+        mergedRevisionNumber == currentReactRevision_.value().number) {
+      currentReactRevision_.reset();
+    }
+  }
+}
+
+void ShadowTree::promoteReactRevision() const {
+  ShadowTreeRevision currentReactRevision;
+  {
+    SharedLock lock = sharedRevisionLock();
+    // Promotion happens at the end of the event loop tick, it's possible to
+    // have more than one promotion in a row. In this case, all but the first
+    // one should no-op.
+    if (!currentReactRevision_.has_value()) {
+      return;
+    }
+    currentReactRevision = currentReactRevision_.value();
+  }
+
+  {
+    UniqueLock lock = uniqueRevisionLock(false);
+    reactRevisionToBePromoted_ = std::move(currentReactRevision);
+  }
+
+  delegate_.shadowTreeDidPromoteReactRevision(*this);
+}
+
+void ShadowTree::scheduleReactRevisionPromotion() const {
+  delegate_.shadowTreeDidFinishReactCommit(*this);
+}
+
 void ShadowTree::commitEmptyTree() const {
   commit(
       [](const RootShadowNode& oldRootShadowNode)
@@ -426,19 +559,21 @@ void ShadowTree::notifyDelegatesOfUpdates() const {
   delegate_.shadowTreeDidFinishTransaction(mountingCoordinator_, true);
 }
 
-inline ShadowTree::UniqueLock ShadowTree::uniqueCommitLock() const {
+inline ShadowTree::UniqueLock ShadowTree::uniqueRevisionLock(bool defer) const {
   if (ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion()) {
-    return std::unique_lock{commitMutexRecursive_};
+    return defer ? std::unique_lock{revisionMutexRecursive_, std::defer_lock}
+                 : std::unique_lock{revisionMutexRecursive_};
   } else {
-    return std::unique_lock{commitMutex_};
+    return defer ? std::unique_lock{revisionMutex_, std::defer_lock}
+                 : std::unique_lock{revisionMutex_};
   }
 }
 
-inline ShadowTree::SharedLock ShadowTree::sharedCommitLock() const {
+inline ShadowTree::SharedLock ShadowTree::sharedRevisionLock() const {
   if (ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion()) {
-    return std::unique_lock{commitMutexRecursive_};
+    return std::unique_lock{revisionMutexRecursive_};
   } else {
-    return std::shared_lock{commitMutex_};
+    return std::shared_lock{revisionMutex_};
   }
 }
 

package/ReactCommon/react/renderer/mounting/ShadowTree.h

@@ -50,6 +50,8 @@ enum class ShadowTreeCommitMode {
 enum class ShadowTreeCommitSource {
   Unknown,
   React,
+  AnimationEndSync,
+  ReactRevisionMerge,
 };
 
 struct ShadowTreeCommitOptions {
@@ -123,6 +125,12 @@ class ShadowTree final {
    */
   ShadowTreeRevision getCurrentRevision() const;
 
+  /*
+   * Returns a `ShadowTreeRevision` representing the momentary state of
+   * the `ShadowTree` in the JS thread.
+   */
+  std::optional<ShadowTreeRevision> getCurrentReactRevision() const;
+
   /*
    * Commit an empty tree (a new `RootShadowNode` with no children).
    */
@@ -136,6 +144,18 @@ class ShadowTree final {
 
   std::shared_ptr<const MountingCoordinator> getMountingCoordinator() const;
 
+  /**
+   * Promotes the current React revision to be merged into the main branch of the
+   * ShadowTree.
+   */
+  void promoteReactRevision() const;
+
+  /**
+   * Commits the currently promoted React revision to the "main" branch of the
+   * ShadowTree. No-op if the promoted React revision doesn't exist.
+   */
+  void mergeReactRevision() const;
+
  private:
   constexpr static ShadowTreeRevision::Number INITIAL_REVISION{0};
 
@@ -143,19 +163,23 @@ class ShadowTree final {
 
   void emitLayoutEvents(std::vector<const LayoutableShadowNode *> &affectedLayoutableNodes) const;
 
+  void scheduleReactRevisionPromotion() const;
+
   const SurfaceId surfaceId_;
   const ShadowTreeDelegate &delegate_;
-  mutable std::shared_mutex commitMutex_;
-  mutable std::recursive_mutex commitMutexRecursive_;
-  mutable CommitMode commitMode_{CommitMode::Normal}; // Protected by `commitMutex_`.
-  mutable ShadowTreeRevision currentRevision_; // Protected by `commitMutex_`.
+  mutable std::shared_mutex revisionMutex_;
+  mutable std::recursive_mutex revisionMutexRecursive_;
+  mutable CommitMode commitMode_{CommitMode::Normal}; // Protected by `revisionMutex_`.
+  mutable ShadowTreeRevision currentRevision_; // Protected by `revisionMutex_`.
+  mutable std::optional<ShadowTreeRevision> currentReactRevision_; // Protected by `revisionMutex_`.
+  mutable std::optional<ShadowTreeRevision> reactRevisionToBePromoted_; // Protected by `revisionMutex_`.
   std::shared_ptr<const MountingCoordinator> mountingCoordinator_;
 
   using UniqueLock = std::variant<std::unique_lock<std::shared_mutex>, std::unique_lock<std::recursive_mutex>>;
   using SharedLock = std::variant<std::shared_lock<std::shared_mutex>, std::unique_lock<std::recursive_mutex>>;
 
-  inline UniqueLock uniqueCommitLock() const;
-  inline SharedLock sharedCommitLock() const;
+  inline UniqueLock uniqueRevisionLock(bool defer = false) const;
+  inline SharedLock sharedRevisionLock() const;
 };
 
 } // namespace facebook::react