Implement IEventLoopControl in RuntimeScheduler

Summary:
Make `RuntimeScheduler` implement `IEventLoopControl`.
Wire `ReactInstance` to register that scheduler on Hermes
runtimes that expose `ISetEventLoopControl`.
Clear the pointer during teardown before `RuntimeScheduler`
is destroyed.
Regenerate React Native C++ API snapshots for the public
header change.

Only the modern scheduler have the actual implementation, it's no-op
in the legacy scheduler.

Changelog: [Internal]

Reviewed By: javache

Differential Revision: D106744175

Author: lavenzg

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -61,6 +61,18 @@ void RuntimeScheduler::scheduleWork(RawCallback&& callback) noexcept {
   return runtimeSchedulerImpl_->scheduleWork(std::move(callback));
 }
 
+void RuntimeScheduler::scheduleTask(const std::function<void()>& task) {
+  return runtimeSchedulerImpl_->scheduleTask(task);
+}
+
+uint64_t RuntimeScheduler::registerTaskQueueSource() {
+  return runtimeSchedulerImpl_->registerTaskQueueSource();
+}
+
+void RuntimeScheduler::unregisterTaskQueueSource(uint64_t sourceId) {
+  return runtimeSchedulerImpl_->unregisterTaskQueueSource(sourceId);
+}
+
 std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
     SchedulerPriority priority,
     jsi::Function&& callback) noexcept {

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <ReactCommon/RuntimeExecutor.h>
+#include <jsi/hermes-interfaces.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/consistency/ShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/runtimescheduler/SchedulerPriorityUtils.h>
@@ -27,9 +28,12 @@ extern const char RuntimeSchedulerKey[];
 
 // This is a temporary abstract class for RuntimeScheduler forks to implement
 // (and use them interchangeably).
-class RuntimeSchedulerBase {
+class RuntimeSchedulerBase : public facebook::hermes::IEventLoopControl {
  public:
   virtual ~RuntimeSchedulerBase() = default;
+
+  using facebook::hermes::IEventLoopControl::scheduleTask;
+
   virtual void scheduleWork(RawCallback &&callback) noexcept = 0;
   virtual void executeNowOnTheSameThread(RawCallback &&callback) = 0;
   virtual std::shared_ptr<Task> scheduleTask(SchedulerPriority priority, jsi::Function &&callback) noexcept = 0;
@@ -55,7 +59,7 @@ class RuntimeSchedulerBase {
 
 // This is a proxy for RuntimeScheduler implementation, which will be selected
 // at runtime based on a feature flag.
-class RuntimeScheduler final : RuntimeSchedulerBase {
+class RuntimeScheduler final : public RuntimeSchedulerBase {
  public:
   explicit RuntimeScheduler(
       RuntimeExecutor runtimeExecutor,
@@ -76,6 +80,13 @@ class RuntimeScheduler final : RuntimeSchedulerBase {
 
   void scheduleWork(RawCallback &&callback) noexcept override;
 
+  /// IEventLoopControl implementation, forwarded to the underlying fork.
+  void scheduleTask(const std::function<void()> &task) override;
+
+  uint64_t registerTaskQueueSource() override;
+
+  void unregisterTaskQueueSource(uint64_t sourceId) override;
+
   /*
    * Grants access to the runtime synchronously on the caller's thread.
    *

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.cpp

@@ -46,6 +46,14 @@ void RuntimeScheduler_Legacy::scheduleWork(RawCallback&& callback) noexcept {
       });
 }
 
+void RuntimeScheduler_Legacy::scheduleTask(
+    [[maybe_unused]] const std::function<void()>& task) {}
+uint64_t RuntimeScheduler_Legacy::registerTaskQueueSource() {
+  return 0;
+}
+void RuntimeScheduler_Legacy::unregisterTaskQueueSource(
+    [[maybe_unused]] uint64_t sourceId) {}
+
 std::shared_ptr<Task> RuntimeScheduler_Legacy::scheduleTask(
     SchedulerPriority priority,
     jsi::Function&& callback) noexcept {

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.h

@@ -40,6 +40,11 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
 
   void scheduleWork(RawCallback &&callback) noexcept override;
 
+  /// IEventLoopControl implementation. No-op for legacy scheduler.
+  void scheduleTask(const std::function<void()> &task) override;
+  uint64_t registerTaskQueueSource() override;
+  void unregisterTaskQueueSource(uint64_t sourceId) override;
+
   /*
    * Grants access to the runtime synchronously on the caller's thread.
    *

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.cpp

@@ -47,6 +47,23 @@ void RuntimeScheduler_Modern::scheduleWork(RawCallback&& callback) noexcept {
   scheduleTask(SchedulerPriority::ImmediatePriority, std::move(callback));
 }
 
+void RuntimeScheduler_Modern::scheduleTask(const std::function<void()>& task) {
+  scheduleIdleTask([task](jsi::Runtime& /*runtime*/) { task(); });
+}
+
+uint64_t RuntimeScheduler_Modern::registerTaskQueueSource() {
+  // It's fine to wrap around, as it's impossible to hold so many live task
+  // queue sources in practice.
+  return nextTaskQueueSourceId_.fetch_add(1) + 1;
+}
+
+void RuntimeScheduler_Modern::unregisterTaskQueueSource(uint64_t /*sourceId*/) {
+  // For now, we don't need to do unregistering. The reason is that the event
+  // loop of the runtime scheduler doesn't need to be blocked on the task
+  // producer of IEventLoopControl. When the event loop ends, we just ignore
+  // all queueing tasks.
+}
+
 std::shared_ptr<Task> RuntimeScheduler_Modern::scheduleTask(
     SchedulerPriority priority,
     jsi::Function&& callback) noexcept {

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.h

@@ -45,6 +45,14 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    */
   void scheduleWork(RawCallback &&callback) noexcept override;
 
+  /// IEventLoopControl implementation. \p task is always scheduled as an idle
+  /// task.
+  void scheduleTask(const std::function<void()> &task) override;
+
+  uint64_t registerTaskQueueSource() override;
+
+  void unregisterTaskQueueSource(uint64_t sourceId) override;
+
   /*
    * Grants access to the runtime synchronously on the caller's thread.
    *
@@ -144,6 +152,10 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
       RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate) override;
 
  private:
+  /// Monotonic counter handing out IDs for IEventLoopControl task queue
+  /// sources.
+  std::atomic<uint64_t> nextTaskQueueSourceId_{0};
+
   std::atomic<uint_fast8_t> syncTaskRequests_{0};
 
   std::priority_queue<std::shared_ptr<Task>, std::vector<std::shared_ptr<Task>>, TaskPriorityComparer> taskQueue_;

packages/react-native/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -7,6 +7,7 @@
 
 #include <gtest/gtest.h>
 #include <hermes/hermes.h>
+#include <jsi/hermes-interfaces.h>
 #include <jsi/jsi.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
@@ -170,6 +171,31 @@ TEST_P(RuntimeSchedulerTest, scheduleSingleTask) {
   EXPECT_EQ(stubQueue_->size(), 0);
 }
 
+TEST_P(RuntimeSchedulerTest, scheduleTaskViaEventLoopControl) {
+  // The RuntimeScheduler proxy is what gets registered with Hermes as an
+  // IEventLoopControl. scheduleTask() forwards to the selected fork, which
+  // schedules the work as an idle task.
+  facebook::hermes::IEventLoopControl& eventLoopControl = *runtimeScheduler_;
+
+  bool didRunTask = false;
+  eventLoopControl.scheduleTask([&didRunTask]() { didRunTask = true; });
+
+  if (GetParam()) {
+    // Modern scheduler: the task is queued on the event loop and runs on tick.
+    EXPECT_FALSE(didRunTask);
+    EXPECT_EQ(stubQueue_->size(), 1);
+
+    stubQueue_->tick();
+
+    EXPECT_TRUE(didRunTask);
+    EXPECT_EQ(stubQueue_->size(), 0);
+  } else {
+    // Legacy scheduler: idle tasks are not supported, so this is a no-op.
+    EXPECT_FALSE(didRunTask);
+    EXPECT_EQ(stubQueue_->size(), 0);
+  }
+}
+
 TEST_P(
     RuntimeSchedulerTest,
     scheduleSingleTaskWithMicrotasksAndBatchedRenderingUpdate) {

packages/react-native/ReactCommon/react/runtime/ReactInstance.cpp

@@ -48,6 +48,16 @@ std::shared_ptr<RuntimeScheduler> createRuntimeScheduler(
   return scheduler;
 }
 
+void setHermesEventLoopControl(
+    jsi::Runtime& runtime,
+    facebook::hermes::IEventLoopControl* eventLoopControl) {
+  auto* setEventLoopControl =
+      jsi::castInterface<facebook::hermes::ISetEventLoopControl>(&runtime);
+  if (setEventLoopControl != nullptr) {
+    setEventLoopControl->setEventLoopControl(eventLoopControl);
+  }
+}
+
 std::string getSyntheticBundlePath(uint32_t bundleId) {
   std::array<char, 32> buffer{};
   std::snprintf(buffer.data(), buffer.size(), "seg-%u.js", bundleId);
@@ -156,13 +166,23 @@ ReactInstance::ReactInstance(
         });
   }
 
+  runtimeExecutor(
+      [runtimeScheduler = runtimeScheduler_.get()](jsi::Runtime& runtime) {
+        setHermesEventLoopControl(runtime, runtimeScheduler);
+      });
+
   bufferedRuntimeExecutor_ = std::make_shared<BufferedRuntimeExecutor>(
       [runtimeScheduler = runtimeScheduler_.get()](
           std::function<void(jsi::Runtime & runtime)>&& callback) {
         runtimeScheduler->scheduleWork(std::move(callback));
       });
 }
 ReactInstance::~ReactInstance() noexcept {
+  // This is thread safe because there is no JSI call at this point, and there
+  // won't be any concurrent calls to getEventLoopControl().
+  // We need to clear this pointer before runtimeScheduler_ is destroyed.
+  setHermesEventLoopControl(runtime_->getRuntime(), nullptr);
+
   if (timerManager_ != nullptr) {
     timerManager_->quit();
   }

packages/react-native/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp

@@ -15,6 +15,7 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <hermes/hermes.h>
 #include <jserrorhandler/JsErrorHandler.h>
+#include <jsi/hermes-interfaces.h>
 #include <jsi/jsi.h>
 #include <react/runtime/ReactInstance.h>
 
@@ -138,6 +139,12 @@ class ReactInstanceTest : public ::testing::Test {
         std::move(onJsError));
     timerManager_->setRuntimeExecutor(instance_->getBufferedRuntimeExecutor());
 
+    // ReactInstance construction defers registering the RuntimeScheduler as the
+    // Hermes IEventLoopControl onto the runtime executor, which enqueues a
+    // callback on messageQueueThread_. Drain it so each test starts from an
+    // empty queue and its step() bookkeeping is unaffected.
+    step();
+
     // Install a C++ error handler
     errorHandler_ = std::make_shared<ErrorUtils>();
     runtime_->global().setProperty(
@@ -223,6 +230,23 @@ class ReactInstanceTest : public ::testing::Test {
   std::shared_ptr<ErrorUtils> errorHandler_;
 };
 
+TEST_F(ReactInstanceTest, testRegistersRuntimeSchedulerAsEventLoopControl) {
+  auto* setEventLoopControl =
+      jsi::castInterface<facebook::hermes::ISetEventLoopControl>(runtime_);
+  if (setEventLoopControl == nullptr) {
+    // This Hermes build does not implement ISetEventLoopControl, so
+    // ReactInstance's registration is a no-op and there is nothing to observe.
+    GTEST_SKIP()
+        << "Hermes runtime does not expose ISetEventLoopControl in this build";
+  }
+
+  // SetUp() already drained the deferred registration callback, so by now the
+  // RuntimeScheduler is registered as the runtime's event loop control.
+  facebook::hermes::IEventLoopControl* expected =
+      instance_->getRuntimeScheduler().get();
+  EXPECT_EQ(setEventLoopControl->getEventLoopControl(), expected);
+}
+
 TEST_F(ReactInstanceTest, testBridgelessFlagIsSet) {
   auto valBefore = tryEval("RN$Bridgeless === true", "false");
   EXPECT_EQ(valBefore.getBool(), false);

packages/react-native/ReactCommon/react/runtime/tests/cxx/RuntimeExecutorShutdownTest.cpp

@@ -73,6 +73,12 @@ class RuntimeExecutorShutdownTest : public ::testing::Test {
         messageQueueThread_,
         timerManager,
         std::move(onJsError));
+
+    // ReactInstance construction defers registering the RuntimeScheduler as the
+    // Hermes IEventLoopControl onto the runtime executor, which enqueues a
+    // callback on messageQueueThread_. Drain it so each shutdown scenario
+    // starts from an empty queue.
+    messageQueueThread_->tick();
   }
 
   std::shared_ptr<MockMessageQueueThread> messageQueueThread_;