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

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

@@ -14,26 +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;
+  bool getShouldYield() const noexcept;
 
-  SchedulerPriority getCurrentPriorityLevel() const;
+  SchedulerPriority getCurrentPriorityLevel() const noexcept;
 
-  RuntimeSchedulerTimePoint now() const;
+  RuntimeSchedulerTimePoint now() const noexcept;
+
+  void setEnableYielding(bool enableYielding);
 
  private:
   mutable std::priority_queue<
@@ -41,9 +67,12 @@ class RuntimeScheduler final {
       std::vector<std::shared_ptr<Task>>,
       TaskPriorityComparer>
       taskQueue_;
+
   RuntimeExecutor const runtimeExecutor_;
-  SchedulerPriority currentPriority_{SchedulerPriority::NormalPriority};
-  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
@@ -56,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,
@@ -167,4 +167,5 @@ jsi::Value RuntimeSchedulerBinding::get(
   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,7 +7,8 @@
 
 #include "RuntimeScheduler.h"
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 Task::Task(
     SchedulerPriority priority,
@@ -17,15 +18,20 @@ Task::Task(
       callback(std::move(callback)),
       expirationTime(expirationTime) {}
 
-jsi::Value Task::execute(jsi::Runtime &runtime) const {
+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.
-    return callback.value().call(runtime, {false});
+    result = callback.value().call(runtime, {false});
+
+    // Destroying callback to prevent calling it twice.
+    callback.reset();
   }
-  return jsi::Value::undefined();
+  return result;
 }
 
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

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

@@ -12,7 +12,8 @@
 #include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
 #include <react/renderer/runtimescheduler/SchedulerPriority.h>
 
-namespace facebook::react {
+namespace facebook {
+namespace react {
 
 class RuntimeScheduler;
 class TaskPriorityComparer;
@@ -31,7 +32,7 @@ struct Task final {
   better::optional<jsi::Function> callback;
   RuntimeSchedulerClock::time_point expirationTime;
 
-  jsi::Value execute(jsi::Runtime &runtime) const;
+  jsi::Value execute(jsi::Runtime &runtime);
 };
 
 class TaskPriorityComparer {
@@ -43,4 +44,5 @@ class TaskPriorityComparer {
   }
 };
 
-} // 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

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

@@ -312,4 +312,161 @@ TEST_F(RuntimeSchedulerTest, getCurrentPriorityLevel) {
       SchedulerPriority::NormalPriority);
 }
 
+TEST_F(RuntimeSchedulerTest, scheduleWork) {
+  bool wasCalled = false;
+  runtimeScheduler_->scheduleWork(
+      [&](jsi::Runtime const &) { wasCalled = true; });
+
+  EXPECT_FALSE(wasCalled);
+
+  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(wasCalled);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, scheduleWorkWithYielding) {
+  runtimeScheduler_->setEnableYielding(true);
+  bool wasCalled = false;
+  runtimeScheduler_->scheduleWork(
+      [&](jsi::Runtime const &) { wasCalled = true; });
+
+  EXPECT_FALSE(wasCalled);
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(wasCalled);
+  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, normalTaskYieldsToPlatformEvent) {
+  runtimeScheduler_->setEnableYielding(true);
+
+  bool didRunJavaScriptTask = false;
+  bool didRunPlatformWork = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunJavaScriptTask = true;
+    EXPECT_TRUE(didRunPlatformWork);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  runtimeScheduler_->scheduleWork([&](jsi::Runtime const &) {
+    didRunPlatformWork = true;
+    EXPECT_FALSE(didRunJavaScriptTask);
+    EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+  });
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 2);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, expiredTaskDoesntYieldToPlatformEvent) {
+  runtimeScheduler_->setEnableYielding(true);
+
+  bool didRunJavaScriptTask = false;
+  bool didRunPlatformWork = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunJavaScriptTask = true;
+    EXPECT_FALSE(didRunPlatformWork);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  runtimeScheduler_->scheduleWork([&](jsi::Runtime const &) {
+    didRunPlatformWork = true;
+    EXPECT_TRUE(didRunJavaScriptTask);
+  });
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 2);
+
+  stubClock_->advanceTimeBy(6s);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, immediateTaskDoesntYieldToPlatformEvent) {
+  runtimeScheduler_->setEnableYielding(true);
+
+  bool didRunJavaScriptTask = false;
+  bool didRunPlatformWork = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool) {
+    didRunJavaScriptTask = true;
+    EXPECT_FALSE(didRunPlatformWork);
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::ImmediatePriority, std::move(callback));
+
+  runtimeScheduler_->scheduleWork([&](jsi::Runtime const &) {
+    didRunPlatformWork = true;
+    EXPECT_TRUE(didRunJavaScriptTask);
+  });
+
+  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 2);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_F(RuntimeSchedulerTest, scheduleTaskFromTask) {
+  bool didRunFirstTask = false;
+  bool didRunSecondTask = false;
+  auto firstCallback = createHostFunctionFromLambda(
+      [this, &didRunFirstTask, &didRunSecondTask](bool didUserCallbackTimeout) {
+        didRunFirstTask = true;
+        EXPECT_FALSE(didUserCallbackTimeout);
+
+        auto secondCallback = createHostFunctionFromLambda(
+            [&didRunSecondTask](bool didUserCallbackTimeout) {
+              didRunSecondTask = true;
+              EXPECT_FALSE(didUserCallbackTimeout);
+              return jsi::Value::undefined();
+            });
+
+        runtimeScheduler_->scheduleTask(
+            SchedulerPriority::ImmediatePriority, std::move(secondCallback));
+        return jsi::Value::undefined();
+      });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(firstCallback));
+
+  EXPECT_FALSE(didRunFirstTask);
+  EXPECT_FALSE(didRunSecondTask);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunFirstTask);
+  EXPECT_TRUE(didRunSecondTask);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/tests/StubQueue.h

@@ -15,6 +15,12 @@ class StubQueue {
     callbackQueue_.push(func);
   }
 
+  void flush() {
+    while (!callbackQueue_.empty()) {
+      tick();
+    }
+  }
+
   void tick() {
     if (!callbackQueue_.empty()) {
       auto callback = callbackQueue_.front();

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

@@ -9,8 +9,7 @@
 
 #include <react/debug/react_native_assert.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 AsynchronousEventBeat::AsynchronousEventBeat(
     RunLoopObserver::Unique uiRunLoopObserver,
@@ -24,34 +23,36 @@ AsynchronousEventBeat::AsynchronousEventBeat(
 
 void AsynchronousEventBeat::activityDidChange(
     RunLoopObserver::Delegate const *delegate,
-    RunLoopObserver::Activity activity) const noexcept {
+    RunLoopObserver::Activity) const noexcept {
   react_native_assert(delegate == this);
   induce();
 }
 
 void AsynchronousEventBeat::induce() const {
-  if (!isRequested_) {
+  if (!isRequested_ || isBeatCallbackScheduled_) {
     return;
   }
 
+  isRequested_ = false;
+
   // Here we know that `this` object exists because the caller has a strong
   // pointer to `owner`. To ensure the object will exist inside
   // `runtimeExecutor_` callback, we need to copy the  pointer there.
   auto weakOwner = uiRunLoopObserver_->getOwner();
 
-  runtimeExecutor_([this, weakOwner](jsi::Runtime &runtime) mutable {
+  isBeatCallbackScheduled_ = true;
+
+  runtimeExecutor_([this, weakOwner](jsi::Runtime &runtime) {
+    isBeatCallbackScheduled_ = false;
+
     auto owner = weakOwner.lock();
     if (!owner) {
       return;
     }
 
-    if (!isRequested_) {
-      return;
+    if (beatCallback_) {
+      beatCallback_(runtime);
     }
-
-    this->beat(runtime);
   });
 }
-
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

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

@@ -9,8 +9,7 @@
 #include <react/renderer/core/EventBeat.h>
 #include <react/utils/RunLoopObserver.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 /*
  * Event beat associated with JavaScript runtime.
@@ -35,7 +34,8 @@ class AsynchronousEventBeat : public EventBeat,
  private:
   RunLoopObserver::Unique uiRunLoopObserver_;
   RuntimeExecutor runtimeExecutor_;
+
+  mutable std::atomic<bool> isBeatCallbackScheduled_{false};
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/renderer/{components/picker/androidpicker/react/renderer/components/androidpicker/AndroidDialogPickerShadowNode.cpp → scheduler/InspectorData.h}

@@ -5,12 +5,20 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "AndroidDialogPickerShadowNode.h"
+#include <vector>
 
 namespace facebook {
 namespace react {
 
-extern const char AndroidDialogPickerComponentName[] = "AndroidDialogPicker";
+struct InspectorData {
+  std::vector<std::string> hierarchy;
+  int selectedIndex;
+  std::string fileName;
+  int lineNumber;
+  int columnNumber;
+  // TODO T97216348: remove folly::dynamic from InspectorData struct
+  folly::dynamic props;
+};
 
 } // namespace react
 } // namespace facebook