@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

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

@@ -6,6 +6,9 @@
  */
 
 #include "RuntimeScheduler_Legacy.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
 #include "SchedulerPriorityUtils.h"
 
 #include <ReactCommon/RuntimeExecutorSyncUIThreadUtils.h>
@@ -43,6 +46,14 @@ void RuntimeScheduler_Legacy::scheduleWork(RawCallback&& callback) noexcept {
       });
 }
 
+void RuntimeScheduler_Legacy::scheduleTask(
+    [[maybe_unused]] const std::function<void()>& task) {}
+uint64_t RuntimeScheduler_Legacy::registerTaskQueueSource() {
+  return 0;
+}
+void RuntimeScheduler_Legacy::unregisterTaskQueueSource(
+    [[maybe_unused]] uint64_t sourceId) {}
+
 std::shared_ptr<Task> RuntimeScheduler_Legacy::scheduleTask(
     SchedulerPriority priority,
     jsi::Function&& callback) noexcept {
@@ -282,3 +293,5 @@ void RuntimeScheduler_Legacy::executeTask(
 }
 
 } // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/consistency/ShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
@@ -38,6 +40,11 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
 
   void scheduleWork(RawCallback &&callback) noexcept override;
 
+  /// IEventLoopControl implementation. No-op for legacy scheduler.
+  void scheduleTask(const std::function<void()> &task) override;
+  uint64_t registerTaskQueueSource() override;
+  void unregisterTaskQueueSource(uint64_t sourceId) override;
+
   /*
    * Grants access to the runtime synchronously on the caller's thread.
    *
@@ -172,3 +179,5 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
 };
 
 } // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH

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

@@ -47,6 +47,23 @@ void RuntimeScheduler_Modern::scheduleWork(RawCallback&& callback) noexcept {
   scheduleTask(SchedulerPriority::ImmediatePriority, std::move(callback));
 }
 
+void RuntimeScheduler_Modern::scheduleTask(const std::function<void()>& task) {
+  scheduleIdleTask([task](jsi::Runtime& /*runtime*/) { task(); });
+}
+
+uint64_t RuntimeScheduler_Modern::registerTaskQueueSource() {
+  // It's fine to wrap around, as it's impossible to hold so many live task
+  // queue sources in practice.
+  return nextTaskQueueSourceId_.fetch_add(1) + 1;
+}
+
+void RuntimeScheduler_Modern::unregisterTaskQueueSource(uint64_t /*sourceId*/) {
+  // For now, we don't need to do unregistering. The reason is that the event
+  // loop of the runtime scheduler doesn't need to be blocked on the task
+  // producer of IEventLoopControl. When the event loop ends, we just ignore
+  // all queueing tasks.
+}
+
 std::shared_ptr<Task> RuntimeScheduler_Modern::scheduleTask(
     SchedulerPriority priority,
     jsi::Function&& callback) noexcept {
@@ -361,7 +378,7 @@ void RuntimeScheduler_Modern::updateRendering(HighResTimeStamp taskEndTime) {
 void RuntimeScheduler_Modern::executeTask(
     jsi::Runtime& runtime,
     Task& task,
-    bool didUserCallbackTimeout) const {
+    bool didUserCallbackTimeout) {
   TraceSection s(
       "RuntimeScheduler::executeTask",
       "id",
@@ -380,10 +397,10 @@ void RuntimeScheduler_Modern::executeTask(
       task.callback = result.getObject(runtime).getFunction(runtime);
     }
   } catch (jsi::JSError& error) {
-    onTaskError_(runtime, error);
+    handleTaskError(runtime, error);
   } catch (std::exception& ex) {
     jsi::JSError error(runtime, std::string("Non-js exception: ") + ex.what());
-    onTaskError_(runtime, error);
+    handleTaskError(runtime, error);
   }
 }
 
@@ -419,11 +436,11 @@ void RuntimeScheduler_Modern::performMicrotaskCheckpoint(
         break;
       }
     } catch (jsi::JSError& error) {
-      onTaskError_(runtime, error);
+      handleTaskError(runtime, error);
     } catch (std::exception& ex) {
       jsi::JSError error(
           runtime, std::string("Non-js exception: ") + ex.what());
-      onTaskError_(runtime, error);
+      handleTaskError(runtime, error);
     }
     retries++;
   }
@@ -449,6 +466,27 @@ void RuntimeScheduler_Modern::reportLongTasks(
   }
 }
 
+void RuntimeScheduler_Modern::handleTaskError(
+    jsi::Runtime& runtime,
+    jsi::JSError& error) {
+  if (ReactNativeFeatureFlags::enableRuntimeSchedulerQueueClearingOnError()) {
+    clearQueues();
+  }
+
+  onTaskError_(runtime, error);
+}
+
+void RuntimeScheduler_Modern::clearQueues() {
+  {
+    std::unique_lock lock(schedulingMutex_);
+    taskQueue_ = {};
+    isEventLoopScheduled_ = false;
+  }
+
+  pendingRenderingUpdates_ = {};
+  surfaceIdsWithPendingRenderingUpdates_.clear();
+}
+
 void RuntimeScheduler_Modern::markYieldingOpportunity(
     HighResTimeStamp currentTime) {
   auto currentPeriod = currentTime - lastYieldingOpportunity_;

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

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

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

@@ -17,7 +17,9 @@
 
 namespace facebook::react {
 
+#ifndef RCT_REMOVE_LEGACY_ARCH
 class RuntimeScheduler_Legacy;
+#endif
 class RuntimeScheduler_Modern;
 class TaskPriorityComparer;
 
@@ -29,7 +31,9 @@ struct Task final : public jsi::NativeState {
   Task(SchedulerPriority priority, RawCallback &&callback, HighResTimeStamp expirationTime);
 
  private:
+#ifndef RCT_REMOVE_LEGACY_ARCH
   friend RuntimeScheduler_Legacy;
+#endif
   friend RuntimeScheduler_Modern;
   friend TaskPriorityComparer;
 

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

@@ -7,6 +7,7 @@
 
 #include <gtest/gtest.h>
 #include <hermes/hermes.h>
+#include <jsi/hermes-interfaces.h>
 #include <jsi/jsi.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
@@ -26,20 +27,27 @@ namespace facebook::react {
 
 using namespace std::chrono_literals;
 
-static bool forcedBatchRenderingUpdatesInEventLoop = false;
-
 class RuntimeSchedulerTestFeatureFlags
     : public ReactNativeFeatureFlagsDefaults {
  public:
-  explicit RuntimeSchedulerTestFeatureFlags(bool enableEventLoop)
-      : enableEventLoop_(enableEventLoop) {}
+  explicit RuntimeSchedulerTestFeatureFlags(
+      bool enableEventLoop,
+      bool enableRuntimeSchedulerQueueClearingOnError = false)
+      : enableEventLoop_(enableEventLoop),
+        enableRuntimeSchedulerQueueClearingOnError_(
+            enableRuntimeSchedulerQueueClearingOnError) {}
 
   bool enableBridgelessArchitecture() override {
     return enableEventLoop_;
   }
 
+  bool enableRuntimeSchedulerQueueClearingOnError() override {
+    return enableRuntimeSchedulerQueueClearingOnError_;
+  }
+
  private:
   bool enableEventLoop_;
+  bool enableRuntimeSchedulerQueueClearingOnError_;
 };
 
 class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
@@ -47,8 +55,7 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
   void SetUp() override {
     hostFunctionCallCount_ = 0;
 
-    ReactNativeFeatureFlags::override(
-        std::make_unique<RuntimeSchedulerTestFeatureFlags>(GetParam()));
+    setUpFeatureFlags();
 
     // Configuration that enables microtasks
     ::hermes::vm::RuntimeConfig::Builder runtimeConfigBuilder =
@@ -86,6 +93,14 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
     ReactNativeFeatureFlags::dangerouslyReset();
   }
 
+  void setUpFeatureFlags(
+      bool enableRuntimeSchedulerQueueClearingOnError = false) {
+    ReactNativeFeatureFlags::dangerouslyReset();
+    ReactNativeFeatureFlags::override(
+        std::make_unique<RuntimeSchedulerTestFeatureFlags>(
+            GetParam(), enableRuntimeSchedulerQueueClearingOnError));
+  }
+
   jsi::Function createHostFunctionFromLambda(
       std::function<jsi::Value(bool)> callback) {
     return jsi::Function::createFromHostFunction(
@@ -156,6 +171,31 @@ TEST_P(RuntimeSchedulerTest, scheduleSingleTask) {
   EXPECT_EQ(stubQueue_->size(), 0);
 }
 
+TEST_P(RuntimeSchedulerTest, scheduleTaskViaEventLoopControl) {
+  // The RuntimeScheduler proxy is what gets registered with Hermes as an
+  // IEventLoopControl. scheduleTask() forwards to the selected fork, which
+  // schedules the work as an idle task.
+  facebook::hermes::IEventLoopControl& eventLoopControl = *runtimeScheduler_;
+
+  bool didRunTask = false;
+  eventLoopControl.scheduleTask([&didRunTask]() { didRunTask = true; });
+
+  if (GetParam()) {
+    // Modern scheduler: the task is queued on the event loop and runs on tick.
+    EXPECT_FALSE(didRunTask);
+    EXPECT_EQ(stubQueue_->size(), 1);
+
+    stubQueue_->tick();
+
+    EXPECT_TRUE(didRunTask);
+    EXPECT_EQ(stubQueue_->size(), 0);
+  } else {
+    // Legacy scheduler: idle tasks are not supported, so this is a no-op.
+    EXPECT_FALSE(didRunTask);
+    EXPECT_EQ(stubQueue_->size(), 0);
+  }
+}
+
 TEST_P(
     RuntimeSchedulerTest,
     scheduleSingleTaskWithMicrotasksAndBatchedRenderingUpdate) {
@@ -164,8 +204,6 @@ TEST_P(
     return;
   }
 
-  forcedBatchRenderingUpdatesInEventLoop = true;
-
   uint nextOperationPosition = 1;
 
   uint taskPosition = 0;
@@ -877,6 +915,46 @@ TEST_P(RuntimeSchedulerTest, handlingError) {
   EXPECT_EQ(stubErrorUtils_->getReportFatalCallCount(), 1);
 }
 
+TEST_P(RuntimeSchedulerTest, clearsQueuesOnError) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  setUpFeatureFlags(/*enableRuntimeSchedulerQueueClearingOnError=*/true);
+
+  bool didRunThrowingTask = false;
+  bool didRunQueuedTask = false;
+  bool didRunRenderingUpdate = false;
+
+  auto throwingCallback =
+      createHostFunctionFromLambda([&](bool /*unused*/) -> jsi::Value {
+        didRunThrowingTask = true;
+        runtimeScheduler_->scheduleRenderingUpdate(
+            0, [&]() { didRunRenderingUpdate = true; });
+        throw jsi::JSError(*runtime_, "Test error");
+      });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::ImmediatePriority, std::move(throwingCallback));
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::LowPriority,
+      [&](jsi::Runtime& /*runtime*/) { didRunQueuedTask = true; });
+
+  EXPECT_FALSE(didRunThrowingTask);
+  EXPECT_FALSE(didRunQueuedTask);
+  EXPECT_FALSE(didRunRenderingUpdate);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunThrowingTask);
+  EXPECT_FALSE(didRunQueuedTask);
+  EXPECT_FALSE(didRunRenderingUpdate);
+  EXPECT_EQ(stubQueue_->size(), 0);
+  EXPECT_EQ(stubErrorUtils_->getReportFatalCallCount(), 1);
+}
+
 TEST_P(RuntimeSchedulerTest, basicSameThreadExecution) {
   bool didRunSynchronousTask = false;
   std::thread t1([this, &didRunSynchronousTask]() {
@@ -899,6 +977,29 @@ TEST_P(RuntimeSchedulerTest, basicSameThreadExecution) {
   EXPECT_TRUE(didRunSynchronousTask);
 }
 
+// Mirror of `basicSameThreadExecution` for the production call pattern: the
+// caller is the UI thread (XCTest test methods run on the main NSThread on
+// Apple), so `executeNowOnTheSameThread` routes through the coordinator path
+// in `executeSynchronouslyOnSameThread_CAN_DEADLOCK`. The off-main `driver`
+// thread drives the stub queue ("JS thread") so the main thread can wake up.
+TEST_P(RuntimeSchedulerTest, basicUIThreadExecution) {
+  bool didRunSynchronousTask = false;
+
+  std::thread driver([this]() {
+    stubQueue_->waitForTask();
+    stubQueue_->tick();
+  });
+
+  runtimeScheduler_->executeNowOnTheSameThread(
+      [&didRunSynchronousTask](jsi::Runtime& /*rt*/) {
+        didRunSynchronousTask = true;
+      });
+
+  driver.join();
+
+  EXPECT_TRUE(didRunSynchronousTask);
+}
+
 TEST_P(RuntimeSchedulerTest, sameThreadTaskCreatesImmediatePriorityTask) {
   bool didRunSynchronousTask = false;
   bool didRunSubsequentTask = false;
@@ -1356,6 +1457,10 @@ TEST_P(RuntimeSchedulerTest, reportsLongTasksWithYielding) {
 INSTANTIATE_TEST_SUITE_P(
     UseModernRuntimeScheduler,
     RuntimeSchedulerTest,
+#ifdef RCT_REMOVE_LEGACY_ARCH
+    testing::Values(true));
+#else
     testing::Values(false, true));
+#endif
 
 } // namespace facebook::react

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

@@ -22,6 +22,7 @@
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
+#include <mutex>
 
 namespace facebook::react {
 
@@ -295,6 +296,9 @@ SchedulerDelegate* Scheduler::getDelegate() const {
 #pragma mark - UIManagerAnimationDelegate
 
 void Scheduler::animationTick() const {
+  if (!uiManager_) {
+    return;
+  }
   uiManager_->animationTick();
 }
 
@@ -456,9 +460,13 @@ void Scheduler::uiManagerDidPromoteReactRevision(const ShadowTree& shadowTree) {
 }
 
 void Scheduler::uiManagerDidStartSurface(const ShadowTree& shadowTree) {
-  std::shared_lock lock(onSurfaceStartCallbackMutex_);
-  if (onSurfaceStartCallback_) {
-    onSurfaceStartCallback_(shadowTree);
+  std::vector<OnSurfaceStartCallback> callbacks;
+  {
+    std::shared_lock lock(onSurfaceStartCallbackMutex_);
+    callbacks = onSurfaceStartCallbacks_;
+  }
+  for (const auto& callback : callbacks) {
+    callback(shadowTree);
   }
 }
 
@@ -488,10 +496,10 @@ void Scheduler::removeEventListener(
   }
 }
 
-void Scheduler::uiManagerShouldSetOnSurfaceStartCallback(
+void Scheduler::uiManagerShouldAddOnSurfaceStartCallback(
     OnSurfaceStartCallback&& callback) {
-  std::shared_lock lock(onSurfaceStartCallbackMutex_);
-  onSurfaceStartCallback_ = std::move(callback);
+  std::unique_lock lock(onSurfaceStartCallbackMutex_);
+  onSurfaceStartCallbacks_.push_back(std::move(callback));
 }
 
 } // namespace facebook::react

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

@@ -9,6 +9,7 @@
 
 #include <atomic>
 #include <memory>
+#include <vector>
 
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/performance/cdpmetrics/CdpMetricsReporter.h>
@@ -117,7 +118,7 @@ class Scheduler final : public UIManagerDelegate {
   void removeEventListener(const std::shared_ptr<const EventListener> &listener);
 
 #pragma mark - Surface start callback
-  void uiManagerShouldSetOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) override;
+  void uiManagerShouldAddOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) override;
 
  private:
   friend class SurfaceHandler;
@@ -159,7 +160,7 @@ class Scheduler final : public UIManagerDelegate {
   std::shared_ptr<ViewTransitionModule> viewTransitionModule_;
 
   mutable std::shared_mutex onSurfaceStartCallbackMutex_;
-  OnSurfaceStartCallback onSurfaceStartCallback_;
+  std::vector<OnSurfaceStartCallback> onSurfaceStartCallbacks_;
 };
 
 } // namespace facebook::react

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

@@ -9,7 +9,6 @@
 
 #include <cxxreact/TraceSection.h>
 #include <react/debug/react_native_assert.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/uimanager/UIManager.h>
 
 namespace facebook::react {
@@ -213,78 +212,6 @@ Size SurfaceHandler::measure(
   return rootShadowNode->getLayoutMetrics().frame.size;
 }
 
-std::shared_ptr<const ShadowNode> SurfaceHandler::dirtyMeasurableNodesRecursive(
-    std::shared_ptr<const ShadowNode> node) const {
-  const auto nodeHasChildren = !node->getChildren().empty();
-  const auto isMeasurableYogaNode =
-      node->getTraits().check(ShadowNodeTraits::Trait::MeasurableYogaNode);
-
-  // Node is not measurable and has no children, its layout will not be affected
-  if (!nodeHasChildren && !isMeasurableYogaNode) {
-    return nullptr;
-  }
-
-  std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>
-      newChildren = ShadowNodeFragment::childrenPlaceholder();
-
-  if (nodeHasChildren) {
-    std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>>
-        newChildrenMutable = nullptr;
-    for (size_t i = 0; i < node->getChildren().size(); i++) {
-      const auto& child = node->getChildren()[i];
-
-      if (const auto& layoutableNode =
-              std::dynamic_pointer_cast<const YogaLayoutableShadowNode>(
-                  child)) {
-        auto newChild = dirtyMeasurableNodesRecursive(layoutableNode);
-
-        if (newChild != nullptr) {
-          if (newChildrenMutable == nullptr) {
-            newChildrenMutable = std::make_shared<
-                std::vector<std::shared_ptr<const ShadowNode>>>(
-                node->getChildren());
-            newChildren = newChildrenMutable;
-          }
-
-          (*newChildrenMutable)[i] = newChild;
-        }
-      }
-    }
-
-    // Node is not measurable and its children were not dirtied, its layout will
-    // not be affected
-    if (!isMeasurableYogaNode && newChildrenMutable == nullptr) {
-      return nullptr;
-    }
-  }
-
-  const auto newNode = node->getComponentDescriptor().cloneShadowNode(
-      *node,
-      {
-          .children = newChildren,
-          // Preserve the original state of the node
-          .state = node->getState(),
-      });
-
-  if (isMeasurableYogaNode) {
-    std::static_pointer_cast<YogaLayoutableShadowNode>(newNode)->dirtyLayout();
-  }
-
-  return newNode;
-}
-
-void SurfaceHandler::dirtyMeasurableNodes(ShadowNode& root) const {
-  for (const auto& child : root.getChildren()) {
-    if (const auto& layoutableNode =
-            std::dynamic_pointer_cast<const YogaLayoutableShadowNode>(child)) {
-      const auto newChild = dirtyMeasurableNodesRecursive(layoutableNode);
-      if (newChild != nullptr) {
-        root.replaceChild(*child, newChild);
-      }
-    }
-  }
-}
-
 void SurfaceHandler::constraintLayout(
     const LayoutConstraints& layoutConstraints,
     const LayoutContext& layoutContext) const {
@@ -315,19 +242,8 @@ void SurfaceHandler::constraintLayout(
         link_.shadowTree && "`link_.shadowTree` must not be null.");
     link_.shadowTree->commit(
         [&](const RootShadowNode& oldRootShadowNode) {
-          auto newRoot = oldRootShadowNode.clone(
+          return oldRootShadowNode.clone(
               propsParserContext, layoutConstraints, layoutContext);
-
-          // Dirty all measurable nodes when the fontSizeMultiplier changes to
-          // trigger re-measurement.
-          if (ReactNativeFeatureFlags::enableFontScaleChangesUpdatingLayout() &&
-              layoutContext.fontSizeMultiplier !=
-                  oldRootShadowNode.getConcreteProps()
-                      .layoutContext.fontSizeMultiplier) {
-            dirtyMeasurableNodes(*newRoot);
-          }
-
-          return newRoot;
         },
         {/* default commit options */});
   }

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

@@ -151,12 +151,6 @@ class SurfaceHandler {
 
   void applyDisplayMode(DisplayMode displayMode) const;
 
-  /*
-   * An utility for dirtying all measurable shadow nodes present in the tree.
-   */
-  void dirtyMeasurableNodes(ShadowNode &root) const;
-  std::shared_ptr<const ShadowNode> dirtyMeasurableNodesRecursive(std::shared_ptr<const ShadowNode> node) const;
-
 #pragma mark - Link & Parameters
 
   /*