react-native 0.0.0-17be3a003 → 0.0.0-18697adec

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -42,7 +42,8 @@ class RuntimeSchedulerTest : public testing::Test {
         std::make_unique<RuntimeScheduler>(runtimeExecutor, stubNow);
   }
 
-  jsi::Function createHostFunctionFromLambda(std::function<void()> callback) {
+  jsi::Function createHostFunctionFromLambda(
+      std::function<jsi::Value(bool)> callback) {
     return jsi::Function::createFromHostFunction(
         *runtime_,
         jsi::PropNameID::forUtf8(*runtime_, ""),
@@ -50,11 +51,11 @@ class RuntimeSchedulerTest : public testing::Test {
         [this, callback = std::move(callback)](
             jsi::Runtime &,
             jsi::Value const &,
-            jsi::Value const *,
+            jsi::Value const *arguments,
             size_t) noexcept -> jsi::Value {
           ++hostFunctionCallCount_;
-          callback();
-          return jsi::Value::undefined();
+          auto didUserCallbackTimeout = arguments[0].getBool();
+          return callback(didUserCallbackTimeout);
         });
   }
 
@@ -88,11 +89,62 @@ TEST_F(RuntimeSchedulerTest, getShouldYield) {
 TEST_F(RuntimeSchedulerTest, scheduleSingleTask) {
   bool didRunTask = false;
   auto callback =
-      createHostFunctionFromLambda([&didRunTask]() { didRunTask = true; });
+      createHostFunctionFromLambda([&didRunTask](bool didUserCallbackTimeout) {
+        didRunTask = true;
+        EXPECT_FALSE(didUserCallbackTimeout);
+        return jsi::Value::undefined();
+      });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  EXPECT_FALSE(didRunTask);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunTask);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, scheduleImmediatePriorityTask) {
+  bool didRunTask = false;
+  auto callback =
+      createHostFunctionFromLambda([&didRunTask](bool didUserCallbackTimeout) {
+        didRunTask = true;
+        EXPECT_FALSE(didUserCallbackTimeout);
+        return jsi::Value::undefined();
+      });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::ImmediatePriority, std::move(callback));
+
+  EXPECT_FALSE(didRunTask);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunTask);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, taskExpiration) {
+  bool didRunTask = false;
+  auto callback =
+      createHostFunctionFromLambda([&didRunTask](bool didUserCallbackTimeout) {
+        didRunTask = true;
+        // Task has timed out but the parameter is deprecated and `false` is
+        // hardcoded.
+        EXPECT_FALSE(didUserCallbackTimeout);
+        return jsi::Value::undefined();
+      });
 
   runtimeScheduler_->scheduleTask(
       SchedulerPriority::NormalPriority, std::move(callback));
 
+  // Task with normal priority has 5s timeout.
+  stubClock_->advanceTimeBy(6s);
+
   EXPECT_FALSE(didRunTask);
   EXPECT_EQ(stubQueue_->size(), 1);
 
@@ -105,8 +157,9 @@ TEST_F(RuntimeSchedulerTest, scheduleSingleTask) {
 TEST_F(RuntimeSchedulerTest, scheduleTwoTasksWithSamePriority) {
   uint firstTaskCallOrder;
   auto callbackOne =
-      createHostFunctionFromLambda([this, &firstTaskCallOrder]() {
+      createHostFunctionFromLambda([this, &firstTaskCallOrder](bool) {
         firstTaskCallOrder = hostFunctionCallCount_;
+        return jsi::Value::undefined();
       });
 
   runtimeScheduler_->scheduleTask(
@@ -114,8 +167,9 @@ TEST_F(RuntimeSchedulerTest, scheduleTwoTasksWithSamePriority) {
 
   uint secondTaskCallOrder;
   auto callbackTwo =
-      createHostFunctionFromLambda([this, &secondTaskCallOrder]() {
+      createHostFunctionFromLambda([this, &secondTaskCallOrder](bool) {
         secondTaskCallOrder = hostFunctionCallCount_;
+        return jsi::Value::undefined();
       });
 
   runtimeScheduler_->scheduleTask(
@@ -136,8 +190,9 @@ TEST_F(RuntimeSchedulerTest, scheduleTwoTasksWithSamePriority) {
 TEST_F(RuntimeSchedulerTest, scheduleTwoTasksWithDifferentPriorities) {
   uint lowPriorityTaskCallOrder;
   auto callbackOne =
-      createHostFunctionFromLambda([this, &lowPriorityTaskCallOrder]() {
+      createHostFunctionFromLambda([this, &lowPriorityTaskCallOrder](bool) {
         lowPriorityTaskCallOrder = hostFunctionCallCount_;
+        return jsi::Value::undefined();
       });
 
   runtimeScheduler_->scheduleTask(
@@ -145,8 +200,9 @@ TEST_F(RuntimeSchedulerTest, scheduleTwoTasksWithDifferentPriorities) {
 
   uint userBlockingPriorityTaskCallOrder;
   auto callbackTwo = createHostFunctionFromLambda(
-      [this, &userBlockingPriorityTaskCallOrder]() {
+      [this, &userBlockingPriorityTaskCallOrder](bool) {
         userBlockingPriorityTaskCallOrder = hostFunctionCallCount_;
+        return jsi::Value::undefined();
       });
 
   runtimeScheduler_->scheduleTask(
@@ -166,8 +222,10 @@ TEST_F(RuntimeSchedulerTest, scheduleTwoTasksWithDifferentPriorities) {
 
 TEST_F(RuntimeSchedulerTest, cancelTask) {
   bool didRunTask = false;
-  auto callback =
-      createHostFunctionFromLambda([&didRunTask]() { didRunTask = true; });
+  auto callback = createHostFunctionFromLambda([&didRunTask](bool) {
+    didRunTask = true;
+    return jsi::Value::undefined();
+  });
 
   auto task = runtimeScheduler_->scheduleTask(
       SchedulerPriority::NormalPriority, std::move(callback));
@@ -183,4 +241,232 @@ TEST_F(RuntimeSchedulerTest, cancelTask) {
   EXPECT_EQ(stubQueue_->size(), 0);
 }
 
+TEST_F(RuntimeSchedulerTest, continuationTask) {
+  bool didRunTask = false;
+  bool didContinuationTask = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunTask = true;
+    return jsi::Function::createFromHostFunction(
+        *runtime_,
+        jsi::PropNameID::forUtf8(*runtime_, ""),
+        1,
+        [&](jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *arguments,
+            size_t) noexcept -> jsi::Value {
+          didContinuationTask = true;
+          return jsi::Value::undefined();
+        });
+  });
+
+  auto task = runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  EXPECT_FALSE(didRunTask);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunTask);
+  EXPECT_TRUE(didContinuationTask);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, getCurrentPriorityLevel) {
+  auto callback =
+      createHostFunctionFromLambda([this](bool didUserCallbackTimeout) {
+        EXPECT_EQ(
+            runtimeScheduler_->getCurrentPriorityLevel(),
+            SchedulerPriority::ImmediatePriority);
+        return jsi::Value::undefined();
+      });
+
+  EXPECT_EQ(
+      runtimeScheduler_->getCurrentPriorityLevel(),
+      SchedulerPriority::NormalPriority);
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::ImmediatePriority, std::move(callback));
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(
+      runtimeScheduler_->getCurrentPriorityLevel(),
+      SchedulerPriority::NormalPriority);
+
+  callback = createHostFunctionFromLambda([this](bool didUserCallbackTimeout) {
+    EXPECT_EQ(
+        runtimeScheduler_->getCurrentPriorityLevel(),
+        SchedulerPriority::IdlePriority);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::IdlePriority, std::move(callback));
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(
+      runtimeScheduler_->getCurrentPriorityLevel(),
+      SchedulerPriority::NormalPriority);
+}
+
+TEST_F(RuntimeSchedulerTest, scheduleWork) {
+  bool wasCalled = false;
+  runtimeScheduler_->scheduleWork(
+      [&](jsi::Runtime const &) { wasCalled = true; });
+
+  EXPECT_FALSE(wasCalled);
+
+  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(wasCalled);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, scheduleWorkWithYielding) {
+  runtimeScheduler_->setEnableYielding(true);
+  bool wasCalled = false;
+  runtimeScheduler_->scheduleWork(
+      [&](jsi::Runtime const &) { wasCalled = true; });
+
+  EXPECT_FALSE(wasCalled);
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(wasCalled);
+  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, normalTaskYieldsToPlatformEvent) {
+  runtimeScheduler_->setEnableYielding(true);
+
+  bool didRunJavaScriptTask = false;
+  bool didRunPlatformWork = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunJavaScriptTask = true;
+    EXPECT_TRUE(didRunPlatformWork);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  runtimeScheduler_->scheduleWork([&](jsi::Runtime const &) {
+    didRunPlatformWork = true;
+    EXPECT_FALSE(didRunJavaScriptTask);
+    EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+  });
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 2);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, expiredTaskDoesntYieldToPlatformEvent) {
+  runtimeScheduler_->setEnableYielding(true);
+
+  bool didRunJavaScriptTask = false;
+  bool didRunPlatformWork = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunJavaScriptTask = true;
+    EXPECT_FALSE(didRunPlatformWork);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  runtimeScheduler_->scheduleWork([&](jsi::Runtime const &) {
+    didRunPlatformWork = true;
+    EXPECT_TRUE(didRunJavaScriptTask);
+  });
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 2);
+
+  stubClock_->advanceTimeBy(6s);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, immediateTaskDoesntYieldToPlatformEvent) {
+  runtimeScheduler_->setEnableYielding(true);
+
+  bool didRunJavaScriptTask = false;
+  bool didRunPlatformWork = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunJavaScriptTask = true;
+    EXPECT_FALSE(didRunPlatformWork);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::ImmediatePriority, std::move(callback));
+
+  runtimeScheduler_->scheduleWork([&](jsi::Runtime const &) {
+    didRunPlatformWork = true;
+    EXPECT_TRUE(didRunJavaScriptTask);
+  });
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 2);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, scheduleTaskFromTask) {
+  bool didRunFirstTask = false;
+  bool didRunSecondTask = false;
+  auto firstCallback = createHostFunctionFromLambda(
+      [this, &didRunFirstTask, &didRunSecondTask](bool didUserCallbackTimeout) {
+        didRunFirstTask = true;
+        EXPECT_FALSE(didUserCallbackTimeout);
+
+        auto secondCallback = createHostFunctionFromLambda(
+            [&didRunSecondTask](bool didUserCallbackTimeout) {
+              didRunSecondTask = true;
+              EXPECT_FALSE(didUserCallbackTimeout);
+              return jsi::Value::undefined();
+            });
+
+        runtimeScheduler_->scheduleTask(
+            SchedulerPriority::ImmediatePriority, std::move(secondCallback));
+        return jsi::Value::undefined();
+      });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(firstCallback));
+
+  EXPECT_FALSE(didRunFirstTask);
+  EXPECT_FALSE(didRunSecondTask);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunFirstTask);
+  EXPECT_TRUE(didRunSecondTask);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/tests/StubQueue.h

@@ -15,6 +15,12 @@ class StubQueue {
     callbackQueue_.push(func);
   }
 
+  void flush() {
+    while (!callbackQueue_.empty()) {
+      tick();
+    }
+  }
+
   void tick() {
     if (!callbackQueue_.empty()) {
       auto callback = callbackQueue_.front();

package/ReactCommon/react/renderer/scheduler/AsynchronousEventBeat.cpp

@@ -9,8 +9,7 @@
 
 #include <react/debug/react_native_assert.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 AsynchronousEventBeat::AsynchronousEventBeat(
     RunLoopObserver::Unique uiRunLoopObserver,
@@ -24,34 +23,36 @@ AsynchronousEventBeat::AsynchronousEventBeat(
 
 void AsynchronousEventBeat::activityDidChange(
     RunLoopObserver::Delegate const *delegate,
-    RunLoopObserver::Activity activity) const noexcept {
+    RunLoopObserver::Activity) const noexcept {
   react_native_assert(delegate == this);
   induce();
 }
 
 void AsynchronousEventBeat::induce() const {
-  if (!isRequested_) {
+  if (!isRequested_ || isBeatCallbackScheduled_) {
     return;
   }
 
+  isRequested_ = false;
+
   // Here we know that `this` object exists because the caller has a strong
   // pointer to `owner`. To ensure the object will exist inside
   // `runtimeExecutor_` callback, we need to copy the  pointer there.
   auto weakOwner = uiRunLoopObserver_->getOwner();
 
-  runtimeExecutor_([this, weakOwner](jsi::Runtime &runtime) mutable {
+  isBeatCallbackScheduled_ = true;
+
+  runtimeExecutor_([this, weakOwner](jsi::Runtime &runtime) {
+    isBeatCallbackScheduled_ = false;
+
     auto owner = weakOwner.lock();
     if (!owner) {
       return;
     }
 
-    if (!isRequested_) {
-      return;
+    if (beatCallback_) {
+      beatCallback_(runtime);
     }
-
-    this->beat(runtime);
   });
 }
-
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/renderer/scheduler/AsynchronousEventBeat.h

@@ -9,8 +9,7 @@
 #include <react/renderer/core/EventBeat.h>
 #include <react/utils/RunLoopObserver.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 /*
  * Event beat associated with JavaScript runtime.
@@ -35,7 +34,8 @@ class AsynchronousEventBeat : public EventBeat,
  private:
   RunLoopObserver::Unique uiRunLoopObserver_;
   RuntimeExecutor runtimeExecutor_;
+
+  mutable std::atomic<bool> isBeatCallbackScheduled_{false};
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/renderer/{components/picker/androidpicker/react/renderer/components/androidpicker/AndroidDialogPickerShadowNode.cpp → scheduler/InspectorData.h}

@@ -5,12 +5,20 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "AndroidDialogPickerShadowNode.h"
+#include <vector>
 
 namespace facebook {
 namespace react {
 
-extern const char AndroidDialogPickerComponentName[] = "AndroidDialogPicker";
+struct InspectorData {
+  std::vector<std::string> hierarchy;
+  int selectedIndex;
+  std::string fileName;
+  int lineNumber;
+  int columnNumber;
+  // TODO T97216348: remove folly::dynamic from InspectorData struct
+  folly::dynamic props;
+};
 
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -12,7 +12,7 @@
 
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
-#include <react/renderer/core/Constants.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
@@ -35,19 +35,18 @@ Scheduler::Scheduler(
     UIManagerAnimationDelegate *animationDelegate,
     SchedulerDelegate *delegate) {
   runtimeExecutor_ = schedulerToolbox.runtimeExecutor;
+  contextContainer_ = schedulerToolbox.contextContainer;
 
   reactNativeConfig_ =
-      schedulerToolbox.contextContainer
-          ->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
+      contextContainer_->at<std::shared_ptr<const ReactNativeConfig>>(
+          "ReactNativeConfig");
 
   // Creating a container for future `EventDispatcher` instance.
   eventDispatcher_ =
       std::make_shared<better::optional<EventDispatcher const>>();
 
   auto uiManager = std::make_shared<UIManager>(
-      runtimeExecutor_,
-      schedulerToolbox.backgroundExecutor,
-      schedulerToolbox.garbageCollectionTrigger);
+      runtimeExecutor_, schedulerToolbox.backgroundExecutor, contextContainer_);
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
 
@@ -55,11 +54,12 @@ Scheduler::Scheduler(
                        jsi::Runtime &runtime,
                        const EventTarget *eventTarget,
                        const std::string &type,
+                       ReactEventPriority priority,
                        const ValueFactory &payloadFactory) {
     uiManager->visitBinding(
         [&](UIManagerBinding const &uiManagerBinding) {
           uiManagerBinding.dispatchEvent(
-              runtime, eventTarget, type, payloadFactory);
+              runtime, eventTarget, type, priority, payloadFactory);
         },
         runtime);
   };
@@ -71,8 +71,7 @@ Scheduler::Scheduler(
   // Creating an `EventDispatcher` instance inside the already allocated
   // container (inside the optional).
   eventDispatcher_->emplace(
-      eventPipe,
-      statePipe,
+      EventQueueProcessor(eventPipe, statePipe),
       schedulerToolbox.synchronousEventBeatFactory,
       schedulerToolbox.asynchronousEventBeatFactory,
       eventOwnerBox);
@@ -82,32 +81,22 @@ Scheduler::Scheduler(
       EventDispatcher::Shared{eventDispatcher_, &eventDispatcher_->value()};
 
   componentDescriptorRegistry_ = schedulerToolbox.componentRegistryFactory(
-      eventDispatcher, schedulerToolbox.contextContainer);
+      eventDispatcher, contextContainer_);
 
   uiManager->setDelegate(this);
   uiManager->setComponentDescriptorRegistry(componentDescriptorRegistry_);
 
-#ifdef ANDROID
-  auto enableRuntimeScheduler = reactNativeConfig_->getBool(
-      "react_fabric:enable_runtime_scheduler_android");
-#else
-  auto enableRuntimeScheduler =
-      reactNativeConfig_->getBool("react_fabric:enable_runtime_scheduler_ios");
-#endif
-
-  runtimeExecutor_([=](jsi::Runtime &runtime) {
-    auto uiManagerBinding = UIManagerBinding::createAndInstallIfNeeded(runtime);
+  runtimeExecutor_([uiManager,
+                    runtimeExecutor = runtimeExecutor_](jsi::Runtime &runtime) {
+    auto uiManagerBinding =
+        UIManagerBinding::createAndInstallIfNeeded(runtime, runtimeExecutor);
     uiManagerBinding->attach(uiManager);
-    if (enableRuntimeScheduler) {
-      RuntimeSchedulerBinding::createAndInstallIfNeeded(
-          runtime, runtimeExecutor_);
-    }
   });
 
   auto componentDescriptorRegistryKey =
       "ComponentDescriptorRegistry_DO_NOT_USE_PRETTY_PLEASE";
-  schedulerToolbox.contextContainer->erase(componentDescriptorRegistryKey);
-  schedulerToolbox.contextContainer->insert(
+  contextContainer_->erase(componentDescriptorRegistryKey);
+  contextContainer_->insert(
       componentDescriptorRegistryKey,
       std::weak_ptr<ComponentDescriptorRegistry const>(
           componentDescriptorRegistry_));
@@ -129,19 +118,10 @@ Scheduler::Scheduler(
 #ifdef ANDROID
   removeOutstandingSurfacesOnDestruction_ = reactNativeConfig_->getBool(
       "react_fabric:remove_outstanding_surfaces_on_destruction_android");
-  enableNewDiffer_ = reactNativeConfig_->getBool(
-      "react_fabric:enable_new_differ_h1_2021_android");
-  Constants::setPropsForwardingEnabled(reactNativeConfig_->getBool(
-      "react_fabric:enable_props_forwarding_android"));
 #else
   removeOutstandingSurfacesOnDestruction_ = reactNativeConfig_->getBool(
       "react_fabric:remove_outstanding_surfaces_on_destruction_ios");
-  enableNewDiffer_ =
-      reactNativeConfig_->getBool("react_fabric:enable_new_differ_h1_2021_ios");
 #endif
-
-  uiManager->extractUIManagerBindingOnDemand_ = reactNativeConfig_->getBool(
-      "react_fabric:extract_uimanagerbinding_on_demand");
 }
 
 Scheduler::~Scheduler() {
@@ -202,8 +182,39 @@ Scheduler::~Scheduler() {
 
 void Scheduler::registerSurface(
     SurfaceHandler const &surfaceHandler) const noexcept {
+  surfaceHandler.setContextContainer(getContextContainer());
   surfaceHandler.setUIManager(uiManager_.get());
-  surfaceHandler.setEnableNewDiffer(enableNewDiffer_);
+}
+
+InspectorData Scheduler::getInspectorDataForInstance(
+    SharedEventEmitter eventEmitter) const noexcept {
+  return executeSynchronouslyOnSameThread_CAN_DEADLOCK<InspectorData>(
+      runtimeExecutor_, [=](jsi::Runtime &runtime) -> InspectorData {
+        auto uiManagerBinding = UIManagerBinding::getBinding(runtime);
+        auto value = uiManagerBinding->getInspectorDataForInstance(
+            runtime, eventEmitter);
+
+        // TODO T97216348: avoid transforming jsi into folly::dynamic
+        auto dynamic = jsi::dynamicFromValue(runtime, value);
+        auto source = dynamic["source"];
+
+        InspectorData result = {};
+        result.fileName =
+            source["fileName"].isNull() ? "" : source["fileName"].c_str();
+        result.lineNumber = (int)source["lineNumber"].getDouble();
+        result.columnNumber = (int)source["columnNumber"].getDouble();
+        result.selectedIndex = (int)dynamic["selectedIndex"].getDouble();
+        // TODO T97216348: remove folly::dynamic from InspectorData struct
+        result.props = dynamic["props"];
+        auto hierarchy = dynamic["hierarchy"];
+        for (size_t i = 0; i < hierarchy.size(); i++) {
+          auto viewHierarchyValue = hierarchy[i]["name"];
+          if (!viewHierarchyValue.isNull()) {
+            result.hierarchy.push_back(viewHierarchyValue.c_str());
+          }
+        }
+        return result;
+      });
 }
 
 void Scheduler::unregisterSurface(
@@ -281,14 +292,23 @@ void Scheduler::uiManagerDidFinishTransaction(
     delegate_->schedulerDidFinishTransaction(mountingCoordinator);
   }
 }
-void Scheduler::uiManagerDidCreateShadowNode(
-    const ShadowNode::Shared &shadowNode) {
+void Scheduler::uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) {
   SystraceSection s("Scheduler::uiManagerDidCreateShadowNode");
 
   if (delegate_) {
-    auto shadowView = ShadowView(*shadowNode);
     delegate_->schedulerDidRequestPreliminaryViewAllocation(
-        shadowNode->getSurfaceId(), shadowView);
+        shadowNode.getSurfaceId(), shadowNode);
+  }
+}
+
+void Scheduler::uiManagerDidCloneShadowNode(
+    const ShadowNode &oldShadowNode,
+    const ShadowNode &newShadowNode) {
+  SystraceSection s("Scheduler::uiManagerDidCloneShadowNode");
+
+  if (delegate_) {
+    delegate_->schedulerDidCloneShadowNode(
+        newShadowNode.getSurfaceId(), oldShadowNode, newShadowNode);
   }
 }
 
@@ -328,5 +348,9 @@ void Scheduler::uiManagerDidSetIsJSResponder(
   }
 }
 
+ContextContainer::Shared Scheduler::getContextContainer() const {
+  return contextContainer_;
+}
+
 } // namespace react
 } // namespace facebook