react-native-windows 0.82.1 → 0.83.0-preview.0

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/ModuleRegistry.cpp

@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "ModuleRegistry.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#include <glog/logging.h>
+#include <reactperflogger/BridgeNativeModulePerfLogger.h>
+#include <utility>
+
+#include "NativeModule.h"
+#include "TraceSection.h"
+
+namespace facebook::react {
+
+namespace {
+
+std::string normalizeName(std::string name) {
+  // TODO mhorowitz #10487027: This is super ugly.  We should just
+  // change iOS to emit normalized names, drop the "RK..." from
+  // names hardcoded in Android, and then delete this and the
+  // similar hacks in js.
+  if (name.compare(0, 3, "RCT") == 0) {
+    return name.substr(3);
+  } else if (name.compare(0, 2, "RK") == 0) {
+    return name.substr(2);
+  }
+  return name;
+}
+
+} // namespace
+
+ModuleRegistry::ModuleRegistry(
+    std::vector<std::unique_ptr<NativeModule>> modules,
+    ModuleNotFoundCallback callback)
+    : modules_{std::move(modules)},
+      moduleNotFoundCallback_{std::move(callback)} {}
+
+void ModuleRegistry::updateModuleNamesFromIndex(size_t index) {
+  for (; index < modules_.size(); index++) {
+    std::string name = normalizeName(modules_[index]->getName());
+    modulesByName_[name] = index;
+  }
+}
+
+void ModuleRegistry::registerModules(
+    std::vector<std::unique_ptr<NativeModule>> modules) {
+  TraceSection s_("ModuleRegistry::registerModules");
+  // Noop if there are no NativeModules to add
+  if (modules.empty()) {
+    return;
+  }
+
+  if (modules_.empty() && unknownModules_.empty()) {
+    modules_ = std::move(modules);
+  } else {
+    size_t modulesSize = modules_.size();
+    size_t addModulesSize = modules.size();
+    bool addToNames = !modulesByName_.empty();
+    modules_.reserve(modulesSize + addModulesSize);
+    std::move(modules.begin(), modules.end(), std::back_inserter(modules_));
+    if (!unknownModules_.empty()) {
+      for (size_t index = modulesSize; index < modulesSize + addModulesSize;
+           index++) {
+        std::string name = normalizeName(modules_[index]->getName());
+        auto it = unknownModules_.find(name);
+        if (it != unknownModules_.end()) {
+          throw std::runtime_error(
+              "module " + name +
+              " was required without being registered and is now being registered.");
+        } else if (addToNames) {
+          modulesByName_[name] = index;
+        }
+      }
+    } else if (addToNames) {
+      updateModuleNamesFromIndex(modulesSize);
+    }
+  }
+}
+
+std::vector<std::string> ModuleRegistry::moduleNames() {
+  TraceSection s_("ModuleRegistry::moduleNames");
+  std::vector<std::string> names;
+  for (size_t i = 0; i < modules_.size(); i++) {
+    std::string name = normalizeName(modules_[i]->getName());
+    modulesByName_[name] = i;
+    names.push_back(std::move(name));
+  }
+  return names;
+}
+
+std::optional<ModuleConfig> ModuleRegistry::getConfig(const std::string& name) {
+  TraceSection s("ModuleRegistry::getConfig", "module", name);
+
+  // Initialize modulesByName_
+  if (modulesByName_.empty() && !modules_.empty()) {
+    moduleNames();
+  }
+
+  auto it = modulesByName_.find(name);
+
+  if (it == modulesByName_.end()) {
+    if (unknownModules_.find(name) != unknownModules_.end()) {
+      BridgeNativeModulePerfLogger::moduleJSRequireBeginningFail(name.c_str());
+      BridgeNativeModulePerfLogger::moduleJSRequireEndingStart(name.c_str());
+      return std::nullopt;
+    }
+
+    if (!moduleNotFoundCallback_) {
+      unknownModules_.insert(name);
+      BridgeNativeModulePerfLogger::moduleJSRequireBeginningFail(name.c_str());
+      BridgeNativeModulePerfLogger::moduleJSRequireEndingStart(name.c_str());
+      return std::nullopt;
+    }
+
+    BridgeNativeModulePerfLogger::moduleJSRequireBeginningEnd(name.c_str());
+
+    bool wasModuleLazilyLoaded = moduleNotFoundCallback_(name);
+    it = modulesByName_.find(name);
+
+    bool wasModuleRegisteredWithRegistry =
+        wasModuleLazilyLoaded && it != modulesByName_.end();
+
+    if (!wasModuleRegisteredWithRegistry) {
+      BridgeNativeModulePerfLogger::moduleJSRequireEndingStart(name.c_str());
+      unknownModules_.insert(name);
+      return std::nullopt;
+    }
+  } else {
+    BridgeNativeModulePerfLogger::moduleJSRequireBeginningEnd(name.c_str());
+  }
+
+  // If we've gotten this far, then we've signaled moduleJSRequireBeginningEnd
+
+  size_t index = it->second;
+
+  CHECK(index < modules_.size());
+  NativeModule* module = modules_[index].get();
+
+  // string name, object constants, array methodNames (methodId is index),
+  // [array promiseMethodIds], [array syncMethodIds]
+  folly::dynamic config = folly::dynamic::array(name);
+
+  {
+    TraceSection s_("ModuleRegistry::getConstants", "module", name);
+    /**
+     * In the case that there are constants, we'll initialize the NativeModule,
+     * and signal moduleJSRequireEndingStart. Otherwise, we'll simply signal the
+     * event. The Module will be initialized when we invoke one of its
+     * NativeModule methods.
+     */
+    config.push_back(module->getConstants());
+  }
+
+  {
+    TraceSection s_("ModuleRegistry::getMethods", "module", name);
+    std::vector<MethodDescriptor> methods = module->getMethods();
+
+    folly::dynamic methodNames = folly::dynamic::array;
+    folly::dynamic promiseMethodIds = folly::dynamic::array;
+    folly::dynamic syncMethodIds = folly::dynamic::array;
+
+    for (auto& descriptor : methods) {
+      // TODO: #10487027 compare tags instead of doing string comparison?
+      methodNames.push_back(std::move(descriptor.name));
+      if (descriptor.type == "promise") {
+        promiseMethodIds.push_back(methodNames.size() - 1);
+      } else if (descriptor.type == "sync") {
+        syncMethodIds.push_back(methodNames.size() - 1);
+      }
+    }
+
+    if (!methodNames.empty()) {
+      config.push_back(std::move(methodNames));
+      if (!promiseMethodIds.empty() || !syncMethodIds.empty()) {
+        config.push_back(std::move(promiseMethodIds));
+        if (!syncMethodIds.empty()) {
+          config.push_back(std::move(syncMethodIds));
+        }
+      }
+    }
+  }
+
+  if (config.size() == 2 && config[1].empty()) {
+    // no constants or methods
+    return std::nullopt;
+  } else {
+    return ModuleConfig{.index = index, .config = std::move(config)};
+  }
+}
+
+std::string ModuleRegistry::getModuleName(unsigned int moduleId) {
+  if (moduleId >= modules_.size()) {
+    throw std::runtime_error(
+        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
+        std::to_string(modules_.size()) + ")");
+  }
+
+  return modules_[moduleId]->getName();
+}
+
+std::string ModuleRegistry::getModuleSyncMethodName(
+    unsigned int moduleId,
+    unsigned int methodId) {
+  if (moduleId >= modules_.size()) {
+    throw std::runtime_error(
+        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
+        std::to_string(modules_.size()) + ")");
+  }
+
+  return modules_[moduleId]->getSyncMethodName(methodId);
+}
+
+void ModuleRegistry::callNativeMethod(
+    unsigned int moduleId,
+    unsigned int methodId,
+    folly::dynamic&& params,
+    int callId) {
+  if (moduleId >= modules_.size()) {
+    throw std::runtime_error(
+        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
+        std::to_string(modules_.size()) + ")");
+  }
+  modules_[moduleId]->invoke(methodId, std::move(params), callId);
+}
+
+MethodCallResult ModuleRegistry::callSerializableNativeHook(
+    unsigned int moduleId,
+    unsigned int methodId,
+    folly::dynamic&& params) {
+  if (moduleId >= modules_.size()) {
+    throw std::runtime_error(
+        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
+        std::to_string(modules_.size()) + ")");
+  }
+  return modules_[moduleId]->callSerializableNativeHook(
+      methodId, std::move(params));
+}
+
+} // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/NativeToJsBridge.cpp

@@ -5,9 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+
 #include "NativeToJsBridge.h"
 
-#ifndef RCT_FIT_RM_OLD_RUNTIME
+#ifndef RCT_REMOVE_LEGACY_ARCH
 
 #include <ReactCommon/CallInvoker.h>
 #include <folly/json.h>
@@ -38,8 +43,8 @@ namespace facebook::react {
 
 // This class manages calls from JS to native code.
 class [[deprecated(
-    "This API will be removed along with the legacy architecture.")]] JsToNativeBridge
-    : public react::ExecutorDelegate {
+    "This API will be removed along with the legacy architecture.")]]
+JsToNativeBridge : public react::ExecutorDelegate {
  public:
   JsToNativeBridge(
       std::shared_ptr<ModuleRegistry> registry,
@@ -351,4 +356,8 @@ NativeToJsBridge::getInspectorTargetDelegate() {
 
 } // namespace facebook::react
 
-#endif // RCT_FIT_RM_OLD_RUNTIME
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/RAMBundleRegistry.cpp

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "RAMBundleRegistry.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#include <folly/String.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+constexpr uint32_t RAMBundleRegistry::MAIN_BUNDLE_ID;
+#pragma clang diagnostic pop
+
+std::unique_ptr<RAMBundleRegistry> RAMBundleRegistry::singleBundleRegistry(
+    std::unique_ptr<JSModulesUnbundle> mainBundle) {
+  return std::make_unique<RAMBundleRegistry>(std::move(mainBundle));
+}
+
+std::unique_ptr<RAMBundleRegistry> RAMBundleRegistry::multipleBundlesRegistry(
+    std::unique_ptr<JSModulesUnbundle> mainBundle,
+    std::function<std::unique_ptr<JSModulesUnbundle>(std::string)> factory) {
+  return std::make_unique<RAMBundleRegistry>(
+      std::move(mainBundle), std::move(factory));
+}
+
+RAMBundleRegistry::RAMBundleRegistry(
+    std::unique_ptr<JSModulesUnbundle> mainBundle,
+    std::function<std::unique_ptr<JSModulesUnbundle>(std::string)> factory)
+    : m_factory(std::move(factory)) {
+  m_bundles.emplace(MAIN_BUNDLE_ID, std::move(mainBundle));
+}
+
+void RAMBundleRegistry::registerBundle(
+    uint32_t bundleId,
+    std::string bundlePath) {
+  m_bundlePaths.emplace(bundleId, std::move(bundlePath));
+}
+
+JSModulesUnbundle::Module RAMBundleRegistry::getModule(
+    uint32_t bundleId,
+    uint32_t moduleId) {
+  if (m_bundles.find(bundleId) == m_bundles.end()) {
+    if (!m_factory) {
+      throw std::runtime_error(
+          "You need to register factory function in order to "
+          "support multiple RAM bundles.");
+    }
+
+    auto bundlePath = m_bundlePaths.find(bundleId);
+    if (bundlePath == m_bundlePaths.end()) {
+      throw std::runtime_error(
+          "In order to fetch RAM bundle from the registry, its file "
+          "path needs to be registered first.");
+    }
+    m_bundles.emplace(bundleId, m_factory(bundlePath->second));
+  }
+
+  auto module = getBundle(bundleId)->getModule(moduleId);
+  if (bundleId == MAIN_BUNDLE_ID) {
+    return module;
+  }
+
+  return {
+      .name = "seg-" + std::to_string(bundleId) + '_' + module.name,
+      .code = std::move(module.code),
+  };
+}
+
+JSModulesUnbundle* RAMBundleRegistry::getBundle(uint32_t bundleId) const {
+  return m_bundles.at(bundleId).get();
+}
+
+} // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/ReactMarker.cpp

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "ReactMarker.h"
+#include <cxxreact/JSExecutor.h>
+
+namespace facebook::react::ReactMarker {
+
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+LogTaggedMarker logTaggedMarkerBridgelessImpl = nullptr;
+LogTaggedMarker logTaggedMarkerImpl = nullptr;
+std::shared_mutex logTaggedMarkerImplMutex;
+
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+
+void logMarker(const ReactMarkerId markerId) {
+  logTaggedMarker(markerId, nullptr);
+}
+
+void logTaggedMarker(const ReactMarkerId markerId, const char* tag) {
+  LogTaggedMarker marker = nullptr;
+  {
+    std::shared_lock lock(logTaggedMarkerImplMutex);
+    marker = logTaggedMarkerImpl;
+  }
+  if (marker != nullptr) {
+    marker(markerId, tag);
+  }
+}
+
+void logMarkerBridgeless(const ReactMarkerId markerId) {
+  logTaggedMarkerBridgeless(markerId, nullptr);
+}
+
+void logTaggedMarkerBridgeless(const ReactMarkerId markerId, const char* tag) {
+  logTaggedMarkerBridgelessImpl(markerId, tag);
+}
+
+void logMarkerDone(const ReactMarkerId markerId, double markerTime) {
+  StartupLogger::getInstance().logStartupEvent(markerId, markerTime);
+}
+
+StartupLogger& StartupLogger::getInstance() {
+  static StartupLogger instance;
+  return instance;
+}
+
+void StartupLogger::logStartupEvent(
+    const ReactMarkerId markerId,
+    double markerTime) {
+  switch (markerId) {
+    case ReactMarkerId::APP_STARTUP_START:
+      if (!std::isnan(appStartupStartTime)) {
+        // We had a startup start time, which indicates a warm start (user
+        // closed the app and start again). In this case we need to invalidate
+        // all other startup timings.
+        reset();
+      }
+      appStartupStartTime = markerTime;
+      return;
+
+    case ReactMarkerId::APP_STARTUP_STOP:
+      if (std::isnan(appStartupEndTime)) {
+        appStartupEndTime = markerTime;
+      }
+      return;
+
+    case ReactMarkerId::INIT_REACT_RUNTIME_START:
+      if (std::isnan(initReactRuntimeStartTime)) {
+        initReactRuntimeStartTime = markerTime;
+      }
+      return;
+
+    case ReactMarkerId::INIT_REACT_RUNTIME_STOP:
+      if (std::isnan(initReactRuntimeEndTime)) {
+        initReactRuntimeEndTime = markerTime;
+      }
+      return;
+
+    case ReactMarkerId::RUN_JS_BUNDLE_START:
+      if (std::isnan(runJSBundleStartTime)) {
+        runJSBundleStartTime = markerTime;
+      }
+      return;
+
+    case ReactMarkerId::RUN_JS_BUNDLE_STOP:
+      if (std::isnan(runJSBundleEndTime)) {
+        runJSBundleEndTime = markerTime;
+      }
+      return;
+
+    default:
+      return;
+  }
+}
+
+void StartupLogger::reset() {
+  appStartupStartTime = std::nan("");
+  appStartupEndTime = std::nan("");
+  initReactRuntimeStartTime = std::nan("");
+  initReactRuntimeEndTime = std::nan("");
+  runJSBundleStartTime = std::nan("");
+  runJSBundleEndTime = std::nan("");
+}
+
+double StartupLogger::getAppStartupStartTime() {
+  return appStartupStartTime;
+}
+
+double StartupLogger::getInitReactRuntimeStartTime() {
+  return initReactRuntimeStartTime;
+}
+
+double StartupLogger::getInitReactRuntimeEndTime() {
+  return initReactRuntimeEndTime;
+}
+
+double StartupLogger::getRunJSBundleStartTime() {
+  return runJSBundleStartTime;
+}
+
+double StartupLogger::getRunJSBundleEndTime() {
+  return runJSBundleEndTime;
+}
+
+double StartupLogger::getAppStartupEndTime() {
+  return appStartupEndTime;
+}
+
+} // namespace facebook::react::ReactMarker
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/TraceSection.h

@@ -69,13 +69,13 @@ namespace facebook::react {
 struct TraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit TraceSection(
-      [[maybe_unused]] const char* name,
-      [[maybe_unused]] ConvertsToStringPiece&&... args) {
+  explicit TraceSection([[maybe_unused]] const char *name, [[maybe_unused]] ConvertsToStringPiece &&...args)
+  {
     TRACE_EVENT_BEGIN("react-native", perfetto::DynamicString{name}, args...);
   }
 
-  ~TraceSection() {
+  ~TraceSection()
+  {
     TRACE_EVENT_END("react-native");
   }
 };
@@ -84,10 +84,10 @@ using TraceSectionUnwrapped = TraceSection;
 struct ConcreteTraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit ConcreteTraceSection(
-      const char* name,
-      ConvertsToStringPiece&&... args)
-      : m_section(TRACE_TAG_REACT_CXX_BRIDGE, name, args...) {} // [Windows][issue #14819]
+  explicit ConcreteTraceSection(const char *name, ConvertsToStringPiece &&...args)
+      : m_section(TRACE_TAG_REACT_CXX_BRIDGE, name, args...) // [Windows][issue #14819]
+  {
+  }
 
  private:
   fbsystrace::FbSystraceSection m_section;
@@ -97,9 +97,9 @@ using TraceSectionUnwrapped = ConcreteTraceSection;
 struct DummyTraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit DummyTraceSection(
-      [[maybe_unused]] const char* name,
-      [[maybe_unused]] ConvertsToStringPiece&&... args) {}
+  explicit DummyTraceSection([[maybe_unused]] const char *name, [[maybe_unused]] ConvertsToStringPiece &&...args)
+  {
+  }
 };
 using TraceSectionUnwrapped = DummyTraceSection;
 #endif
@@ -110,14 +110,14 @@ using TraceSectionUnwrapped = DummyTraceSection;
  * In the case of WITH_LOOM_TRACE we don't use the signposts APIs because of the
  * templated type for TraceSection.
  */
-#if defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
-    !defined(WITH_LOOM_TRACE)
+#if defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && !defined(WITH_LOOM_TRACE)
 
 namespace systrace {
 
 template <typename T, typename = void>
 struct renderer {
-  static std::string render(const T& t) {
+  static std::string render(const T &t)
+  {
     std::ostringstream oss;
     oss << t;
     return oss.str();
@@ -125,19 +125,19 @@ struct renderer {
 };
 
 template <typename T>
-static auto render(const T& t)
-    -> decltype(renderer<T>::render(std::declval<const T&>())) {
+static auto render(const T &t) -> decltype(renderer<T>::render(std::declval<const T &>()))
+{
   return renderer<T>::render(t);
 }
 
 inline os_log_t instrumentsLogHandle = nullptr;
 
-static inline os_log_t getOrCreateInstrumentsLogHandle() {
+static inline os_log_t getOrCreateInstrumentsLogHandle()
+{
   static std::once_flag flag{};
   std::call_once(flag, []() {
     if (!instrumentsLogHandle) {
-      instrumentsLogHandle = os_log_create(
-          "dev.reactnative.instruments", OS_LOG_CATEGORY_DYNAMIC_TRACING);
+      instrumentsLogHandle = os_log_create("dev.reactnative.instruments", OS_LOG_CATEGORY_DYNAMIC_TRACING);
     }
   });
   return instrumentsLogHandle;
@@ -148,8 +148,8 @@ static inline os_log_t getOrCreateInstrumentsLogHandle() {
 struct TraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit TraceSection(const char* name, ConvertsToStringPiece&&... args)
-      : systraceSectionUnwrapped_(name, args...) {
+  explicit TraceSection(const char *name, ConvertsToStringPiece &&...args) : systraceSectionUnwrapped_(name, args...)
+  {
     os_log_t instrumentsLogHandle = systrace::getOrCreateInstrumentsLogHandle();
 
     // If the log isn't enabled, we don't want the performance overhead of the
@@ -168,24 +168,14 @@ struct TraceSection {
 
     signpostID_ = os_signpost_id_make_with_pointer(instrumentsLogHandle, this);
 
-    os_signpost_interval_begin(
-        instrumentsLogHandle,
-        signpostID_,
-        "Systrace",
-        "%s begin: %s",
-        name,
-        argsString.c_str());
+    os_signpost_interval_begin(instrumentsLogHandle, signpostID_, "Systrace", "%s begin: %s", name, argsString.c_str());
   }
 
-  ~TraceSection() {
+  ~TraceSection()
+  {
     // We don't need to gate on os_signpost_enabled here because it's already
     // checked in os_signpost_interval_end.
-    os_signpost_interval_end(
-        systrace::instrumentsLogHandle,
-        signpostID_,
-        "Systrace",
-        "%s end",
-        name_.data());
+    os_signpost_interval_end(systrace::instrumentsLogHandle, signpostID_, "Systrace", "%s end", name_.data());
   }
 
  private: