react-native-tvos 0.81.3-0 → 0.82.0-0

package/ReactCommon/react/renderer/uimanager/tests/PointerEventsProcessorTest.cpp

@@ -36,8 +36,6 @@ static inline void listenToAllPointerEvents(ViewProps& props) {
 class PointerEventsProcessorTest : public ::testing::Test {
  public:
   PointerEventsProcessorTest() {
-    surfaceId_ = 0;
-
     auto contextContainer = std::make_shared<ContextContainer>();
 
     ComponentDescriptorProviderRegistry componentDescriptorProviderRegistry{};
@@ -180,7 +178,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
         *uiManager_,
         *contextContainer);
     shadowTree->commit(
-        [this](const RootShadowNode& oldRootShadowNode) {
+        [this](const RootShadowNode& /*oldRootShadowNode*/) {
           return std::static_pointer_cast<RootShadowNode>(this->rootNode_);
         },
         {true});
@@ -199,13 +197,13 @@ class PointerEventsProcessorTest : public ::testing::Test {
 
   EventLog dispatchPointerEvent(
       const std::shared_ptr<const ShadowNode>& target,
-      std::string eventName,
-      PointerEvent eventPayload) {
+      const std::string& eventName,
+      const PointerEvent& eventPayload) {
     EventLog eventLog;
     auto dispatchCallback = [&eventLog](
                                 const ShadowNode& targetNode,
                                 const std::string& type,
-                                ReactEventPriority priority,
+                                ReactEventPriority /*priority*/,
                                 const EventPayload& eventPayload) {
       eventLog.push_back({
           .tag = targetNode.getTag(),
@@ -223,7 +221,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
     return eventLog;
   }
 
-  SurfaceId surfaceId_;
+  SurfaceId surfaceId_{0};
 
   std::shared_ptr<RootShadowNode> rootNode_;
   std::shared_ptr<ViewShadowNode> nodeA_;

package/ReactCommon/react/runtime/BridgelessNativeMethodCallInvoker.cpp

@@ -14,13 +14,13 @@ BridgelessNativeMethodCallInvoker::BridgelessNativeMethodCallInvoker(
     : messageQueueThread_(std::move(messageQueueThread)) {}
 
 void BridgelessNativeMethodCallInvoker::invokeAsync(
-    const std::string& methodName,
+    const std::string& /*methodName*/,
     NativeMethodCallFunc&& func) noexcept {
   messageQueueThread_->runOnQueue(std::move(func));
 }
 
 void BridgelessNativeMethodCallInvoker::invokeSync(
-    const std::string& methodName,
+    const std::string& /*methodName*/,
     NativeMethodCallFunc&& func) {
   messageQueueThread_->runOnQueueSync(std::move(func));
 }

package/ReactCommon/react/runtime/BufferedRuntimeExecutor.cpp

@@ -7,13 +7,11 @@
 
 #include "BufferedRuntimeExecutor.h"
 
-#include <algorithm>
-
 namespace facebook::react {
 
 BufferedRuntimeExecutor::BufferedRuntimeExecutor(
     RuntimeExecutor runtimeExecutor)
-    : runtimeExecutor_(runtimeExecutor),
+    : runtimeExecutor_(std::move(runtimeExecutor)),
       isBufferingEnabled_(true),
       lastIndex_(0) {}
 
@@ -49,9 +47,9 @@ void BufferedRuntimeExecutor::flush() {
 }
 
 void BufferedRuntimeExecutor::unsafeFlush() {
-  while (queue_.size() > 0) {
+  while (!queue_.empty()) {
     const BufferedWork& bufferedWork = queue_.top();
-    Work work = std::move(bufferedWork.work_);
+    Work work = bufferedWork.work_;
     runtimeExecutor_(std::move(work));
     queue_.pop();
   }

package/ReactCommon/react/runtime/CMakeLists.txt

@@ -18,6 +18,10 @@ add_library(bridgeless
 target_compile_reactnative_options(bridgeless PRIVATE)
 if(${CMAKE_BUILD_TYPE} MATCHES Debug OR REACT_NATIVE_DEBUG_OPTIMIZED)
   target_compile_options(bridgeless PRIVATE -DHERMES_ENABLE_DEBUGGER=1)
+
+  if (HERMES_V1_ENABLED)
+        target_compile_options(bridgeless PRIVATE -DHERMES_V1_ENABLED=1)
+  endif()
 endif ()
 target_include_directories(bridgeless PUBLIC .)
 

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -36,7 +36,9 @@ std::shared_ptr<RuntimeScheduler> createRuntimeScheduler(
     RuntimeSchedulerTaskErrorHandler taskErrorHandler) {
   std::shared_ptr<RuntimeScheduler> scheduler =
       std::make_shared<RuntimeScheduler>(
-          runtimeExecutor, HighResTimeStamp::now, taskErrorHandler);
+          std::move(runtimeExecutor),
+          HighResTimeStamp::now,
+          std::move(taskErrorHandler));
   scheduler->setPerformanceEntryReporter(
       // FIXME: Move creation of PerformanceEntryReporter to here and
       // guarantee that its lifetime is the same as the runtime.
@@ -54,7 +56,7 @@ ReactInstance::ReactInstance(
     JsErrorHandler::OnJsError onJsError,
     jsinspector_modern::HostTarget* parentInspectorTarget)
     : runtime_(std::move(runtime)),
-      jsMessageQueueThread_(jsMessageQueueThread),
+      jsMessageQueueThread_(std::move(jsMessageQueueThread)),
       timerManager_(std::move(timerManager)),
       jsErrorHandler_(std::make_shared<JsErrorHandler>(std::move(onJsError))),
       parentInspectorTarget_(parentInspectorTarget) {
@@ -93,7 +95,7 @@ ReactInstance::ReactInstance(
         }
       };
 
-  if (parentInspectorTarget_) {
+  if (parentInspectorTarget_ != nullptr) {
     auto executor = parentInspectorTarget_->executorFromThis();
 
     auto bufferedRuntimeExecutorThatWaitsForInspectorSetup =
@@ -155,7 +157,7 @@ ReactInstance::ReactInstance(
 }
 
 void ReactInstance::unregisterFromInspector() {
-  if (inspectorTarget_) {
+  if (inspectorTarget_ != nullptr) {
     assert(runtimeInspectorTarget_);
     inspectorTarget_->unregisterRuntime(*runtimeInspectorTarget_);
 
@@ -200,7 +202,7 @@ namespace {
 // Copied from JSIExecutor.cpp
 // basename_r isn't in all iOS SDKs, so use this simple version instead.
 std::string simpleBasename(const std::string& path) {
-  size_t pos = path.rfind("/");
+  size_t pos = path.rfind('/');
   return (pos != std::string::npos) ? path.substr(pos) : path;
 }
 
@@ -234,7 +236,7 @@ void ReactInstance::loadScript(
       beforeLoad(runtime);
     }
     TraceSection s("ReactInstance::loadScript");
-    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
+    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl != nullptr);
     if (hasLogger) {
       ReactMarker::logTaggedMarkerBridgeless(
           ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
@@ -344,15 +346,18 @@ void ReactInstance::registerSegment(
     }
     auto buffer = std::make_shared<BigStringBuffer>(std::move(script));
 
-    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
+    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl != nullptr);
     if (hasLogger) {
       ReactMarker::logTaggedMarkerBridgeless(
           ReactMarker::REGISTER_JS_SEGMENT_START, tag.c_str());
     }
     LOG(WARNING) << "Starting to evaluate segment " << segmentId
                  << " in ReactInstance::registerSegment";
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     runtime.evaluateJavaScript(
         buffer, JSExecutor::getSyntheticBundlePath(segmentId, segmentPath));
+#pragma clang diagnostic pop
     LOG(WARNING) << "Finished evaluating segment " << segmentId
                  << " in ReactInstance::registerSegment";
     if (hasLogger) {
@@ -365,7 +370,7 @@ void ReactInstance::registerSegment(
 namespace {
 void defineReactInstanceFlags(
     jsi::Runtime& runtime,
-    ReactInstance::JSRuntimeFlags options) noexcept {
+    const ReactInstance::JSRuntimeFlags& options) noexcept {
   defineReadOnlyGlobal(runtime, "RN$Bridgeless", jsi::Value(true));
 
   if (options.isProfiling) {
@@ -390,7 +395,10 @@ bool isTruthy(jsi::Runtime& runtime, const jsi::Value& value) {
 void ReactInstance::initializeRuntime(
     JSRuntimeFlags options,
     BindingsInstallFunc bindingsInstallFunc) noexcept {
-  runtimeScheduler_->scheduleWork([this, options, bindingsInstallFunc](
+  runtimeScheduler_->scheduleWork([this,
+                                   options = std::move(options),
+                                   bindingsInstallFunc =
+                                       std::move(bindingsInstallFunc)](
                                       jsi::Runtime& runtime) {
     TraceSection s("ReactInstance::initializeRuntime");
 
@@ -606,7 +614,7 @@ void ReactInstance::handleMemoryPressureJs(int pressureLevel) {
     TRIM_MEMORY_RUNNING_MODERATE = 5,
     TRIM_MEMORY_UI_HIDDEN = 20,
   };
-  const char* levelName;
+  const char* levelName = nullptr;
   switch (pressureLevel) {
     case TRIM_MEMORY_BACKGROUND:
       levelName = "TRIM_MEMORY_BACKGROUND";

package/ReactCommon/react/runtime/ReactInstance.h

@@ -18,7 +18,6 @@
 #include <react/runtime/BufferedRuntimeExecutor.h>
 #include <react/runtime/JSRuntimeFactory.h>
 #include <react/runtime/TimerManager.h>
-#include <vector>
 
 namespace facebook::react {
 
@@ -41,7 +40,7 @@ class ReactInstance final : private jsinspector_modern::InstanceTargetDelegate {
 
   struct JSRuntimeFlags {
     bool isProfiling = false;
-    const std::string runtimeDiagnosticFlags = "";
+    const std::string runtimeDiagnosticFlags;
   };
 
   void initializeRuntime(

package/ReactCommon/react/runtime/TimerManager.cpp

@@ -59,7 +59,7 @@ TimerManager::TimerManager(
 
 void TimerManager::setRuntimeExecutor(
     RuntimeExecutor runtimeExecutor) noexcept {
-  runtimeExecutor_ = runtimeExecutor;
+  runtimeExecutor_ = std::move(runtimeExecutor);
 }
 
 TimerHandle TimerManager::createReactNativeMicrotask(
@@ -232,7 +232,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
           3, // Function, delay, ...args
           [this](
               jsi::Runtime& rt,
-              const jsi::Value& thisVal,
+              const jsi::Value& /*thisVal*/,
               const jsi::Value* args,
               size_t count) {
             if (count == 0) {
@@ -272,7 +272,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
           1, // timerID
           [this](
               jsi::Runtime& rt,
-              const jsi::Value& thisVal,
+              const jsi::Value& /*thisVal*/,
               const jsi::Value* args,
               size_t count) {
             if (count > 0 && args[0].isNumber()) {
@@ -291,7 +291,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
           3, // Function, delay, ...args
           [this](
               jsi::Runtime& rt,
-              const jsi::Value& thisVal,
+              const jsi::Value& /*thisVal*/,
               const jsi::Value* args,
               size_t count) {
             if (count == 0) {
@@ -332,7 +332,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
           1, // timerID
           [this](
               jsi::Runtime& rt,
-              const jsi::Value& thisVal,
+              const jsi::Value& /*thisVal*/,
               const jsi::Value* args,
               size_t count) {
             if (count > 0 && args[0].isNumber()) {
@@ -351,7 +351,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
           1, // callback
           [this](
               jsi::Runtime& rt,
-              const jsi::Value& thisVal,
+              const jsi::Value& /*thisVal*/,
               const jsi::Value* args,
               size_t count) {
             if (count == 0) {
@@ -373,9 +373,9 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
                 [callbackContainer = std::make_shared<jsi::Function>(
                      args[0].getObject(rt).getFunction(rt))](
                     jsi::Runtime& rt,
-                    const jsi::Value& thisVal,
-                    const jsi::Value* args,
-                    size_t count) {
+                    const jsi::Value& /*thisVal*/,
+                    const jsi::Value* /*args*/,
+                    size_t /*count*/) {
                   auto performance =
                       rt.global().getPropertyAsObject(rt, "performance");
                   auto nowFn = performance.getPropertyAsFunction(rt, "now");
@@ -402,7 +402,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
           1, // timerID
           [this](
               jsi::Runtime& rt,
-              const jsi::Value& thisVal,
+              const jsi::Value& /*thisVal*/,
               const jsi::Value* args,
               size_t count) {
             if (count > 0 && args[0].isNumber()) {

package/ReactCommon/react/runtime/hermes/CMakeLists.txt

@@ -19,7 +19,7 @@ target_include_directories(bridgelesshermes PUBLIC .)
 
 react_native_android_selector(reactnative reactnative "")
 target_link_libraries(bridgelesshermes
-        hermes-engine::libhermes
+        hermes-engine::hermesvm
         hermes_executor_common
         hermes_inspector_modern
         jsi
@@ -35,4 +35,8 @@ if(${CMAKE_BUILD_TYPE} MATCHES Debug OR REACT_NATIVE_DEBUG_OPTIMIZED)
                 PRIVATE
                 -DHERMES_ENABLE_DEBUGGER=1
         )
+
+        if (HERMES_V1_ENABLED)
+                target_compile_options(bridgelesshermes PRIVATE -DHERMES_V1_ENABLED=1)
+        endif()
 endif()

package/ReactCommon/react/runtime/hermes/HermesInstance.cpp

@@ -14,7 +14,11 @@
 
 #ifdef HERMES_ENABLE_DEBUGGER
 #include <hermes/inspector-modern/chrome/Registration.h>
+
+#ifndef HERMES_V1_ENABLED
 #include <hermes/inspector/RuntimeAdapter.h>
+#endif
+
 #include <jsi/decorator.h>
 #endif
 
@@ -23,7 +27,7 @@ using namespace facebook::jsi;
 
 namespace facebook::react {
 
-#ifdef HERMES_ENABLE_DEBUGGER
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
 
 // Wrapper that strongly retains the HermesRuntime for on device debugging.
 //
@@ -90,7 +94,7 @@ class DecoratedRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
   inspector_modern::chrome::DebugSessionToken debugToken_;
 };
 
-#endif
+#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
 
 class HermesJSRuntime : public JSRuntime {
  public:
@@ -157,7 +161,7 @@ std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
                             .getPropertyAsObject(*hermesRuntime, "prototype");
   errorPrototype.setProperty(*hermesRuntime, "jsEngine", "hermes");
 
-#ifdef HERMES_ENABLE_DEBUGGER
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
   auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
   if (!inspectorFlags.getFuseboxEnabled()) {
     std::unique_ptr<DecoratedRuntime> decoratedRuntime =

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.mm

@@ -341,7 +341,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   // Initialize RCTModuleRegistry so that TurboModules can require other TurboModules.
   [_bridgeModuleDecorator.moduleRegistry setTurboModuleRegistry:_turboModuleManager];
 
-  if (ReactNativeFeatureFlags::enableMainQueueModulesOnIOS()) {
+  if (ReactNativeFeatureFlags::enableEagerMainQueueModulesOnIOS()) {
     /**
      * Some native modules need to capture uikit objects on the main thread.
      * Start initializing those modules on the main queue here. The JavaScript thread

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTJscInstance.h

@@ -9,8 +9,7 @@
 #import <jsi/jsi.h>
 #import <react/runtime/JSRuntimeFactory.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class RCTJscInstance : public JSRuntimeFactory {
  public:
@@ -21,5 +20,4 @@ class RCTJscInstance : public JSRuntimeFactory {
 
   ~RCTJscInstance(){};
 };
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTJscInstance.mm

@@ -8,8 +8,7 @@
 #import "RCTJscInstance.h"
 #include <jsc/JSCRuntime.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 RCTJscInstance::RCTJscInstance() {}
 
@@ -18,5 +17,4 @@ std::unique_ptr<JSRuntime> RCTJscInstance::createJSRuntime(std::shared_ptr<Messa
   return std::make_unique<JSIRuntimeHolder>(jsc::makeJSCRuntime());
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <queue>
+#include <utility>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -32,15 +33,15 @@ class MockTimerRegistry : public PlatformTimerRegistry {
 
 class MockMessageQueueThread : public MessageQueueThread {
  public:
-  void runOnQueue(std::function<void()>&& func) {
+  void runOnQueue(std::function<void()>&& func) override {
     callbackQueue_.push(func);
   }
 
   // Unused
-  void runOnQueueSync(std::function<void()>&&) {}
+  void runOnQueueSync(std::function<void()>&& /*unused*/) override {}
 
   // Unused
-  void quitSynchronous() {}
+  void quitSynchronous() override {}
 
   void tick() {
     if (!callbackQueue_.empty()) {
@@ -79,7 +80,7 @@ class ErrorUtils : public jsi::HostObject {
           1,
           [this](
               jsi::Runtime& runtime,
-              const jsi::Value& thisValue,
+              const jsi::Value& /*thisValue*/,
               const jsi::Value* arguments,
               size_t count) {
             if (count >= 1) {
@@ -114,7 +115,7 @@ class ErrorUtils : public jsi::HostObject {
 
 class ReactInstanceTest : public ::testing::Test {
  protected:
-  ReactInstanceTest() {}
+  ReactInstanceTest() = default;
 
   void SetUp() override {
     auto runtime =
@@ -152,7 +153,7 @@ class ReactInstanceTest : public ::testing::Test {
     step();
 
     // Run the main bundle, so that native -> JS calls no longer get buffered.
-    loadScript(script);
+    loadScript(std::move(script));
   }
 
   void initializeRuntimeWithScript(std::string script) {
@@ -161,16 +162,16 @@ class ReactInstanceTest : public ::testing::Test {
     step();
 
     // Run the main bundle, so that native -> JS calls no longer get buffered.
-    loadScript(script);
+    loadScript(std::move(script));
   }
 
-  jsi::Value tryEval(std::string js, std::string defaultVal) {
+  jsi::Value tryEval(const std::string& js, const std::string& defaultVal) {
     return eval(
         "(function() { try { return " + js + "; } catch { return " +
         defaultVal + "; } })()");
   }
 
-  jsi::Value eval(std::string js) {
+  jsi::Value eval(const std::string& js) {
     RuntimeExecutor runtimeExecutor = instance_->getUnbufferedRuntimeExecutor();
     jsi::Value ret = jsi::Value::undefined();
     runtimeExecutor([js, &ret](jsi::Runtime& runtime) {
@@ -214,11 +215,11 @@ class ReactInstanceTest : public ::testing::Test {
     messageQueueThread_->guardedTick();
   }
 
-  jsi::Runtime* runtime_;
+  jsi::Runtime* runtime_{};
   std::shared_ptr<MockMessageQueueThread> messageQueueThread_;
   std::unique_ptr<ReactInstance> instance_;
   std::shared_ptr<TimerManager> timerManager_;
-  MockTimerRegistry* mockRegistry_;
+  MockTimerRegistry* mockRegistry_{};
   std::shared_ptr<ErrorUtils> errorHandler_;
 };
 

package/ReactCommon/react/test_utils/MockClock.h

@@ -11,9 +11,8 @@
 
 class MockClock {
  public:
-  typedef std::chrono::
-      time_point<std::chrono::steady_clock, std::chrono::nanoseconds>
-          time_point;
+  using time_point = std::chrono::
+      time_point<std::chrono::steady_clock, std::chrono::nanoseconds>;
 
   static time_point now() noexcept {
     return time_;

package/ReactCommon/react/timing/CMakeLists.txt

@@ -11,5 +11,7 @@ include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 add_library(react_timing INTERFACE)
 
 target_include_directories(react_timing INTERFACE ${REACT_COMMON_DIR})
+target_link_libraries(react_timing INTERFACE
+        react_debug)
 target_compile_reactnative_options(react_timing INTERFACE)
 target_compile_options(react_timing INTERFACE -Wpedantic)

package/ReactCommon/react/timing/primitives.h

@@ -7,7 +7,9 @@
 
 #pragma once
 
+#include <react/debug/flags.h>
 #include <chrono>
+#include <functional>
 
 namespace facebook::react {
 
@@ -193,11 +195,15 @@ class HighResTimeStamp {
       const HighResDuration& rhs);
 
  public:
-  HighResTimeStamp() noexcept
-      : chronoTimePoint_(std::chrono::steady_clock::now()) {}
+  HighResTimeStamp() noexcept : chronoTimePoint_(chronoNow()) {}
 
-  static constexpr HighResTimeStamp now() noexcept {
-    return HighResTimeStamp(std::chrono::steady_clock::now());
+  static HighResTimeStamp now() noexcept {
+    return HighResTimeStamp(chronoNow());
+  }
+
+  static HighResDuration unsafeOriginFromUnixTimeStamp() noexcept {
+    static auto origin = computeUnsafeOriginFromUnixTimeStamp();
+    return origin;
   }
 
   static constexpr HighResTimeStamp min() noexcept {
@@ -228,6 +234,14 @@ class HighResTimeStamp {
     return HighResTimeStamp(chronoTimePoint);
   }
 
+#ifdef REACT_NATIVE_DEBUG
+  static void setTimeStampProviderForTesting(
+      std::function<std::chrono::steady_clock::time_point()>&&
+          timeStampProvider) {
+    getTimeStampProvider() = std::move(timeStampProvider);
+  }
+#endif
+
   // This method is provided for convenience, if you need to convert
   // HighResTimeStamp to some common epoch with time stamps from other sources.
   constexpr std::chrono::steady_clock::time_point toChronoSteadyClockTimePoint()
@@ -275,6 +289,32 @@ class HighResTimeStamp {
       : chronoTimePoint_(chronoTimePoint) {}
 
   std::chrono::steady_clock::time_point chronoTimePoint_;
+
+  static HighResDuration computeUnsafeOriginFromUnixTimeStamp() noexcept {
+    auto systemNow = std::chrono::system_clock::now();
+    auto steadyNow = std::chrono::steady_clock::now();
+    return HighResDuration(
+        systemNow.time_since_epoch() - steadyNow.time_since_epoch());
+  }
+
+#ifdef REACT_NATIVE_DEBUG
+  static std::function<std::chrono::steady_clock::time_point()>&
+  getTimeStampProvider() {
+    static std::function<std::chrono::steady_clock::time_point()>
+        timeStampProvider = nullptr;
+    return timeStampProvider;
+  }
+
+  static std::chrono::steady_clock::time_point chronoNow() {
+    auto& timeStampProvider = getTimeStampProvider();
+    return timeStampProvider != nullptr ? timeStampProvider()
+                                        : std::chrono::steady_clock::now();
+  }
+#else
+  inline static std::chrono::steady_clock::time_point chronoNow() {
+    return std::chrono::steady_clock::now();
+  }
+#endif
 };
 
 inline constexpr HighResDuration operator-(

package/ReactCommon/react/utils/ContextContainer.h

@@ -25,8 +25,9 @@ namespace facebook::react {
  */
 class ContextContainer final {
  public:
-  using Shared = std::shared_ptr<const ContextContainer>;
-
+  using Shared
+      [[deprecated("Use std::shared_ptr<const ContextContainer> instead.")]] =
+          std::shared_ptr<const ContextContainer>;
   /*
    * Registers an instance of the particular type `T` in the container
    * using the provided `key`. Only one instance can be registered per key.

package/ReactCommon/react/utils/SimpleThreadSafeCache.h

@@ -38,24 +38,20 @@ class SimpleThreadSafeCache {
    */
   ValueT get(const KeyT& key, CacheGeneratorFunction<ValueT> auto generator)
       const {
-    std::lock_guard<std::mutex> lock(mutex_);
-
-    if (auto it = map_.find(key); it != map_.end()) {
-      // Move accessed item to front of list
-      list_.splice(list_.begin(), list_, it->second);
-      return it->second->second;
-    }
+    return getMapIterator(key, std::move(generator))->second->second;
+  }
 
-    auto value = generator();
-    // Add new value to front of list and map
-    list_.emplace_front(key, value);
-    map_[key] = list_.begin();
-    if (list_.size() > maxSize_) {
-      // Evict least recently used item (back of list)
-      map_.erase(list_.back().first);
-      list_.pop_back();
-    }
-    return value;
+  /*
+   * Returns pointers to both the key and value from the map with a given key.
+   * If the value wasn't found in the cache, constructs the value using given
+   * generator function, stores it inside a cache and returns it.
+   * Can be called from any thread.
+   */
+  std::pair<const KeyT*, const ValueT*> getWithKey(
+      const KeyT& key,
+      CacheGeneratorFunction<ValueT> auto generator) const {
+    auto it = getMapIterator(key, std::move(generator));
+    return std::make_pair(&it->first, &it->second->second);
   }
 
   /*
@@ -79,6 +75,29 @@ class SimpleThreadSafeCache {
   using EntryT = std::pair<KeyT, ValueT>;
   using iterator = typename std::list<EntryT>::iterator;
 
+  auto getMapIterator(
+      const KeyT& key,
+      CacheGeneratorFunction<ValueT> auto generator) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (auto it = map_.find(key); it != map_.end()) {
+      // Move accessed item to front of list
+      list_.splice(list_.begin(), list_, it->second);
+      return it;
+    }
+
+    auto value = generator();
+    // Add new value to front of list and map
+    list_.emplace_front(key, value);
+    auto [it, _] = map_.insert_or_assign(key, list_.begin());
+    if (list_.size() > maxSize_) {
+      // Evict least recently used item (back of list)
+      map_.erase(list_.back().first);
+      list_.pop_back();
+    }
+    return it;
+  }
+
   size_t maxSize_;
   mutable std::mutex mutex_;
   mutable std::list<EntryT> list_;