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

package/ReactCommon/react/renderer/mounting/ShadowTree.cpp

@@ -178,7 +178,7 @@ static void updateMountedFlag(
     return;
   }
 
-  int index;
+  size_t index;
 
   // Stage 1: Mount and unmount "updated" children.
   for (index = 0; index < oldChildren.size() && index < newChildren.size();
@@ -202,7 +202,7 @@ static void updateMountedFlag(
     updateMountedFlag(oldChild->getChildren(), newChild->getChildren());
   }
 
-  int lastIndexAfterFirstStage = index;
+  size_t lastIndexAfterFirstStage = index;
 
   // State 2: Mount new children.
   for (index = lastIndexAfterFirstStage; index < newChildren.size(); index++) {
@@ -224,7 +224,7 @@ ShadowTree::ShadowTree(
     LayoutConstraints const &layoutConstraints,
     LayoutContext const &layoutContext,
     ShadowTreeDelegate const &delegate,
-    bool enableNewDiffer)
+    ContextContainer const &contextContainer)
     : surfaceId_(surfaceId), delegate_(delegate) {
   const auto noopEventEmitter = std::make_shared<const ViewEventEmitter>(
       nullptr, -1, std::shared_ptr<const EventDispatcher>());
@@ -235,7 +235,10 @@ ShadowTree::ShadowTree(
               EventDispatcher::Shared{}, nullptr, nullptr});
 
   const auto props = std::make_shared<const RootProps>(
-      *RootShadowNode::defaultSharedProps(), layoutConstraints, layoutContext);
+      PropsParserContext{surfaceId, contextContainer},
+      *RootShadowNode::defaultSharedProps(),
+      layoutConstraints,
+      layoutContext);
 
   auto const fragment =
       ShadowNodeFamilyFragment{surfaceId, surfaceId, noopEventEmitter};
@@ -253,7 +256,6 @@ ShadowTree::ShadowTree(
 
   mountingCoordinator_ =
       std::make_shared<MountingCoordinator const>(currentRevision_);
-  mountingCoordinator_->setEnableNewDiffer(enableNewDiffer);
 }
 
 ShadowTree::~ShadowTree() {

package/ReactCommon/react/renderer/mounting/ShadowTree.h

@@ -18,6 +18,7 @@
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowTreeDelegate.h>
 #include <react/renderer/mounting/ShadowTreeRevision.h>
+#include <react/utils/ContextContainer.h>
 #include "MountingOverrideDelegate.h"
 
 namespace facebook {
@@ -71,7 +72,7 @@ class ShadowTree final {
       LayoutConstraints const &layoutConstraints,
       LayoutContext const &layoutContext,
       ShadowTreeDelegate const &delegate,
-      bool enableNewDiffer);
+      ContextContainer const &contextContainer);
 
   ~ShadowTree();
 

package/ReactCommon/react/renderer/mounting/ShadowView.cpp

@@ -25,6 +25,7 @@ ShadowView::ShadowView(const ShadowNode &shadowNode)
       componentHandle(shadowNode.getComponentHandle()),
       surfaceId(shadowNode.getSurfaceId()),
       tag(shadowNode.getTag()),
+      traits(shadowNode.getTraits()),
       props(shadowNode.getProps()),
       eventEmitter(shadowNode.getEventEmitter()),
       layoutMetrics(layoutMetricsFromShadowNode(shadowNode)),
@@ -65,6 +66,7 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
   return {
       {"surfaceId", getDebugDescription(object.surfaceId, options)},
       {"tag", getDebugDescription(object.tag, options)},
+      {"traits", getDebugDescription(object.traits, options)},
       {"componentName", object.componentName},
       {"props", getDebugDescription(object.props, options)},
       {"eventEmitter", getDebugDescription(object.eventEmitter, options)},

package/ReactCommon/react/renderer/mounting/ShadowView.h

@@ -43,6 +43,7 @@ struct ShadowView final {
   ComponentHandle componentHandle{};
   SurfaceId surfaceId{};
   Tag tag{};
+  ShadowNodeTraits traits{};
   Props::Shared props{};
   EventEmitter::Shared eventEmitter{};
   LayoutMetrics layoutMetrics{EmptyLayoutMetrics};

package/ReactCommon/react/renderer/mounting/ShadowViewMutation.cpp

@@ -84,6 +84,18 @@ bool ShadowViewMutation::mutatedViewIsVirtual() const {
   return viewIsVirtual;
 }
 
+ShadowViewMutation::ShadowViewMutation(
+    Type type,
+    ShadowView parentShadowView,
+    ShadowView oldChildShadowView,
+    ShadowView newChildShadowView,
+    int index)
+    : type(type),
+      parentShadowView(parentShadowView),
+      oldChildShadowView(oldChildShadowView),
+      newChildShadowView(newChildShadowView),
+      index(index) {}
+
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(ShadowViewMutation const &mutation) {

package/ReactCommon/react/renderer/mounting/ShadowViewMutation.h

@@ -23,6 +23,8 @@ namespace react {
 struct ShadowViewMutation final {
   using List = std::vector<ShadowViewMutation>;
 
+  ShadowViewMutation() = delete;
+
 #pragma mark - Designated Initializers
 
   /*
@@ -70,13 +72,20 @@ struct ShadowViewMutation final {
   ShadowView newChildShadowView = {};
   int index = -1;
 
- public:
   // Some platforms can have the notion of virtual views - views that are in the
   // ShadowTree hierarchy but never are on the platform. Generally this is used
   // so notify the platform that a view exists so that we can keep EventEmitters
   // around, to notify JS of something. This mechanism is DEPRECATED and it is
   // highly recommended that you NOT make use of this in your platform!
   bool mutatedViewIsVirtual() const;
+
+ private:
+  ShadowViewMutation(
+      Type type,
+      ShadowView parentShadowView,
+      ShadowView oldChildShadowView,
+      ShadowView newChildShadowView,
+      int index);
 };
 
 using ShadowViewMutationList = std::vector<ShadowViewMutation>;

package/ReactCommon/react/renderer/mounting/StubViewTree.cpp

@@ -117,7 +117,9 @@ void StubViewTree::mutate(ShadowViewMutationList const &mutations) {
           });
           react_native_assert(childStubView->parentTag == NO_VIEW_TAG);
           react_native_assert(
-              parentStubView->children.size() >= mutation.index);
+              mutation.index >= 0 &&
+              parentStubView->children.size() >=
+                  static_cast<size_t>(mutation.index));
           childStubView->parentTag = parentTag;
           parentStubView->children.insert(
               parentStubView->children.begin() + mutation.index, childStubView);
@@ -147,7 +149,10 @@ void StubViewTree::mutate(ShadowViewMutationList const &mutations) {
                        << parentTag << "] @" << mutation.index << " with "
                        << parentStubView->children.size() << " children";
           });
-          react_native_assert(parentStubView->children.size() > mutation.index);
+          react_native_assert(
+              mutation.index >= 0 &&
+              parentStubView->children.size() >
+                  static_cast<size_t>(mutation.index));
           react_native_assert(registry.find(childTag) != registry.end());
           auto childStubView = registry[childTag];
           if ((ShadowView)(*childStubView) != mutation.oldChildShadowView) {
@@ -183,7 +188,9 @@ void StubViewTree::mutate(ShadowViewMutationList const &mutations) {
                        << ": " << strChildList;
           });
           react_native_assert(
-              parentStubView->children.size() > mutation.index &&
+              mutation.index >= 0 &&
+              parentStubView->children.size() >
+                  static_cast<size_t>(mutation.index) &&
               parentStubView->children[mutation.index]->tag ==
                   childStubView->tag);
           childStubView->parentTag = NO_VIEW_TAG;

package/ReactCommon/react/renderer/mounting/TelemetryController.cpp

@@ -30,7 +30,7 @@ bool TelemetryController::pullTransaction(
   auto surfaceId = transaction.getSurfaceId();
   auto number = transaction.getNumber();
   auto telemetry = transaction.getTelemetry();
-  auto numberOfMutations = transaction.getMutations().size();
+  auto numberOfMutations = static_cast<int>(transaction.getMutations().size());
 
   mutex_.lock();
   auto compoundTelemetry = compoundTelemetry_;

package/ReactCommon/react/renderer/mounting/stubs.cpp

@@ -47,13 +47,13 @@ static void calculateShadowViewMutationsForNewTree(
   // Sorting pairs based on `orderIndex` if needed.
   reorderInPlaceIfNeeded(newChildPairs);
 
-  for (auto index = 0; index < newChildPairs.size(); index++) {
+  for (size_t index = 0; index < newChildPairs.size(); index++) {
     auto const &newChildPair = newChildPairs[index];
 
     mutations.push_back(
         ShadowViewMutation::CreateMutation(newChildPair.shadowView));
     mutations.push_back(ShadowViewMutation::InsertMutation(
-        parentShadowView, newChildPair.shadowView, index));
+        parentShadowView, newChildPair.shadowView, static_cast<int>(index)));
 
     auto newGrandChildPairs =
         sliceChildShadowNodeViewPairsLegacy(*newChildPair.shadowNode);
@@ -89,7 +89,7 @@ StubViewTree buildStubViewTreeUsingDifferentiator(
       ShadowNode::emptySharedShadowNodeSharedList()});
 
   auto mutations =
-      calculateShadowViewMutations(*emptyRootShadowNode, rootShadowNode, true);
+      calculateShadowViewMutations(*emptyRootShadowNode, rootShadowNode);
 
   auto stubViewTree = StubViewTree(ShadowView(*emptyRootShadowNode));
   stubViewTree.mutate(mutations);

package/ReactCommon/react/renderer/mounting/tests/MountingTest.cpp

@@ -9,6 +9,7 @@
 
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/stubs.h>
 
@@ -31,8 +32,12 @@ static SharedViewProps nonFlattenedDefaultProps(
   dynamic["nativeId"] = "NativeId";
   dynamic["accessible"] = true;
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   return std::static_pointer_cast<ViewProps const>(
-      componentDescriptor.cloneProps(nullptr, RawProps{dynamic}));
+      componentDescriptor.cloneProps(
+          parserContext, nullptr, RawProps{dynamic}));
 }
 
 static ShadowNode::Shared makeNode(
@@ -78,8 +83,11 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
               ShadowNodeFragment{RootShadowNode::defaultSharedProps()},
               rootFamily)));
 
+  PropsParserContext parserContext{-1, *contextContainer};
+
   // Applying size constraints.
   emptyRootNode = emptyRootNode->clone(
+      parserContext,
       LayoutConstraints{
           Size{512, 0}, Size{512, std::numeric_limits<Float>::infinity()}},
       LayoutContext{});
@@ -242,8 +250,7 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
     }*/
 
   // Calculating mutations.
-  auto mutations1 =
-      calculateShadowViewMutations(*rootNodeV1, *rootNodeV2, true);
+  auto mutations1 = calculateShadowViewMutations(*rootNodeV1, *rootNodeV2);
 
   // The order and exact mutation instructions here may change at any time.
   // This test just ensures that any changes are intentional.
@@ -259,8 +266,7 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   EXPECT_TRUE(mutations1[1].index == 0);
 
   // Calculating mutations.
-  auto mutations2 =
-      calculateShadowViewMutations(*rootNodeV2, *rootNodeV3, true);
+  auto mutations2 = calculateShadowViewMutations(*rootNodeV2, *rootNodeV3);
 
   // The order and exact mutation instructions here may change at any time.
   // This test just ensures that any changes are intentional.
@@ -276,8 +282,7 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   EXPECT_TRUE(mutations2[1].oldChildShadowView.tag == 100);
 
   // Calculating mutations.
-  auto mutations3 =
-      calculateShadowViewMutations(*rootNodeV3, *rootNodeV4, true);
+  auto mutations3 = calculateShadowViewMutations(*rootNodeV3, *rootNodeV4);
   LOG(ERROR) << "Num mutations IN OLD TEST mutations3: " << mutations3.size();
 
   // The order and exact mutation instructions here may change at any time.
@@ -299,8 +304,7 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   EXPECT_TRUE(mutations3[3].index == 2);
 
   // Calculating mutations.
-  auto mutations4 =
-      calculateShadowViewMutations(*rootNodeV4, *rootNodeV5, true);
+  auto mutations4 = calculateShadowViewMutations(*rootNodeV4, *rootNodeV5);
 
   // The order and exact mutation instructions here may change at any time.
   // This test just ensures that any changes are intentional.
@@ -325,8 +329,7 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   EXPECT_TRUE(mutations4[5].newChildShadowView.tag == 102);
   EXPECT_TRUE(mutations4[5].index == 3);
 
-  auto mutations5 =
-      calculateShadowViewMutations(*rootNodeV5, *rootNodeV6, true);
+  auto mutations5 = calculateShadowViewMutations(*rootNodeV5, *rootNodeV6);
 
   // The order and exact mutation instructions here may change at any time.
   // This test just ensures that any changes are intentional.
@@ -345,8 +348,7 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   EXPECT_TRUE(mutations5[3].newChildShadowView.tag == 105);
   EXPECT_TRUE(mutations5[3].index == 3);
 
-  auto mutations6 =
-      calculateShadowViewMutations(*rootNodeV6, *rootNodeV7, true);
+  auto mutations6 = calculateShadowViewMutations(*rootNodeV6, *rootNodeV7);
 
   // The order and exact mutation instructions here may change at any time.
   // This test just ensures that any changes are intentional.
@@ -389,8 +391,11 @@ TEST(MountingTest, testViewReparentingInstructionGeneration) {
               ShadowNodeFragment{RootShadowNode::defaultSharedProps()},
               rootFamily)));
 
+  PropsParserContext parserContext{-1, *contextContainer};
+
   // Applying size constraints.
   emptyRootNode = emptyRootNode->clone(
+      parserContext,
       LayoutConstraints{
           Size{512, 0}, Size{512, std::numeric_limits<Float>::infinity()}},
       LayoutContext{});
@@ -600,8 +605,7 @@ TEST(MountingTest, testViewReparentingInstructionGeneration) {
   rootNodeV5->sealRecursive();
 
   // Calculating mutations.
-  auto mutations1 =
-      calculateShadowViewMutations(*rootNodeV1, *rootNodeV2, true);
+  auto mutations1 = calculateShadowViewMutations(*rootNodeV1, *rootNodeV2);
 
   EXPECT_EQ(mutations1.size(), 5);
   EXPECT_EQ(mutations1[0].type, ShadowViewMutation::Update);
@@ -615,8 +619,7 @@ TEST(MountingTest, testViewReparentingInstructionGeneration) {
   EXPECT_EQ(mutations1[4].type, ShadowViewMutation::Insert);
   EXPECT_EQ(mutations1[4].newChildShadowView.tag, 1000);
 
-  auto mutations2 =
-      calculateShadowViewMutations(*rootNodeV2, *rootNodeV3, true);
+  auto mutations2 = calculateShadowViewMutations(*rootNodeV2, *rootNodeV3);
 
   EXPECT_EQ(mutations2.size(), 5);
   EXPECT_EQ(mutations2[0].type, ShadowViewMutation::Update);
@@ -632,8 +635,7 @@ TEST(MountingTest, testViewReparentingInstructionGeneration) {
   EXPECT_EQ(mutations2[4].type, ShadowViewMutation::Insert);
   EXPECT_EQ(mutations2[4].newChildShadowView.tag, 1000);
 
-  auto mutations3 =
-      calculateShadowViewMutations(*rootNodeV3, *rootNodeV4, true);
+  auto mutations3 = calculateShadowViewMutations(*rootNodeV3, *rootNodeV4);
 
   // between these two trees, lots of new nodes are created and inserted - this
   // is all correct, and this is the minimal amount of mutations
@@ -670,8 +672,7 @@ TEST(MountingTest, testViewReparentingInstructionGeneration) {
   EXPECT_EQ(mutations3[14].type, ShadowViewMutation::Insert);
   EXPECT_EQ(mutations3[14].newChildShadowView.tag, 1000);
 
-  auto mutations4 =
-      calculateShadowViewMutations(*rootNodeV4, *rootNodeV5, true);
+  auto mutations4 = calculateShadowViewMutations(*rootNodeV4, *rootNodeV5);
 
   EXPECT_EQ(mutations4.size(), 9);
   EXPECT_EQ(mutations4[0].type, ShadowViewMutation::Update);

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeLifeCycleTest.cpp

@@ -12,10 +12,11 @@
 
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
-#include <react/renderer/mounting/stubs.h>
 
+#include <react/renderer/mounting/stubs.h>
 #include <react/test_utils/Entropy.h>
 #include <react/test_utils/shadowTreeGeneration.h>
 
@@ -44,6 +45,8 @@ static void testShadowNodeTreeLifeCycle(
   auto noopEventEmitter =
       std::make_shared<ViewEventEmitter const>(nullptr, -1, eventDispatcher);
 
+  PropsParserContext parserContext{-1, *contextContainer};
+
   auto allNodes = std::vector<ShadowNode::Shared>{};
 
   for (int i = 0; i < repeats; i++) {
@@ -61,6 +64,7 @@ static void testShadowNodeTreeLifeCycle(
 
     // Applying size constraints.
     emptyRootNode = emptyRootNode->clone(
+        parserContext,
         LayoutConstraints{
             Size{512, 0}, Size{512, std::numeric_limits<Float>::infinity()}},
         LayoutContext{});
@@ -79,7 +83,7 @@ static void testShadowNodeTreeLifeCycle(
     // Building an initial view hierarchy.
     auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*emptyRootNode);
     viewTree.mutate(
-        calculateShadowViewMutations(*emptyRootNode, *currentRootNode, true));
+        calculateShadowViewMutations(*emptyRootNode, *currentRootNode));
 
     for (int j = 0; j < stages; j++) {
       auto nextRootNode = currentRootNode;
@@ -106,7 +110,7 @@ static void testShadowNodeTreeLifeCycle(
 
       // Calculating mutations.
       auto mutations =
-          calculateShadowViewMutations(*currentRootNode, *nextRootNode, true);
+          calculateShadowViewMutations(*currentRootNode, *nextRootNode);
 
       // Make sure that in a single frame, a DELETE for a
       // view is not followed by a CREATE for the same view.
@@ -191,6 +195,8 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
   auto noopEventEmitter =
       std::make_shared<ViewEventEmitter const>(nullptr, -1, eventDispatcher);
 
+  PropsParserContext parserContext{-1, *contextContainer};
+
   auto allNodes = std::vector<ShadowNode::Shared>{};
 
   for (int i = 0; i < repeats; i++) {
@@ -208,6 +214,7 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
 
     // Applying size constraints.
     emptyRootNode = emptyRootNode->clone(
+        parserContext,
         LayoutConstraints{
             Size{512, 0}, Size{512, std::numeric_limits<Float>::infinity()}},
         LayoutContext{});
@@ -226,7 +233,7 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
     // Building an initial view hierarchy.
     auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*emptyRootNode);
     viewTree.mutate(
-        calculateShadowViewMutations(*emptyRootNode, *currentRootNode, true));
+        calculateShadowViewMutations(*emptyRootNode, *currentRootNode));
 
     for (int j = 0; j < stages; j++) {
       auto nextRootNode = currentRootNode;
@@ -254,7 +261,7 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
 
       // Calculating mutations.
       auto mutations =
-          calculateShadowViewMutations(*currentRootNode, *nextRootNode, true);
+          calculateShadowViewMutations(*currentRootNode, *nextRootNode);
 
       // Make sure that in a single frame, a DELETE for a
       // view is not followed by a CREATE for the same view.

package/ReactCommon/react/renderer/mounting/tests/StackingContextTest.cpp

@@ -171,8 +171,8 @@ class StackingContextTest : public ::testing::Test {
     callback(buildStubViewTreeUsingDifferentiator(*rootShadowNode_));
     callback(buildStubViewTreeWithoutUsingDifferentiator(*rootShadowNode_));
 
-    auto mutations = calculateShadowViewMutations(
-        *currentRootShadowNode_, *rootShadowNode_, true);
+    auto mutations =
+        calculateShadowViewMutations(*currentRootShadowNode_, *rootShadowNode_);
     currentRootShadowNode_ = rootShadowNode_;
     currentStubViewTree_.mutate(mutations);
     callback(currentStubViewTree_);

package/ReactCommon/react/renderer/mounting/tests/StateReconciliationTest.cpp

@@ -11,14 +11,15 @@
 
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/element/ComponentBuilder.h>
 #include <react/renderer/element/Element.h>
-#include <react/renderer/element/testUtils.h>
-
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowTree.h>
 #include <react/renderer/mounting/ShadowTreeDelegate.h>
 
+#include <react/renderer/element/testUtils.h>
+
 using namespace facebook::react;
 
 class DummyShadowTreeDelegate : public ShadowTreeDelegate {
@@ -89,6 +90,8 @@ TEST(StateReconciliationTest, testStateReconciliation) {
         });
   // clang-format on
 
+  ContextContainer contextContainer{};
+
   auto shadowNode = builder.build(element);
 
   auto rootShadowNodeState1 = shadowNode->ShadowNode::clone({});
@@ -102,7 +105,7 @@ TEST(StateReconciliationTest, testStateReconciliation) {
       LayoutConstraints{},
       LayoutContext{},
       shadowTreeDelegate,
-      true};
+      contextContainer};
 
   shadowTree.commit(
       [&](RootShadowNode const &oldRootShadowNode) {

package/ReactCommon/react/renderer/runtimescheduler/Android.mk

@@ -15,7 +15,7 @@ LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
 
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../
 
-LOCAL_SHARED_LIBRARIES := libruntimeexecutor libreact_render_core
+LOCAL_SHARED_LIBRARIES := libruntimeexecutor libreact_render_core libreact_debug libjsi callinvoker
 
 LOCAL_CFLAGS := \
   -DLOG_TAG=\"Fabric\"
@@ -25,3 +25,4 @@ LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
 include $(BUILD_SHARED_LIBRARY)
 
 $(call import-module,runtimeexecutor)
+$(call import-module,callinvoker)

package/ReactCommon/react/renderer/runtimescheduler/BUCK

@@ -53,6 +53,7 @@ rn_xplat_cxx_library(
         react_native_xplat_target("runtimeexecutor:runtimeexecutor"),
         react_native_xplat_target("react/renderer/debug:debug"),
         react_native_xplat_target("better:better"),
+        react_native_xplat_target("callinvoker:callinvoker"),
     ],
 )
 

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

@@ -7,16 +7,33 @@
 
 #include "RuntimeScheduler.h"
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
-RuntimeScheduler::RuntimeScheduler(RuntimeExecutor const &runtimeExecutor)
-    : RuntimeScheduler(runtimeExecutor, RuntimeSchedulerClock::now) {}
+#pragma mark - Public
 
 RuntimeScheduler::RuntimeScheduler(
     RuntimeExecutor const &runtimeExecutor,
     std::function<RuntimeSchedulerTimePoint()> now)
     : runtimeExecutor_(runtimeExecutor), now_(now) {}
 
+void RuntimeScheduler::scheduleWork(
+    std::function<void(jsi::Runtime &)> callback) const {
+  if (enableYielding_) {
+    shouldYield_ = true;
+    runtimeExecutor_(
+        [this, callback = std::move(callback)](jsi::Runtime &runtime) {
+          shouldYield_ = false;
+          callback(runtime);
+          startWorkLoop(runtime);
+        });
+  } else {
+    runtimeExecutor_([callback = std::move(callback)](jsi::Runtime &runtime) {
+      callback(runtime);
+    });
+  }
+}
+
 std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
     SchedulerPriority priority,
     jsi::Function callback) {
@@ -25,52 +42,77 @@ std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
       std::make_shared<Task>(priority, std::move(callback), expirationTime);
   taskQueue_.push(task);
 
-  if (!isCallbackScheduled_) {
+  if (!isCallbackScheduled_ && !isPerformingWork_) {
     isCallbackScheduled_ = true;
     runtimeExecutor_([this](jsi::Runtime &runtime) {
       isCallbackScheduled_ = false;
-      auto previousPriority = currentPriority_;
-      while (!taskQueue_.empty()) {
-        auto topPriorityTask = taskQueue_.top();
-        auto now = now_();
-        auto didUserCallbackTimeout = topPriorityTask->expirationTime <= now;
-
-        if (!didUserCallbackTimeout && shouldYield_) {
-          // This task hasn't expired and we need to yield.
-          break;
-        }
-        currentPriority_ = topPriorityTask->priority;
-        auto result = topPriorityTask->execute(runtime);
-
-        if (result.isObject() &&
-            result.getObject(runtime).isFunction(runtime)) {
-          topPriorityTask->callback =
-              result.getObject(runtime).getFunction(runtime);
-        } else {
-          taskQueue_.pop();
-        }
-      }
-      currentPriority_ = previousPriority;
+      startWorkLoop(runtime);
     });
   }
 
   return task;
 }
 
-void RuntimeScheduler::cancelTask(const std::shared_ptr<Task> &task) {
-  task->callback.reset();
+bool RuntimeScheduler::getShouldYield() const noexcept {
+  return shouldYield_;
 }
 
-bool RuntimeScheduler::getShouldYield() const {
-  return shouldYield_;
+void RuntimeScheduler::cancelTask(const std::shared_ptr<Task> &task) noexcept {
+  task->callback.reset();
 }
 
-SchedulerPriority RuntimeScheduler::getCurrentPriorityLevel() const {
+SchedulerPriority RuntimeScheduler::getCurrentPriorityLevel() const noexcept {
   return currentPriority_;
 }
 
-RuntimeSchedulerTimePoint RuntimeScheduler::now() const {
+RuntimeSchedulerTimePoint RuntimeScheduler::now() const noexcept {
   return now_();
 }
 
-} // namespace facebook::react
+void RuntimeScheduler::setEnableYielding(bool enableYielding) {
+  enableYielding_ = enableYielding;
+}
+
+void RuntimeScheduler::executeNowOnTheSameThread(
+    std::function<void(jsi::Runtime &runtime)> callback) const {
+  shouldYield_ = true;
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+      runtimeExecutor_,
+      [callback = std::move(callback)](jsi::Runtime &runtime) {
+        callback(runtime);
+      });
+  shouldYield_ = false;
+}
+
+#pragma mark - Private
+
+void RuntimeScheduler::startWorkLoop(jsi::Runtime &runtime) const {
+  auto previousPriority = currentPriority_;
+  isPerformingWork_ = true;
+  while (!taskQueue_.empty()) {
+    auto topPriorityTask = taskQueue_.top();
+    auto now = now_();
+    auto didUserCallbackTimeout = topPriorityTask->expirationTime <= now;
+
+    if (!didUserCallbackTimeout && shouldYield_) {
+      // This task hasn't expired and we need to yield.
+      break;
+    }
+    currentPriority_ = topPriorityTask->priority;
+    auto result = topPriorityTask->execute(runtime);
+
+    if (result.isObject() && result.getObject(runtime).isFunction(runtime)) {
+      topPriorityTask->callback =
+          result.getObject(runtime).getFunction(runtime);
+    } else {
+      if (taskQueue_.top() == topPriorityTask) {
+        taskQueue_.pop();
+      }
+    }
+  }
+  currentPriority_ = previousPriority;
+  isPerformingWork_ = false;
+}
+
+} // namespace react
+} // namespace facebook