Replace RuntimeSchedulerClock with HighResTimeStamp, HighResDuration (#51251)

Summary:

# Changelog: [Internal]

Replaces `RuntimeSchedulerClock`, which was an alias for `std::chrono::steady_clock` with previously defined single timestamp abstraction.

Reviewed By: rubennorte

Differential Revision: D74246459

Author: hoxyq

packages/react-native/ReactCommon/react/nativemodule/idlecallbacks/NativeIdleCallbacks.cpp

@@ -9,7 +9,7 @@
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
 #include <react/renderer/runtimescheduler/Task.h>
-#include <chrono>
+#include <react/timing/primitives.h>
 #include <utility>
 
 #ifdef RN_DISABLE_OSS_PLUGIN_HEADER
@@ -36,7 +36,7 @@ class IdleTaskRef : public jsi::NativeState {
 jsi::Function makeTimeRemainingFunction(
     jsi::Runtime& runtime,
     std::shared_ptr<RuntimeScheduler> runtimeScheduler,
-    RuntimeSchedulerTimePoint deadline) {
+    HighResTimeStamp deadline) {
   return jsi::Function::createFromHostFunction(
       runtime,
       jsi::PropNameID::forAscii(runtime, "timeRemaining"),
@@ -55,13 +55,8 @@ jsi::Function makeTimeRemainingFunction(
             expired = true;
           } else {
             auto now = runtimeScheduler->now();
-
-            remainingTime = std::max(
-                static_cast<double>(
-                    std::chrono::duration_cast<std::chrono::milliseconds>(
-                        deadline - now)
-                        .count()),
-                0.0);
+            auto diff = deadline - now;
+            remainingTime = std::max(diff.toDOMHighResTimeStamp(), 0.0);
 
             if (remainingTime == 0) {
               expired = true;
@@ -86,15 +81,13 @@ CallbackHandle NativeIdleCallbacks::requestIdleCallback(
   auto runtimeScheduler = binding->getRuntimeScheduler();
 
   // handle timeout parameter
-  std::optional<RuntimeSchedulerTimeout> timeout;
-  std::optional<RuntimeSchedulerTimePoint> expirationTime;
+  std::optional<HighResDuration> timeout;
+  std::optional<HighResTimeStamp> expirationTime;
 
   if (options.has_value() && options.value().timeout.has_value()) {
-    auto userTimeout = (options.value().timeout.value());
-    if (userTimeout > 0) {
-      timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
-          std::chrono::duration<double, std::milli>(userTimeout));
-      expirationTime = runtimeScheduler->now() + timeout.value();
+    HighResDuration userTimeout = options.value().timeout.value();
+    if (userTimeout > HighResDuration::zero()) {
+      expirationTime = runtimeScheduler->now() + userTimeout;
     }
   }
 
@@ -110,7 +103,7 @@ CallbackHandle NativeIdleCallbacks::requestIdleCallback(
     // we interrupt the current one. The general outcome should be the same.
 
     auto executionStartTime = runtimeScheduler->now();
-    auto deadline = executionStartTime + std::chrono::milliseconds(50);
+    auto deadline = executionStartTime + HighResDuration::fromMilliseconds(50);
     auto didTimeout = expirationTime.has_value()
         ? executionStartTime > expirationTime
         : false;

packages/react-native/ReactCommon/react/nativemodule/idlecallbacks/NativeIdleCallbacks.h

@@ -20,7 +20,8 @@ namespace facebook::react {
 using CallbackHandle = jsi::Object;
 
 using NativeRequestIdleCallbackOptions =
-    NativeIdleCallbacksRequestIdleCallbackOptions<std::optional<double>>;
+    NativeIdleCallbacksRequestIdleCallbackOptions<
+        std::optional<HighResDuration>>;
 
 template <>
 struct Bridging<NativeRequestIdleCallbackOptions>

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -8,7 +8,6 @@
 #include "RuntimeScheduler.h"
 #include "RuntimeScheduler_Legacy.h"
 #include "RuntimeScheduler_Modern.h"
-#include "SchedulerPriorityUtils.h"
 
 #include <cxxreact/ErrorUtils.h>
 #include <cxxreact/TraceSection.h>
@@ -22,7 +21,7 @@ extern const char RuntimeSchedulerKey[] = "RuntimeScheduler";
 namespace {
 std::unique_ptr<RuntimeSchedulerBase> getRuntimeSchedulerImplementation(
     RuntimeExecutor runtimeExecutor,
-    std::function<RuntimeSchedulerTimePoint()> now,
+    std::function<HighResTimeStamp()> now,
     RuntimeSchedulerTaskErrorHandler onTaskError) {
   if (ReactNativeFeatureFlags::enableBridgelessArchitecture()) {
     return std::make_unique<RuntimeScheduler_Modern>(
@@ -37,7 +36,7 @@ std::unique_ptr<RuntimeSchedulerBase> getRuntimeSchedulerImplementation(
 
 RuntimeScheduler::RuntimeScheduler(
     RuntimeExecutor runtimeExecutor,
-    std::function<RuntimeSchedulerTimePoint()> now,
+    std::function<HighResTimeStamp()> now,
     RuntimeSchedulerTaskErrorHandler onTaskError)
     : runtimeSchedulerImpl_(getRuntimeSchedulerImplementation(
           std::move(runtimeExecutor),
@@ -68,13 +67,13 @@ std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
 
 std::shared_ptr<Task> RuntimeScheduler::scheduleIdleTask(
     jsi::Function&& callback,
-    RuntimeSchedulerTimeout timeout) noexcept {
+    HighResDuration timeout) noexcept {
   return runtimeSchedulerImpl_->scheduleIdleTask(std::move(callback), timeout);
 }
 
 std::shared_ptr<Task> RuntimeScheduler::scheduleIdleTask(
     RawCallback&& callback,
-    RuntimeSchedulerTimeout timeout) noexcept {
+    HighResDuration timeout) noexcept {
   return runtimeSchedulerImpl_->scheduleIdleTask(std::move(callback), timeout);
 }
 
@@ -90,7 +89,7 @@ SchedulerPriority RuntimeScheduler::getCurrentPriorityLevel() const noexcept {
   return runtimeSchedulerImpl_->getCurrentPriorityLevel();
 }
 
-RuntimeSchedulerTimePoint RuntimeScheduler::now() const noexcept {
+HighResTimeStamp RuntimeScheduler::now() const noexcept {
   return runtimeSchedulerImpl_->now();
 }
 

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -10,15 +10,14 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/consistency/ShadowTreeRevisionConsistencyManager.h>
-#include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
 #include <react/renderer/runtimescheduler/SchedulerPriorityUtils.h>
 #include <react/renderer/runtimescheduler/Task.h>
+#include <react/timing/primitives.h>
 #include "RuntimeSchedulerEventTimingDelegate.h"
 
 namespace facebook::react {
 
 using RuntimeSchedulerRenderingUpdate = std::function<void()>;
-using RuntimeSchedulerTimeout = std::chrono::milliseconds;
 using SurfaceId = int32_t;
 
 using RuntimeSchedulerTaskErrorHandler =
@@ -41,16 +40,16 @@ class RuntimeSchedulerBase {
       RawCallback&& callback) noexcept = 0;
   virtual std::shared_ptr<Task> scheduleIdleTask(
       jsi::Function&& callback,
-      RuntimeSchedulerTimeout timeout = timeoutForSchedulerPriority(
+      HighResDuration timeout = timeoutForSchedulerPriority(
           SchedulerPriority::IdlePriority)) noexcept = 0;
   virtual std::shared_ptr<Task> scheduleIdleTask(
       RawCallback&& callback,
-      RuntimeSchedulerTimeout timeout = timeoutForSchedulerPriority(
+      HighResDuration timeout = timeoutForSchedulerPriority(
           SchedulerPriority::IdlePriority)) noexcept = 0;
   virtual void cancelTask(Task& task) noexcept = 0;
   virtual bool getShouldYield() noexcept = 0;
   virtual SchedulerPriority getCurrentPriorityLevel() const noexcept = 0;
-  virtual RuntimeSchedulerTimePoint now() const noexcept = 0;
+  virtual HighResTimeStamp now() const noexcept = 0;
   virtual void callExpiredTasks(jsi::Runtime& runtime) = 0;
   virtual void scheduleRenderingUpdate(
       SurfaceId surfaceId,
@@ -69,8 +68,7 @@ class RuntimeScheduler final : RuntimeSchedulerBase {
  public:
   explicit RuntimeScheduler(
       RuntimeExecutor runtimeExecutor,
-      std::function<RuntimeSchedulerTimePoint()> now =
-          RuntimeSchedulerClock::now,
+      std::function<HighResTimeStamp()> now = HighResTimeStamp::now,
       RuntimeSchedulerTaskErrorHandler onTaskError = handleTaskErrorDefault);
 
   /*
@@ -112,12 +110,12 @@ class RuntimeScheduler final : RuntimeSchedulerBase {
 
   std::shared_ptr<Task> scheduleIdleTask(
       jsi::Function&& callback,
-      RuntimeSchedulerTimeout timeout = timeoutForSchedulerPriority(
+      HighResDuration timeout = timeoutForSchedulerPriority(
           SchedulerPriority::IdlePriority)) noexcept override;
 
   std::shared_ptr<Task> scheduleIdleTask(
       RawCallback&& callback,
-      RuntimeSchedulerTimeout timeout = timeoutForSchedulerPriority(
+      HighResDuration timeout = timeoutForSchedulerPriority(
           SchedulerPriority::IdlePriority)) noexcept override;
 
   /*
@@ -149,7 +147,7 @@ class RuntimeScheduler final : RuntimeSchedulerBase {
    *
    * Thread synchronization must be enforced externally.
    */
-  RuntimeSchedulerTimePoint now() const noexcept override;
+  HighResTimeStamp now() const noexcept override;
 
   /*
    * Expired task is a task that should have been already executed. Designed to

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp

@@ -7,11 +7,11 @@
 
 #include "RuntimeSchedulerBinding.h"
 #include <ReactCommon/SchedulerPriority.h>
+#include <react/timing/primitives.h>
 #include "RuntimeScheduler.h"
 #include "SchedulerPriorityUtils.h"
 #include "primitives.h"
 
-#include <chrono>
 #include <memory>
 #include <utility>
 
@@ -144,10 +144,8 @@ jsi::Value RuntimeSchedulerBinding::get(
             const jsi::Value*,
             size_t) noexcept -> jsi::Value {
           auto now = runtimeScheduler_->now();
-          auto asDouble =
-              std::chrono::duration<double, std::milli>(now.time_since_epoch())
-                  .count();
-          return {asDouble};
+          auto domHighResTimeStamp = now.toDOMHighResTimeStamp();
+          return {domHighResTimeStamp};
         });
   }
 

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerClock.h

@@ -18,7 +18,7 @@ namespace facebook::react {
 
 RuntimeScheduler_Legacy::RuntimeScheduler_Legacy(
     RuntimeExecutor runtimeExecutor,
-    std::function<RuntimeSchedulerTimePoint()> now,
+    std::function<HighResTimeStamp()> now,
     RuntimeSchedulerTaskErrorHandler onTaskError)
     : runtimeExecutor_(std::move(runtimeExecutor)),
       now_(std::move(now)),
@@ -84,7 +84,7 @@ std::shared_ptr<Task> RuntimeScheduler_Legacy::scheduleTask(
 
 std::shared_ptr<Task> RuntimeScheduler_Legacy::scheduleIdleTask(
     jsi::Function&& /*callback*/,
-    RuntimeSchedulerTimeout /*timeout*/) noexcept {
+    HighResDuration /*timeout*/) noexcept {
   // Idle tasks are not supported on Legacy RuntimeScheduler.
   // Because the method is `noexcept`, we return `nullptr` here and handle it
   // on the caller side.
@@ -93,7 +93,7 @@ std::shared_ptr<Task> RuntimeScheduler_Legacy::scheduleIdleTask(
 
 std::shared_ptr<Task> RuntimeScheduler_Legacy::scheduleIdleTask(
     RawCallback&& /*callback*/,
-    RuntimeSchedulerTimeout /*timeout*/) noexcept {
+    HighResDuration /*timeout*/) noexcept {
   // Idle tasks are not supported on Legacy RuntimeScheduler.
   // Because the method is `noexcept`, we return `nullptr` here and handle it
   // on the caller side.
@@ -113,7 +113,7 @@ SchedulerPriority RuntimeScheduler_Legacy::getCurrentPriorityLevel()
   return currentPriority_;
 }
 
-RuntimeSchedulerTimePoint RuntimeScheduler_Legacy::now() const noexcept {
+HighResTimeStamp RuntimeScheduler_Legacy::now() const noexcept {
   return now_();
 }
 

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.cpp

@@ -10,7 +10,6 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/consistency/ShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
-#include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
 #include <react/renderer/runtimescheduler/Task.h>
 #include <atomic>
 #include <memory>
@@ -22,7 +21,7 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
  public:
   explicit RuntimeScheduler_Legacy(
       RuntimeExecutor runtimeExecutor,
-      std::function<RuntimeSchedulerTimePoint()> now,
+      std::function<HighResTimeStamp()> now,
       RuntimeSchedulerTaskErrorHandler onTaskError);
 
   /*
@@ -68,7 +67,7 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
    */
   std::shared_ptr<Task> scheduleIdleTask(
       jsi::Function&& callback,
-      RuntimeSchedulerTimeout timeout = timeoutForSchedulerPriority(
+      HighResDuration timeout = timeoutForSchedulerPriority(
           SchedulerPriority::IdlePriority)) noexcept override;
 
   /*
@@ -77,7 +76,7 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
    */
   std::shared_ptr<Task> scheduleIdleTask(
       RawCallback&& callback,
-      RuntimeSchedulerTimeout timeout = timeoutForSchedulerPriority(
+      HighResDuration timeout = timeoutForSchedulerPriority(
           SchedulerPriority::IdlePriority)) noexcept override;
 
   /*
@@ -109,7 +108,7 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
    *
    * Thread synchronization must be enforced externally.
    */
-  RuntimeSchedulerTimePoint now() const noexcept override;
+  HighResTimeStamp now() const noexcept override;
 
   /*
    * Expired task is a task that should have been already executed. Designed to
@@ -169,7 +168,7 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
    * Returns a time point representing the current point in time. May be called
    * from multiple threads.
    */
-  std::function<RuntimeSchedulerTimePoint()> now_;
+  std::function<HighResTimeStamp()> now_;
 
   /*
    * Flag indicating if callback on JavaScript queue has been