react-native 0.0.0-16bb2ae4f → 0.0.0-18697adec

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -14,7 +14,8 @@
 #include <memory>
 #include <queue>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 class RuntimeScheduler final {
  public:
@@ -93,6 +94,12 @@ class RuntimeScheduler final {
    * Default value is false
    */
   bool enableYielding_{false};
+
+  /*
+   * This flag is set while performing work, to prevent re-entrancy.
+   */
+  mutable bool isPerformingWork_{false};
 };
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp

@@ -13,7 +13,8 @@
 #include <chrono>
 #include <memory>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 std::shared_ptr<RuntimeSchedulerBinding>
 RuntimeSchedulerBinding::createAndInstallIfNeeded(
@@ -166,4 +167,5 @@ jsi::Value RuntimeSchedulerBinding::get(
   return jsi::Value::undefined();
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.h

@@ -10,7 +10,8 @@
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 /*
  * Exposes RuntimeScheduler to JavaScript realm.
@@ -39,4 +40,5 @@ class RuntimeSchedulerBinding : public jsi::HostObject {
   std::shared_ptr<RuntimeScheduler> runtimeScheduler_;
 };
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "RuntimeSchedulerCallInvoker.h"
+
+namespace facebook::react {
+
+RuntimeSchedulerCallInvoker::RuntimeSchedulerCallInvoker(
+    std::weak_ptr<RuntimeScheduler> runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
+
+void RuntimeSchedulerCallInvoker::invokeAsync(std::function<void()> &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->scheduleWork(
+        [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
+void RuntimeSchedulerCallInvoker::invokeSync(std::function<void()> &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->executeNowOnTheSameThread(
+        [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <ReactCommon/CallInvoker.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace facebook::react {
+
+/*
+ * Exposes RuntimeScheduler to native modules. All calls invonked on JavaScript
+ * queue from native modules will be funneled through RuntimeScheduler.
+ */
+class RuntimeSchedulerCallInvoker : public CallInvoker {
+ public:
+  RuntimeSchedulerCallInvoker(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
+
+  void invokeAsync(std::function<void()> &&func) override;
+  void invokeSync(std::function<void()> &&func) override;
+
+ private:
+  /*
+   * RuntimeScheduler is retained by the runtime. It must not be
+   * retained by anything beyond the runtime.
+   */
+  std::weak_ptr<RuntimeScheduler> runtimeScheduler_;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerClock.h

@@ -9,7 +9,8 @@
 
 #include <chrono>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 /*
  * Represents a monotonic clock suitable for measuring intervals.
@@ -19,4 +20,5 @@ using RuntimeSchedulerClock = std::chrono::steady_clock;
 using RuntimeSchedulerTimePoint = RuntimeSchedulerClock::time_point;
 using RuntimeSchedulerDuration = RuntimeSchedulerClock::duration;
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/SchedulerPriority.h

@@ -10,7 +10,8 @@
 #include <react/debug/react_native_assert.h>
 #include <chrono>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 enum class SchedulerPriority : int {
   ImmediatePriority = 1,
@@ -60,4 +61,5 @@ static inline std::chrono::milliseconds timeoutForSchedulerPriority(
   }
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/Task.cpp

@@ -7,7 +7,8 @@
 
 #include "RuntimeScheduler.h"
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 Task::Task(
     SchedulerPriority priority,
@@ -17,15 +18,20 @@ Task::Task(
       callback(std::move(callback)),
       expirationTime(expirationTime) {}
 
-jsi::Value Task::execute(jsi::Runtime &runtime) const {
+jsi::Value Task::execute(jsi::Runtime &runtime) {
+  auto result = jsi::Value::undefined();
   // Cancelled task doesn't have a callback.
   if (callback) {
     // Callback in JavaScript is expecting a single bool parameter.
     // React team plans to remove it and it is safe to pass in
     // hardcoded false value.
-    return callback.value().call(runtime, {false});
+    result = callback.value().call(runtime, {false});
+
+    // Destroying callback to prevent calling it twice.
+    callback.reset();
   }
-  return jsi::Value::undefined();
+  return result;
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/Task.h

@@ -12,7 +12,8 @@
 #include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
 #include <react/renderer/runtimescheduler/SchedulerPriority.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 class RuntimeScheduler;
 class TaskPriorityComparer;
@@ -31,7 +32,7 @@ struct Task final {
   better::optional<jsi::Function> callback;
   RuntimeSchedulerClock::time_point expirationTime;
 
-  jsi::Value execute(jsi::Runtime &runtime) const;
+  jsi::Value execute(jsi::Runtime &runtime);
 };
 
 class TaskPriorityComparer {
@@ -43,4 +44,5 @@ class TaskPriorityComparer {
   }
 };
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/primitives.h

@@ -11,7 +11,8 @@
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/Task.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 struct TaskWrapper : public jsi::HostObject {
   TaskWrapper(std::shared_ptr<Task> const &task) : task(task) {}
@@ -36,4 +37,5 @@ inline static std::shared_ptr<Task> taskFromValue(
   return value.getObject(runtime).getHostObject<TaskWrapper>(runtime)->task;
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -435,4 +435,38 @@ TEST_F(RuntimeSchedulerTest, immediateTaskDoesntYieldToPlatformEvent) {
   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/{core/Constants.h → scheduler/InspectorData.h}

@@ -5,18 +5,19 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#pragma once
+#include <vector>
 
 namespace facebook {
 namespace react {
 
-struct Constants {
-  /*
-      Flag controling props forwarding when shadow node is cloned on Android.
-      Has no effect on iOS.
-  */
-  static void setPropsForwardingEnabled(bool propsForwardingEnabled);
-  static bool getPropsForwardingEnabled();
+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

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

@@ -12,7 +12,6 @@
 
 #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>
@@ -36,17 +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);
+      runtimeExecutor_, schedulerToolbox.backgroundExecutor, contextContainer_);
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
 
@@ -68,54 +68,35 @@ Scheduler::Scheduler(
     uiManager->updateState(stateUpdate);
   };
 
-#ifdef ANDROID
-  auto unbatchedQueuesOnly =
-      reactNativeConfig_->getBool("react_fabric:unbatched_queues_only_android");
-#else
-  auto unbatchedQueuesOnly =
-      reactNativeConfig_->getBool("react_fabric:unbatched_queues_only_ios");
-#endif
-
   // Creating an `EventDispatcher` instance inside the already allocated
   // container (inside the optional).
   eventDispatcher_->emplace(
       EventQueueProcessor(eventPipe, statePipe),
       schedulerToolbox.synchronousEventBeatFactory,
       schedulerToolbox.asynchronousEventBeatFactory,
-      eventOwnerBox,
-      unbatchedQueuesOnly);
+      eventOwnerBox);
 
   // Casting to `std::shared_ptr<EventDispatcher const>`.
   auto eventDispatcher =
       EventDispatcher::Shared{eventDispatcher_, &eventDispatcher_->value()};
 
   componentDescriptorRegistry_ = schedulerToolbox.componentRegistryFactory(
-      eventDispatcher, schedulerToolbox.contextContainer);
+      eventDispatcher, contextContainer_);
 
   uiManager->setDelegate(this);
   uiManager->setComponentDescriptorRegistry(componentDescriptorRegistry_);
 
-#ifdef ANDROID
-  auto asyncMeasure =
-      reactNativeConfig_->getBool("react_fabric:enable_async_measure_android");
-#else
-  auto asyncMeasure =
-      reactNativeConfig_->getBool("react_fabric:enable_async_measure_ios");
-#endif
-
   runtimeExecutor_([uiManager,
-                    asyncMeasure,
                     runtimeExecutor = runtimeExecutor_](jsi::Runtime &runtime) {
     auto uiManagerBinding =
         UIManagerBinding::createAndInstallIfNeeded(runtime, runtimeExecutor);
     uiManagerBinding->attach(uiManager);
-    uiManagerBinding->setEnableAsyncMeasure(asyncMeasure);
   });
 
   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_));
@@ -137,8 +118,6 @@ Scheduler::Scheduler(
 #ifdef ANDROID
   removeOutstandingSurfacesOnDestruction_ = reactNativeConfig_->getBool(
       "react_fabric:remove_outstanding_surfaces_on_destruction_android");
-  Constants::setPropsForwardingEnabled(reactNativeConfig_->getBool(
-      "react_fabric:enable_props_forwarding_android"));
 #else
   removeOutstandingSurfacesOnDestruction_ = reactNativeConfig_->getBool(
       "react_fabric:remove_outstanding_surfaces_on_destruction_ios");
@@ -203,9 +182,41 @@ Scheduler::~Scheduler() {
 
 void Scheduler::registerSurface(
     SurfaceHandler const &surfaceHandler) const noexcept {
+  surfaceHandler.setContextContainer(getContextContainer());
   surfaceHandler.setUIManager(uiManager_.get());
 }
 
+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(
     SurfaceHandler const &surfaceHandler) const noexcept {
   surfaceHandler.setUIManager(nullptr);
@@ -337,5 +348,9 @@ void Scheduler::uiManagerDidSetIsJSResponder(
   }
 }
 
+ContextContainer::Shared Scheduler::getContextContainer() const {
+  return contextContainer_;
+}
+
 } // namespace react
 } // namespace facebook

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

@@ -15,8 +15,10 @@
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/core/EventEmitter.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/scheduler/InspectorData.h>
 #include <react/renderer/scheduler/SchedulerDelegate.h>
 #include <react/renderer/scheduler/SchedulerToolbox.h>
 #include <react/renderer/scheduler/SurfaceHandler.h>
@@ -49,6 +51,9 @@ class Scheduler final : public UIManagerDelegate {
   void registerSurface(SurfaceHandler const &surfaceHandler) const noexcept;
   void unregisterSurface(SurfaceHandler const &surfaceHandler) const noexcept;
 
+  InspectorData getInspectorDataForInstance(
+      SharedEventEmitter eventEmitter) const noexcept;
+
   void renderTemplateToSurface(
       SurfaceId surfaceId,
       const std::string &uiTemplate);
@@ -99,6 +104,9 @@ class Scheduler final : public UIManagerDelegate {
       bool isJSResponder,
       bool blockNativeResponder) override;
 
+#pragma mark - ContextContainer
+  ContextContainer::Shared getContextContainer() const;
+
  private:
   friend class SurfaceHandler;
 
@@ -119,6 +127,12 @@ class Scheduler final : public UIManagerDelegate {
    */
   std::shared_ptr<better::optional<EventDispatcher const>> eventDispatcher_;
 
+  /**
+   * Hold onto ContextContainer. See SchedulerToolbox.
+   * Must not be nullptr.
+   */
+  ContextContainer::Shared contextContainer_;
+
   /*
    * Temporary flags.
    */

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

@@ -8,6 +8,7 @@
 #include "SurfaceHandler.h"
 
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/uimanager/UIManager.h>
 
@@ -42,49 +43,58 @@ SurfaceHandler &SurfaceHandler::operator=(SurfaceHandler &&other) noexcept {
 
   other.link_ = Link{};
   other.parameters_ = Parameters{};
+  other.parameters_.contextContainer = parameters_.contextContainer;
   return *this;
 }
 
 #pragma mark - Surface Life-Cycle Management
 
+void SurfaceHandler::setContextContainer(
+    ContextContainer::Shared contextContainer) const noexcept {
+  parameters_.contextContainer = contextContainer;
+}
+
 Status SurfaceHandler::getStatus() const noexcept {
   std::shared_lock<better::shared_mutex> lock(linkMutex_);
   return link_.status;
 }
 
 void SurfaceHandler::start() const noexcept {
-  {
-    std::unique_lock<better::shared_mutex> lock(linkMutex_);
-    react_native_assert(
-        link_.status == Status::Registered && "Surface must be registered.");
-    react_native_assert(
-        getLayoutConstraints().layoutDirection != LayoutDirection::Undefined &&
-        "layoutDirection must be set.");
+  SystraceSection s("SurfaceHandler::start");
+  std::unique_lock<better::shared_mutex> lock(linkMutex_);
+  react_native_assert(
+      link_.status == Status::Registered && "Surface must be registered.");
+  react_native_assert(
+      getLayoutConstraints().layoutDirection != LayoutDirection::Undefined &&
+      "layoutDirection must be set.");
+  react_native_assert(
+      parameters_.contextContainer && "ContextContainer must be set.");
 
-    auto parameters = Parameters{};
-    {
-      std::shared_lock<better::shared_mutex> parametersLock(parametersMutex_);
-      parameters = parameters_;
-    }
+  auto parameters = Parameters{};
+  {
+    SystraceSection s2("SurfaceHandler::start::paramsLock");
+    std::shared_lock<better::shared_mutex> parametersLock(parametersMutex_);
+    parameters = parameters_;
+  }
 
-    auto shadowTree = std::make_unique<ShadowTree>(
-        parameters.surfaceId,
-        parameters.layoutConstraints,
-        parameters.layoutContext,
-        *link_.uiManager);
+  auto shadowTree = std::make_unique<ShadowTree>(
+      parameters.surfaceId,
+      parameters.layoutConstraints,
+      parameters.layoutContext,
+      *link_.uiManager,
+      *parameters.contextContainer);
 
-    link_.shadowTree = shadowTree.get();
+  link_.shadowTree = shadowTree.get();
 
-    link_.uiManager->startSurface(
-        std::move(shadowTree),
-        parameters.moduleName,
-        parameters.props,
-        parameters_.displayMode);
+  link_.uiManager->startSurface(
+      std::move(shadowTree),
+      parameters.moduleName,
+      parameters.props,
+      parameters_.displayMode);
 
-    link_.status = Status::Running;
+  link_.status = Status::Running;
 
-    applyDisplayMode(parameters.displayMode);
-  }
+  applyDisplayMode(parameters.displayMode);
 }
 
 void SurfaceHandler::stop() const noexcept {
@@ -156,6 +166,7 @@ std::string SurfaceHandler::getModuleName() const noexcept {
 }
 
 void SurfaceHandler::setProps(folly::dynamic const &props) const noexcept {
+  SystraceSection s("SurfaceHandler::setProps");
   std::unique_lock<better::shared_mutex> lock(parametersMutex_);
   parameters_.props = props;
 }
@@ -192,8 +203,11 @@ Size SurfaceHandler::measure(
   auto currentRootShadowNode =
       link_.shadowTree->getCurrentRevision().rootShadowNode;
 
-  auto rootShadowNode =
-      currentRootShadowNode->clone(layoutConstraints, layoutContext);
+  PropsParserContext propsParserContext{
+      parameters_.surfaceId, *parameters_.contextContainer.get()};
+
+  auto rootShadowNode = currentRootShadowNode->clone(
+      propsParserContext, layoutConstraints, layoutContext);
   rootShadowNode->layoutIfNeeded();
   return rootShadowNode->getLayoutMetrics().frame.size;
 }
@@ -201,6 +215,7 @@ Size SurfaceHandler::measure(
 void SurfaceHandler::constraintLayout(
     LayoutConstraints const &layoutConstraints,
     LayoutContext const &layoutContext) const noexcept {
+  SystraceSection s("SurfaceHandler::constraintLayout");
   {
     std::unique_lock<better::shared_mutex> lock(parametersMutex_);
 
@@ -220,10 +235,14 @@ void SurfaceHandler::constraintLayout(
       return;
     }
 
+    PropsParserContext propsParserContext{
+        parameters_.surfaceId, *parameters_.contextContainer.get()};
+
     react_native_assert(
         link_.shadowTree && "`link_.shadowTree` must not be null.");
     link_.shadowTree->commit([&](RootShadowNode const &oldRootShadowNode) {
-      return oldRootShadowNode.clone(layoutConstraints, layoutContext);
+      return oldRootShadowNode.clone(
+          propsParserContext, layoutConstraints, layoutContext);
     });
   }
 }
@@ -241,6 +260,7 @@ LayoutContext SurfaceHandler::getLayoutContext() const noexcept {
 #pragma mark - Private
 
 void SurfaceHandler::applyDisplayMode(DisplayMode displayMode) const noexcept {
+  SystraceSection s("SurfaceHandler::applyDisplayMode");
   react_native_assert(
       link_.status == Status::Running && "Surface must be running.");
   react_native_assert(