react-native 0.0.0-263478b91 → 0.0.0-268efb102

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_runtimescheduler_android");
-#else
-  auto enableRuntimeScheduler =
-      reactNativeConfig_->getBool("react_fabric:enable_runtimescheduler_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,15 +118,9 @@ 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
 }
 
@@ -199,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(
@@ -278,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);
   }
 }
 
@@ -325,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);
@@ -83,8 +88,10 @@ class Scheduler final : public UIManagerDelegate {
 
   void uiManagerDidFinishTransaction(
       MountingCoordinator::Shared const &mountingCoordinator) override;
-  void uiManagerDidCreateShadowNode(
-      const ShadowNode::Shared &shadowNode) override;
+  void uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) override;
+  void uiManagerDidCloneShadowNode(
+      const ShadowNode &oldShadowNode,
+      const ShadowNode &newShadowNode) override;
   void uiManagerDidDispatchCommand(
       const ShadowNode::Shared &shadowNode,
       std::string const &commandName,
@@ -97,6 +104,9 @@ class Scheduler final : public UIManagerDelegate {
       bool isJSResponder,
       bool blockNativeResponder) override;
 
+#pragma mark - ContextContainer
+  ContextContainer::Shared getContextContainer() const;
+
  private:
   friend class SurfaceHandler;
 
@@ -117,11 +127,16 @@ 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.
    */
   bool removeOutstandingSurfacesOnDestruction_{false};
-  bool enableNewDiffer_{false};
 };
 
 } // namespace react

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

@@ -34,7 +34,15 @@ class SchedulerDelegate {
    */
   virtual void schedulerDidRequestPreliminaryViewAllocation(
       SurfaceId surfaceId,
-      const ShadowView &shadowView) = 0;
+      const ShadowNode &shadowView) = 0;
+
+  /*
+   * Called right after a ShadowNode is cloned.
+   */
+  virtual void schedulerDidCloneShadowNode(
+      SurfaceId surfaceId,
+      const ShadowNode &oldShadowNode,
+      const ShadowNode &newShadowNode) = 0;
 
   virtual void schedulerDidDispatchCommand(
       const ShadowView &shadowView,

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

@@ -13,6 +13,7 @@
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/EventBeat.h>
 #include <react/renderer/leakchecker/LeakChecker.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <react/renderer/uimanager/UIManagerCommitHook.h>
 #include <react/renderer/uimanager/primitives.h>
 #include <react/utils/ContextContainer.h>
@@ -65,12 +66,6 @@ struct SchedulerToolbox final {
    */
   BackgroundExecutor backgroundExecutor;
 
-  /*
-   * Triggers garbage collection. Used when checking if all Fabric's HostObjects
-   * have been properly cleaned up from JavaScript.
-   */
-  GarbageCollectionTrigger garbageCollectionTrigger;
-
   /*
    * A list of `UIManagerCommitHook`s that should be registered in `UIManager`.
    */

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,50 +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,
-        enableNewDiffer_);
+  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 {
@@ -139,11 +148,6 @@ DisplayMode SurfaceHandler::getDisplayMode() const noexcept {
   return parameters_.displayMode;
 }
 
-#pragma mark - Feature Flags
-void SurfaceHandler::setEnableNewDiffer(bool enabled) const noexcept {
-  enableNewDiffer_ = enabled;
-}
-
 #pragma mark - Accessors
 
 SurfaceId SurfaceHandler::getSurfaceId() const noexcept {
@@ -162,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;
 }
@@ -198,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;
 }
@@ -207,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_);
 
@@ -226,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);
     });
   }
 }
@@ -247,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(

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

@@ -12,6 +12,7 @@
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/ReactPrimitives.h>
+#include <react/utils/ContextContainer.h>
 
 namespace facebook {
 namespace react {
@@ -33,7 +34,7 @@ class UIManager;
  * ensure the logical consistency of some methods (e.g. calling `stop` for
  * non-running surface will crash).
  */
-class SurfaceHandler final {
+class SurfaceHandler {
  public:
   /*
    * Represents a status of the `SurfaceHandler` instance.
@@ -61,7 +62,7 @@ class SurfaceHandler final {
    * Can be constructed anytime with a `moduleName` and a `surfaceId`.
    */
   SurfaceHandler(std::string const &moduleName, SurfaceId surfaceId) noexcept;
-  ~SurfaceHandler() noexcept;
+  virtual ~SurfaceHandler() noexcept;
 
   /*
    * Movable-only.
@@ -73,6 +74,12 @@ class SurfaceHandler final {
 
 #pragma mark - Surface Life-Cycle Management
 
+  /*
+   * Must be called before surface is started.
+   */
+  void setContextContainer(
+      ContextContainer::Shared contextContainer) const noexcept;
+
   /*
    * Returns a momentum value of the status.
    */
@@ -88,10 +95,10 @@ class SurfaceHandler final {
   void stop() const noexcept;
 
   /*
-   * Sets (and gets) the runnnig mode.
+   * Sets (and gets) the running mode.
    * The running mode can be changed anytime (even for `Unregistered` surface).
    */
-  void setDisplayMode(DisplayMode displayMode) const noexcept;
+  virtual void setDisplayMode(DisplayMode displayMode) const noexcept;
   DisplayMode getDisplayMode() const noexcept;
 
 #pragma mark - Accessors
@@ -138,9 +145,6 @@ class SurfaceHandler final {
   LayoutConstraints getLayoutConstraints() const noexcept;
   LayoutContext getLayoutContext() const noexcept;
 
-#pragma mark - Feature Flags
-  void setEnableNewDiffer(bool enabled) const noexcept;
-
  private:
   friend class Scheduler;
 
@@ -174,6 +178,7 @@ class SurfaceHandler final {
     folly::dynamic props{};
     LayoutConstraints layoutConstraints{};
     LayoutContext layoutContext{};
+    ContextContainer::Shared contextContainer{};
   };
 
   /*
@@ -198,11 +203,6 @@ class SurfaceHandler final {
    */
   mutable better::shared_mutex parametersMutex_;
   mutable Parameters parameters_;
-
-  /**
-   * Feature flags.
-   */
-  mutable bool enableNewDiffer_{false};
 };
 
 } // namespace react

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

@@ -24,6 +24,7 @@ void SurfaceManager::startSurface(
   {
     std::unique_lock<better::shared_mutex> lock(mutex_);
     auto surfaceHandler = SurfaceHandler{moduleName, surfaceId};
+    surfaceHandler.setContextContainer(scheduler_.getContextContainer());
     registry_.emplace(surfaceId, std::move(surfaceHandler));
   }
 

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

@@ -14,10 +14,12 @@ namespace react {
 
 SynchronousEventBeat::SynchronousEventBeat(
     RunLoopObserver::Unique uiRunLoopObserver,
-    RuntimeExecutor runtimeExecutor)
+    RuntimeExecutor runtimeExecutor,
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler)
     : EventBeat({}),
       uiRunLoopObserver_(std::move(uiRunLoopObserver)),
-      runtimeExecutor_(std::move(runtimeExecutor)) {
+      runtimeExecutor_(std::move(runtimeExecutor)),
+      runtimeScheduler_(runtimeScheduler) {
   uiRunLoopObserver_->setDelegate(this);
   uiRunLoopObserver_->enable();
 }
@@ -44,8 +46,13 @@ void SynchronousEventBeat::lockExecutorAndBeat() const {
     return;
   }
 
-  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
-      runtimeExecutor_, [this](jsi::Runtime &runtime) { beat(runtime); });
+  if (runtimeScheduler_) {
+    runtimeScheduler_->executeNowOnTheSameThread(
+        [this](jsi::Runtime &runtime) { beat(runtime); });
+  } else {
+    executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+        runtimeExecutor_, [this](jsi::Runtime &runtime) { beat(runtime); });
+  }
 }
 
 } // namespace react

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

@@ -9,6 +9,7 @@
 
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/core/EventBeat.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <react/utils/RunLoopObserver.h>
 
 namespace facebook {
@@ -23,7 +24,8 @@ class SynchronousEventBeat final : public EventBeat,
  public:
   SynchronousEventBeat(
       RunLoopObserver::Unique uiRunLoopObserver,
-      RuntimeExecutor runtimeExecutor);
+      RuntimeExecutor runtimeExecutor,
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
 
   void induce() const override;
 
@@ -38,6 +40,7 @@ class SynchronousEventBeat final : public EventBeat,
 
   RunLoopObserver::Unique uiRunLoopObserver_;
   RuntimeExecutor runtimeExecutor_;
+  std::shared_ptr<RuntimeScheduler> runtimeScheduler_;
 };
 
 } // namespace react

package/ReactCommon/react/renderer/templateprocessor/UITemplateProcessor.cpp

@@ -44,14 +44,14 @@ SharedShadowNode UITemplateProcessor::runCommand(
   const int tagOffset = 420000;
   // TODO: change to integer codes and a switch statement
   if (opcode == "createNode") {
-    int tag = command[1].asInt();
+    Tag tag = static_cast<Tag>(command[1].asInt());
     const auto &type = command[2].asString();
     const auto parentTag = command[3].asInt();
     const auto &props = command[4];
     nodes[tag] = componentDescriptorRegistry.createNode(
         tag + tagOffset, type, surfaceId, props, nullptr);
     if (parentTag > -1) { // parentTag == -1 indicates root node
-      auto parentShadowNode = nodes[parentTag];
+      auto parentShadowNode = nodes[static_cast<size_t>(parentTag)];
       auto const &componentDescriptor = componentDescriptorRegistry.at(
           parentShadowNode->getComponentHandle());
       componentDescriptor.appendChild(parentShadowNode, nodes[tag]);
@@ -61,13 +61,13 @@ SharedShadowNode UITemplateProcessor::runCommand(
       LOG(INFO)
           << "(stop) UITemplateProcessor inject serialized 'server rendered' view tree";
     }
-    return nodes[command[1].asInt()];
+    return nodes[static_cast<Tag>(command[1].asInt())];
   } else if (opcode == "loadNativeBool") {
-    int registerNumber = command[1].asInt();
+    auto registerNumber = static_cast<size_t>(command[1].asInt());
     std::string param = command[4][0].asString();
     registers[registerNumber] = reactNativeConfig->getBool(param);
   } else if (opcode == "conditional") {
-    int registerNumber = command[1].asInt();
+    auto registerNumber = static_cast<size_t>(command[1].asInt());
     auto conditionDynamic = registers[registerNumber];
     if (conditionDynamic.isNull()) {
       // TODO: provide original command or command line?

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/RCTAttributedTextUtils.h

@@ -35,6 +35,8 @@ NSAttributedString *RCTNSAttributedStringFromAttributedStringBox(
 facebook::react::AttributedStringBox RCTAttributedStringBoxFromNSAttributedString(
     NSAttributedString *nsAttributedString);
 
+NSString *RCTNSStringFromStringApplyingTextTransform(NSString *string, facebook::react::TextTransform textTransform);
+
 @interface RCTWeakEventEmitterWrapper : NSObject
 @property (nonatomic, assign) facebook::react::SharedEventEmitter eventEmitter;
 @end

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/RCTAttributedTextUtils.mm

@@ -288,6 +288,9 @@ NSDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttributes(T
       case AccessibilityRole::Tab:
         attributes[RCTTextAttributesAccessibilityRoleAttributeName] = @("tab");
         break;
+      case AccessibilityRole::TabBar:
+        attributes[RCTTextAttributesAccessibilityRoleAttributeName] = @("tabbar");
+        break;
       case AccessibilityRole::Tablist:
         attributes[RCTTextAttributesAccessibilityRoleAttributeName] = @("tablist");
         break;
@@ -332,6 +335,11 @@ NSAttributedString *RCTNSAttributedStringFromAttributedString(const AttributedSt
     } else {
       NSString *string = [NSString stringWithCString:fragment.string.c_str() encoding:NSUTF8StringEncoding];
 
+      if (fragment.textAttributes.textTransform.hasValue()) {
+        auto textTransform = fragment.textAttributes.textTransform.value();
+        string = RCTNSStringFromStringApplyingTextTransform(string, textTransform);
+      }
+
       nsAttributedStringFragment = [[NSMutableAttributedString alloc]
           initWithString:string
               attributes:RCTNSTextAttributesFromTextAttributes(fragment.textAttributes)];
@@ -370,3 +378,17 @@ AttributedStringBox RCTAttributedStringBoxFromNSAttributedString(NSAttributedStr
 {
   return nsAttributedString.length ? AttributedStringBox{wrapManagedObject(nsAttributedString)} : AttributedStringBox{};
 }
+
+NSString *RCTNSStringFromStringApplyingTextTransform(NSString *string, TextTransform textTransform)
+{
+  switch (textTransform) {
+    case TextTransform::Uppercase:
+      return [string uppercaseString];
+    case TextTransform::Lowercase:
+      return [string lowercaseString];
+    case TextTransform::Capitalize:
+      return [string capitalizedString];
+    default:
+      return string;
+  }
+}