react-native 0.0.0-17be3a003 → 0.0.0-18697adec

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,32 +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;
-
-      while (!taskQueue_.empty()) {
-        auto topPriority = taskQueue_.top();
-        taskQueue_.pop();
-        (*topPriority)(runtime);
-      }
+      startWorkLoop(runtime);
     });
   }
 
   return task;
 }
 
-void RuntimeScheduler::cancelTask(const std::shared_ptr<Task> &task) {
-  task->cancel();
+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();
 }
 
-RuntimeSchedulerTimePoint RuntimeScheduler::now() const {
+SchedulerPriority RuntimeScheduler::getCurrentPriorityLevel() const noexcept {
+  return currentPriority_;
+}
+
+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

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

@@ -14,24 +14,52 @@
 #include <memory>
 #include <queue>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 class RuntimeScheduler final {
  public:
-  RuntimeScheduler(RuntimeExecutor const &runtimeExecutor);
   RuntimeScheduler(
       RuntimeExecutor const &runtimeExecutor,
-      std::function<RuntimeSchedulerTimePoint()> now);
+      std::function<RuntimeSchedulerTimePoint()> now =
+          RuntimeSchedulerClock::now);
+  /*
+   * Not copyable.
+   */
+  RuntimeScheduler(RuntimeScheduler const &) = delete;
+  RuntimeScheduler &operator=(RuntimeScheduler const &) = delete;
+
+  /*
+   * Not movable.
+   */
+  RuntimeScheduler(RuntimeScheduler &&) = delete;
+  RuntimeScheduler &operator=(RuntimeScheduler &&) = delete;
+
+  void scheduleWork(std::function<void(jsi::Runtime &)> callback) const;
+
+  /*
+   * Grants access to the runtime synchronously on the caller's thread.
+   *
+   * Shouldn't be called directly. it is expected to be used
+   * by dispatching a synchronous event via event emitter in your native
+   * component.
+   */
+  void executeNowOnTheSameThread(
+      std::function<void(jsi::Runtime &runtime)> callback) const;
 
   std::shared_ptr<Task> scheduleTask(
       SchedulerPriority priority,
       jsi::Function callback);
 
-  void cancelTask(std::shared_ptr<Task> const &task);
+  void cancelTask(std::shared_ptr<Task> const &task) noexcept;
+
+  bool getShouldYield() const noexcept;
+
+  SchedulerPriority getCurrentPriorityLevel() const noexcept;
 
-  bool getShouldYield() const;
+  RuntimeSchedulerTimePoint now() const noexcept;
 
-  RuntimeSchedulerTimePoint now() const;
+  void setEnableYielding(bool enableYielding);
 
  private:
   mutable std::priority_queue<
@@ -39,8 +67,17 @@ class RuntimeScheduler final {
       std::vector<std::shared_ptr<Task>>,
       TaskPriorityComparer>
       taskQueue_;
+
   RuntimeExecutor const runtimeExecutor_;
-  std::atomic_bool shouldYield_{false};
+  mutable SchedulerPriority currentPriority_{SchedulerPriority::NormalPriority};
+  mutable std::atomic_bool shouldYield_{false};
+
+  void startWorkLoop(jsi::Runtime &runtime) const;
+
+  /*
+   * Returns a time point representing the current point in time. May be called
+   * from multiple threads.
+   */
   std::function<RuntimeSchedulerTimePoint()> now_;
 
   /*
@@ -48,6 +85,21 @@ class RuntimeScheduler final {
    * scheduled.
    */
   std::atomic_bool isCallbackScheduled_{false};
+
+  /*
+   * Flag indicating if yielding is enabled.
+   *
+   * If set to true and Concurrent Mode is enabled on the surface,
+   * React Native will ask React to yield in case any work has been scheduled.
+   * Default value is false
+   */
+  bool enableYielding_{false};
+
+  /*
+   * This flag is set while performing work, to prevent re-entrancy.
+   */
+  mutable bool isPerformingWork_{false};
 };
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -13,12 +13,13 @@
 #include <chrono>
 #include <memory>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 std::shared_ptr<RuntimeSchedulerBinding>
 RuntimeSchedulerBinding::createAndInstallIfNeeded(
     jsi::Runtime &runtime,
-    RuntimeExecutor runtimeExecutor) {
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler) {
   auto runtimeSchedulerModuleName = "nativeRuntimeScheduler";
 
   auto runtimeSchedulerValue =
@@ -26,9 +27,8 @@ RuntimeSchedulerBinding::createAndInstallIfNeeded(
   if (runtimeSchedulerValue.isUndefined()) {
     // The global namespace does not have an instance of the binding;
     // we need to create, install and return it.
-    auto runtimeScheduler = std::make_unique<RuntimeScheduler>(runtimeExecutor);
     auto runtimeSchedulerBinding =
-        std::make_shared<RuntimeSchedulerBinding>(std::move(runtimeScheduler));
+        std::make_shared<RuntimeSchedulerBinding>(runtimeScheduler);
     auto object =
         jsi::Object::createFromHostObject(runtime, runtimeSchedulerBinding);
     runtime.global().setProperty(
@@ -43,8 +43,8 @@ RuntimeSchedulerBinding::createAndInstallIfNeeded(
 }
 
 RuntimeSchedulerBinding::RuntimeSchedulerBinding(
-    std::unique_ptr<RuntimeScheduler> runtimeScheduler)
-    : runtimeScheduler_(std::move(runtimeScheduler)) {}
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
 
 jsi::Value RuntimeSchedulerBinding::get(
     jsi::Runtime &runtime,
@@ -133,6 +133,11 @@ jsi::Value RuntimeSchedulerBinding::get(
         });
   }
 
+  if (propertyName == "unstable_getCurrentPriorityLevel") {
+    auto currentPriorityLevel = runtimeScheduler_->getCurrentPriorityLevel();
+    return jsi::Value(runtime, serialize(currentPriorityLevel));
+  }
+
   if (propertyName == "unstable_ImmediatePriority") {
     return jsi::Value(runtime, serialize(SchedulerPriority::ImmediatePriority));
   }
@@ -154,8 +159,13 @@ jsi::Value RuntimeSchedulerBinding::get(
     return jsi::Value(runtime, serialize(SchedulerPriority::IdlePriority));
   }
 
+  if (propertyName == "$$typeof") {
+    return jsi::Value::undefined();
+  }
+
   react_native_assert(false && "undefined property");
   return jsi::Value::undefined();
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -10,14 +10,16 @@
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 /*
  * Exposes RuntimeScheduler to JavaScript realm.
  */
 class RuntimeSchedulerBinding : public jsi::HostObject {
  public:
-  RuntimeSchedulerBinding(std::unique_ptr<RuntimeScheduler> runtimeScheduler);
+  RuntimeSchedulerBinding(
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
 
   /*
    * Installs RuntimeSchedulerBinding into JavaScript runtime if needed.
@@ -27,7 +29,7 @@ class RuntimeSchedulerBinding : public jsi::HostObject {
    */
   static std::shared_ptr<RuntimeSchedulerBinding> createAndInstallIfNeeded(
       jsi::Runtime &runtime,
-      RuntimeExecutor runtimeExecutor);
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
 
   /*
    * `jsi::HostObject` specific overloads.
@@ -35,7 +37,8 @@ class RuntimeSchedulerBinding : public jsi::HostObject {
   jsi::Value get(jsi::Runtime &runtime, jsi::PropNameID const &name) override;
 
  private:
-  std::unique_ptr<RuntimeScheduler> runtimeScheduler_;
+  std::shared_ptr<RuntimeScheduler> runtimeScheduler_;
 };
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "RuntimeSchedulerCallInvoker.h"
+
+namespace facebook::react {
+
+RuntimeSchedulerCallInvoker::RuntimeSchedulerCallInvoker(
+    std::weak_ptr<RuntimeScheduler> runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
+
+void RuntimeSchedulerCallInvoker::invokeAsync(std::function<void()> &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->scheduleWork(
+        [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
+void RuntimeSchedulerCallInvoker::invokeSync(std::function<void()> &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->executeNowOnTheSameThread(
+        [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace facebook::react {
+
+/*
+ * Exposes RuntimeScheduler to native modules. All calls invonked on JavaScript
+ * queue from native modules will be funneled through RuntimeScheduler.
+ */
+class RuntimeSchedulerCallInvoker : public CallInvoker {
+ public:
+  RuntimeSchedulerCallInvoker(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
+
+  void invokeAsync(std::function<void()> &&func) override;
+  void invokeSync(std::function<void()> &&func) override;
+
+ private:
+  /*
+   * RuntimeScheduler is retained by the runtime. It must not be
+   * retained by anything beyond the runtime.
+   */
+  std::weak_ptr<RuntimeScheduler> runtimeScheduler_;
+};
+
+} // namespace facebook::react

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

@@ -9,7 +9,8 @@
 
 #include <chrono>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 /*
  * Represents a monotonic clock suitable for measuring intervals.
@@ -19,4 +20,5 @@ using RuntimeSchedulerClock = std::chrono::steady_clock;
 using RuntimeSchedulerTimePoint = RuntimeSchedulerClock::time_point;
 using RuntimeSchedulerDuration = RuntimeSchedulerClock::duration;
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -10,7 +10,8 @@
 #include <react/debug/react_native_assert.h>
 #include <chrono>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 enum class SchedulerPriority : int {
   ImmediatePriority = 1,
@@ -60,4 +61,5 @@ static inline std::chrono::milliseconds timeoutForSchedulerPriority(
   }
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -7,36 +7,31 @@
 
 #include "RuntimeScheduler.h"
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 Task::Task(
     SchedulerPriority priority,
     jsi::Function callback,
     std::chrono::steady_clock::time_point expirationTime)
-    : priority_(priority),
-      callback_(std::move(callback)),
-      expirationTime_(expirationTime) {}
-
-SchedulerPriority Task::getPriority() const {
-  return priority_;
-}
-
-RuntimeSchedulerClock::time_point Task::getExpirationTime() const {
-  return expirationTime_;
-}
-
-void Task::cancel() {
-  // Null out the callback to indicate the task has been canceled. (Can't
-  // remove from the priority_queue because you can't remove arbitrary nodes
-  // from an array based heap, only the first one.)
-  callback_.reset();
-}
-
-void Task::operator()(jsi::Runtime &runtime) const {
-  if (callback_) {
-    // Cancelled task doesn't have a callback.
-    callback_.value().call(runtime, {});
+    : priority(priority),
+      callback(std::move(callback)),
+      expirationTime(expirationTime) {}
+
+jsi::Value Task::execute(jsi::Runtime &runtime) {
+  auto result = jsi::Value::undefined();
+  // Cancelled task doesn't have a callback.
+  if (callback) {
+    // Callback in JavaScript is expecting a single bool parameter.
+    // React team plans to remove it and it is safe to pass in
+    // hardcoded false value.
+    result = callback.value().call(runtime, {false});
+
+    // Destroying callback to prevent calling it twice.
+    callback.reset();
   }
+  return result;
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -12,27 +12,27 @@
 #include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
 #include <react/renderer/runtimescheduler/SchedulerPriority.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
-class Task final {
- public:
+class RuntimeScheduler;
+class TaskPriorityComparer;
+
+struct Task final {
   Task(
       SchedulerPriority priority,
       jsi::Function callback,
       std::chrono::steady_clock::time_point expirationTime);
 
-  SchedulerPriority getPriority() const;
-
-  RuntimeSchedulerClock::time_point getExpirationTime() const;
-
-  void cancel();
+ private:
+  friend RuntimeScheduler;
+  friend TaskPriorityComparer;
 
-  void operator()(jsi::Runtime &runtime) const;
+  SchedulerPriority priority;
+  better::optional<jsi::Function> callback;
+  RuntimeSchedulerClock::time_point expirationTime;
 
- private:
-  SchedulerPriority priority_;
-  better::optional<jsi::Function> callback_;
-  RuntimeSchedulerClock::time_point expirationTime_;
+  jsi::Value execute(jsi::Runtime &runtime);
 };
 
 class TaskPriorityComparer {
@@ -40,8 +40,9 @@ class TaskPriorityComparer {
   inline bool operator()(
       std::shared_ptr<Task> const &lhs,
       std::shared_ptr<Task> const &rhs) {
-    return lhs->getExpirationTime() > rhs->getExpirationTime();
+    return lhs->expirationTime > rhs->expirationTime;
   }
 };
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -11,7 +11,8 @@
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/Task.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 struct TaskWrapper : public jsi::HostObject {
   TaskWrapper(std::shared_ptr<Task> const &task) : task(task) {}
@@ -36,4 +37,5 @@ inline static std::shared_ptr<Task> taskFromValue(
   return value.getObject(runtime).getHostObject<TaskWrapper>(runtime)->task;
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook