Split scheduler commit and flush delegate methods

packages/react-native/React/Fabric/RCTScheduler.h

@@ -28,6 +28,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)schedulerDidFinishTransaction:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
 
+- (void)schedulerShouldRenderTransactions:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
+
 - (void)schedulerDidDispatchCommand:(const facebook::react::ShadowView &)shadowView
                         commandName:(const std::string &)commandName
                                args:(const folly::dynamic &)args;

packages/react-native/React/Fabric/RCTScheduler.mm

@@ -31,6 +31,12 @@ void schedulerDidFinishTransaction(const MountingCoordinator::Shared &mountingCo
     [scheduler.delegate schedulerDidFinishTransaction:mountingCoordinator];
   }
 
+  void schedulerShouldRenderTransactions(const MountingCoordinator::Shared &mountingCoordinator) override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler.delegate schedulerShouldRenderTransactions:mountingCoordinator];
+  }
+
   void schedulerDidRequestPreliminaryViewAllocation(SurfaceId surfaceId, const ShadowNode &shadowNode) override
   {
     // Does nothing.

packages/react-native/React/Fabric/RCTSurfacePresenter.mm

@@ -334,7 +334,16 @@ - (void)_applicationWillTerminate
 
 - (void)schedulerDidFinishTransaction:(MountingCoordinator::Shared)mountingCoordinator
 {
-  [_mountingManager scheduleTransaction:mountingCoordinator];
+  if (!ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
+    [_mountingManager scheduleTransaction:mountingCoordinator];
+  }
+}
+
+- (void)schedulerShouldRenderTransactions:(MountingCoordinator::Shared)mountingCoordinator
+{
+  if (ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
+    [_mountingManager scheduleTransaction:mountingCoordinator];
+  }
 }
 
 - (void)schedulerDidDispatchCommand:(const ShadowView &)shadowView

packages/react-native/ReactAndroid/src/main/jni/react/fabric/Binding.cpp

@@ -462,16 +462,38 @@ std::shared_ptr<FabricMountingManager> Binding::getMountingManager(
 
 void Binding::schedulerDidFinishTransaction(
     const MountingCoordinator::Shared& mountingCoordinator) {
-  auto mountingManager = getMountingManager("schedulerDidFinishTransaction");
-  if (!mountingManager) {
+  auto mountingTransaction = mountingCoordinator->pullTransaction();
+  if (!mountingTransaction.has_value()) {
     return;
   }
 
-  auto mountingTransaction = mountingCoordinator->pullTransaction();
-  if (!mountingTransaction.has_value()) {
+  auto pendingTransaction = std::find_if(
+      pendingTransactions_.begin(),
+      pendingTransactions_.end(),
+      [&](const auto& transaction) {
+        return transaction.getSurfaceId() ==
+            mountingTransaction->getSurfaceId();
+      });
+
+  if (pendingTransaction != pendingTransactions_.end()) {
+    pendingTransaction->mergeWith(std::move(*mountingTransaction));
+  } else {
+    pendingTransactions_.push_back(std::move(*mountingTransaction));
+  }
+}
+
+void Binding::schedulerShouldRenderTransactions(
+    const MountingCoordinator::Shared& /*mountingCoordinator*/) {
+  auto mountingManager =
+      getMountingManager("schedulerShouldRenderTransactions");
+  if (!mountingManager) {
     return;
   }
-  mountingManager->executeMount(*mountingTransaction);
+
+  for (auto& transaction : pendingTransactions_) {
+    mountingManager->executeMount(transaction);
+  }
+  pendingTransactions_.clear();
 }
 
 void Binding::schedulerDidRequestPreliminaryViewAllocation(

packages/react-native/ReactAndroid/src/main/jni/react/fabric/Binding.h

@@ -101,6 +101,9 @@ class Binding : public jni::HybridClass<Binding, JBinding>,
   void schedulerDidFinishTransaction(
       const MountingCoordinator::Shared& mountingCoordinator) override;
 
+  void schedulerShouldRenderTransactions(
+      const MountingCoordinator::Shared& mountingCoordinator) override;
+
   void schedulerDidRequestPreliminaryViewAllocation(
       const SurfaceId surfaceId,
       const ShadowNode& shadowNode) override;
@@ -146,6 +149,9 @@ class Binding : public jni::HybridClass<Binding, JBinding>,
   std::shared_mutex
       surfaceHandlerRegistryMutex_; // Protects `surfaceHandlerRegistry_`.
 
+  // Track pending transactions, one per surfaceId
+  std::vector<MountingTransaction> pendingTransactions_;
+
   float pointScaleFactor_ = 1;
 
   std::shared_ptr<const ReactNativeConfig> reactNativeConfig_{nullptr};

packages/react-native/ReactCommon/react/renderer/mounting/MountingTransaction.cpp

@@ -41,4 +41,17 @@ Number MountingTransaction::getNumber() const {
   return number_;
 }
 
+void MountingTransaction::mergeWith(MountingTransaction&& transaction) {
+  react_native_assert(transaction.getSurfaceId() == surfaceId_);
+  number_ = transaction.getNumber();
+  mutations_.insert(
+      mutations_.end(),
+      std::make_move_iterator(transaction.mutations_.begin()),
+      std::make_move_iterator(transaction.mutations_.end()));
+
+  // TODO T186641819: Telemetry for merged transactions is not supported, use
+  // the latest instance
+  telemetry_ = std::move(transaction.telemetry_);
+}
+
 } // namespace facebook::react

packages/react-native/ReactCommon/react/renderer/mounting/MountingTransaction.h

@@ -76,6 +76,12 @@ class MountingTransaction final {
    */
   Number getNumber() const;
 
+  /*
+   * Merges the given transaction in the current transaction, so they
+   * can be executed atomatically as a single transaction.
+   */
+  void mergeWith(MountingTransaction&& transaction);
+
  private:
   SurfaceId surfaceId_;
   Number number_;

packages/react-native/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -291,6 +291,8 @@ void Scheduler::uiManagerDidFinishTransaction(
   SystraceSection s("Scheduler::uiManagerDidFinishTransaction");
 
   if (delegate_ != nullptr) {
+    delegate_->schedulerDidFinishTransaction(mountingCoordinator);
+
     auto weakRuntimeScheduler =
         contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
             "RuntimeScheduler");
@@ -301,13 +303,14 @@ void Scheduler::uiManagerDidFinishTransaction(
       runtimeScheduler->scheduleRenderingUpdate(
           [delegate = delegate_,
            mountingCoordinator = std::move(mountingCoordinator)]() {
-            delegate->schedulerDidFinishTransaction(mountingCoordinator);
+            delegate->schedulerShouldRenderTransactions(mountingCoordinator);
           });
     } else {
-      delegate_->schedulerDidFinishTransaction(mountingCoordinator);
+      delegate_->schedulerShouldRenderTransactions(mountingCoordinator);
     }
   }
 }
+
 void Scheduler::uiManagerDidCreateShadowNode(const ShadowNode& shadowNode) {
   SystraceSection s("Scheduler::uiManagerDidCreateShadowNode");
 

packages/react-native/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -28,6 +28,13 @@ class SchedulerDelegate {
   virtual void schedulerDidFinishTransaction(
       const MountingCoordinator::Shared& mountingCoordinator) = 0;
 
+  /*
+   * Called when the runtime scheduler decides that one-or-more previously
+   * finished transactions should now be flushed to the screen (atomically).
+   */
+  virtual void schedulerShouldRenderTransactions(
+      const MountingCoordinator::Shared& mountingCoordinator) = 0;
+
   /*
    * Called right after a new ShadowNode was created.
    */