react-native-windows 0.69.5 → 0.70.0-preview.2

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/NativeToJsBridge.cpp

@@ -0,0 +1,344 @@
+/*
+ * 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.
+ */
+
+#include "NativeToJsBridge.h"
+
+#include <ReactCommon/CallInvoker.h>
+#include <folly/MoveWrapper.h>
+#include <folly/json.h>
+#include <glog/logging.h>
+#include <jsi/jsi.h>
+#include <reactperflogger/BridgeNativeModulePerfLogger.h>
+
+#include "ErrorUtils.h"
+#include "Instance.h"
+#include "JSBigString.h"
+#include "MessageQueueThread.h"
+#include "MethodCall.h"
+#include "ModuleRegistry.h"
+#include "RAMBundleRegistry.h"
+#include "SystraceSection.h"
+
+#include <memory>
+
+#ifdef WITH_FBSYSTRACE
+#include <fbsystrace.h>
+#include <jsi/jsi/jsi.h>
+
+using fbsystrace::FbSystraceAsyncFlow;
+#endif
+
+namespace facebook {
+namespace react {
+
+// This class manages calls from JS to native code.
+class JsToNativeBridge : public react::ExecutorDelegate {
+ public:
+  JsToNativeBridge(
+      std::shared_ptr<ModuleRegistry> registry,
+      std::shared_ptr<InstanceCallback> callback)
+      : m_registry(registry), m_callback(callback) {}
+
+  std::shared_ptr<ModuleRegistry> getModuleRegistry() override {
+    return m_registry;
+  }
+
+  bool isBatchActive() {
+    return m_batchHadNativeModuleOrTurboModuleCalls;
+  }
+
+  void callNativeModules(
+      __unused JSExecutor &executor,
+      folly::dynamic &&calls,
+      bool isEndOfBatch) override {
+    CHECK(m_registry || calls.empty())
+        << "native module calls cannot be completed with no native modules";
+    m_batchHadNativeModuleOrTurboModuleCalls =
+        m_batchHadNativeModuleOrTurboModuleCalls || !calls.empty();
+
+    std::vector<MethodCall> methodCalls = parseMethodCalls(std::move(calls));
+    BridgeNativeModulePerfLogger::asyncMethodCallBatchPreprocessEnd(
+        (int)methodCalls.size());
+
+    // An exception anywhere in here stops processing of the batch.  This
+    // was the behavior of the Android bridge, and since exception handling
+    // terminates the whole bridge, there's not much point in continuing.
+    for (auto &call : methodCalls) {
+      m_registry->callNativeMethod(
+          call.moduleId, call.methodId, std::move(call.arguments), call.callId);
+    }
+    if (isEndOfBatch) {
+      // onBatchComplete will be called on the native (module) queue, but
+      // decrementPendingJSCalls will be called sync. Be aware that the bridge
+      // may still be processing native calls when the bridge idle signaler
+      // fires.
+      if (m_batchHadNativeModuleOrTurboModuleCalls) {
+        m_callback->onBatchComplete();
+        m_batchHadNativeModuleOrTurboModuleCalls = false;
+      }
+      m_callback->decrementPendingJSCalls();
+    }
+  }
+
+  MethodCallResult callSerializableNativeHook(
+      __unused JSExecutor &executor,
+      unsigned int moduleId,
+      unsigned int methodId,
+      folly::dynamic &&args) override {
+    return m_registry->callSerializableNativeHook(
+        moduleId, methodId, std::move(args));
+  }
+
+  void recordTurboModuleAsyncMethodCall() {
+    m_batchHadNativeModuleOrTurboModuleCalls = true;
+  }
+
+ private:
+  // These methods are always invoked from an Executor.  The NativeToJsBridge
+  // keeps a reference to the executor, and when destroy() is called, the
+  // executor is destroyed synchronously on its queue.
+  std::shared_ptr<ModuleRegistry> m_registry;
+  std::shared_ptr<InstanceCallback> m_callback;
+  bool m_batchHadNativeModuleOrTurboModuleCalls = false;
+};
+
+NativeToJsBridge::NativeToJsBridge(
+    JSExecutorFactory *jsExecutorFactory,
+    std::shared_ptr<ModuleRegistry> registry,
+    std::shared_ptr<MessageQueueThread> jsQueue,
+    std::shared_ptr<InstanceCallback> callback)
+    : m_destroyed(std::make_shared<bool>(false)),
+      m_delegate(std::make_shared<JsToNativeBridge>(registry, callback)),
+      m_executor(jsExecutorFactory->createJSExecutor(m_delegate, jsQueue)),
+      m_executorMessageQueueThread(std::move(jsQueue)),
+      m_inspectable(m_executor->isInspectable()) {}
+
+// This must be called on the same thread on which the constructor was called.
+NativeToJsBridge::~NativeToJsBridge() {
+  CHECK(*m_destroyed)
+      << "NativeToJsBridge::destroy() must be called before deallocating the NativeToJsBridge!";
+}
+
+void NativeToJsBridge::initializeRuntime() {
+  runOnExecutorQueue(
+      [](JSExecutor *executor) mutable { executor->initializeRuntime(); });
+}
+
+void NativeToJsBridge::loadBundle(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string startupScriptSourceURL) {
+  runOnExecutorQueue(
+      [this,
+       bundleRegistryWrap = folly::makeMoveWrapper(std::move(bundleRegistry)),
+       startupScript = folly::makeMoveWrapper(std::move(startupScript)),
+       startupScriptSourceURL =
+           std::move(startupScriptSourceURL)](JSExecutor *executor) mutable {
+        auto bundleRegistry = bundleRegistryWrap.move();
+        if (bundleRegistry) {
+          executor->setBundleRegistry(std::move(bundleRegistry));
+        }
+        try {
+          executor->loadBundle(
+              std::move(*startupScript), std::move(startupScriptSourceURL));
+        } catch (...) {
+          m_applicationScriptHasFailure = true;
+          throw;
+        }
+      });
+}
+
+void NativeToJsBridge::loadBundleSync(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string startupScriptSourceURL) {
+  if (bundleRegistry) {
+    m_executor->setBundleRegistry(std::move(bundleRegistry));
+  }
+  try {
+    m_executor->loadBundle(
+        std::move(startupScript), std::move(startupScriptSourceURL));
+  } catch (...) {
+    m_applicationScriptHasFailure = true;
+    throw;
+  }
+}
+
+void NativeToJsBridge::callFunction(
+    std::string &&module,
+    std::string &&method,
+    folly::dynamic &&arguments) {
+  int systraceCookie = -1;
+#ifdef WITH_FBSYSTRACE
+  systraceCookie = m_systraceCookie++;
+  FbSystraceAsyncFlow::begin(
+      TRACE_TAG_REACT_CXX_BRIDGE, "JSCall", systraceCookie);
+#endif
+
+  runOnExecutorQueue([this,
+                      module = std::move(module),
+                      method = std::move(method),
+                      arguments = std::move(arguments),
+                      systraceCookie](JSExecutor *executor) {
+    if (m_applicationScriptHasFailure) {
+      LOG(ERROR)
+          << "Attempting to call JS function on a bad application bundle: "
+          << module.c_str() << "." << method.c_str() << "()";
+      throw std::runtime_error(
+          "Attempting to call JS function on a bad application bundle: " +
+          module + "." + method + "()");
+    }
+
+#ifdef WITH_FBSYSTRACE
+    FbSystraceAsyncFlow::end(
+        TRACE_TAG_REACT_CXX_BRIDGE, "JSCall", systraceCookie);
+    SystraceSection s(
+        "NativeToJsBridge::callFunction", "module", module, "method", method);
+#else
+    (void)(systraceCookie);
+#endif
+    // This is safe because we are running on the executor's thread: it won't
+    // destruct until after it's been unregistered (which we check above) and
+    // that will happen on this thread
+    executor->callFunction(module, method, arguments);
+  });
+}
+
+void NativeToJsBridge::invokeCallback(
+    double callbackId,
+    folly::dynamic &&arguments) {
+  int systraceCookie = -1;
+#ifdef WITH_FBSYSTRACE
+  systraceCookie = m_systraceCookie++;
+  FbSystraceAsyncFlow::begin(
+      TRACE_TAG_REACT_CXX_BRIDGE, "<callback>", systraceCookie);
+#endif
+
+  runOnExecutorQueue(
+      [this, callbackId, arguments = std::move(arguments), systraceCookie](
+          JSExecutor *executor) {
+        if (m_applicationScriptHasFailure) {
+          LOG(ERROR)
+              << "Attempting to call JS callback on a bad application bundle: "
+              << callbackId;
+          throw std::runtime_error(
+              "Attempting to invoke JS callback on a bad application bundle.");
+        }
+#ifdef WITH_FBSYSTRACE
+        FbSystraceAsyncFlow::end(
+            TRACE_TAG_REACT_CXX_BRIDGE, "<callback>", systraceCookie);
+        SystraceSection s("NativeToJsBridge::invokeCallback");
+#else
+        (void)(systraceCookie);
+#endif
+        executor->invokeCallback(callbackId, arguments);
+      });
+}
+
+void NativeToJsBridge::registerBundle(
+    uint32_t bundleId,
+    const std::string &bundlePath) {
+  runOnExecutorQueue([bundleId, bundlePath](JSExecutor *executor) {
+    executor->registerBundle(bundleId, bundlePath);
+  });
+}
+
+void NativeToJsBridge::setGlobalVariable(
+    std::string propName,
+    std::unique_ptr<const JSBigString> jsonValue) {
+  runOnExecutorQueue([propName = std::move(propName),
+                      jsonValue = folly::makeMoveWrapper(std::move(jsonValue))](
+                         JSExecutor *executor) mutable {
+    executor->setGlobalVariable(propName, jsonValue.move());
+  });
+}
+
+void *NativeToJsBridge::getJavaScriptContext() {
+  // TODO(cjhopman): this seems unsafe unless we require that it is only called
+  // on the main js queue.
+  return m_executor->getJavaScriptContext();
+}
+
+bool NativeToJsBridge::isInspectable() {
+  return m_inspectable;
+}
+
+bool NativeToJsBridge::isBatchActive() {
+  return m_delegate->isBatchActive();
+}
+
+void NativeToJsBridge::handleMemoryPressure(int pressureLevel) {
+  runOnExecutorQueue([=](JSExecutor *executor) {
+    executor->handleMemoryPressure(pressureLevel);
+  });
+}
+
+void NativeToJsBridge::destroy() {
+  // All calls made through runOnExecutorQueue have an early exit if
+  // m_destroyed is true. Setting this before the runOnQueueSync will cause
+  // pending work to be cancelled and we won't have to wait for it.
+  *m_destroyed = true;
+  m_executorMessageQueueThread->runOnQueueSync([this] {
+    m_executor->destroy();
+    m_executorMessageQueueThread->quitSynchronous();
+    m_executor = nullptr;
+  });
+}
+
+void NativeToJsBridge::runOnExecutorQueue(
+    std::function<void(JSExecutor *)> task) {
+  if (*m_destroyed) {
+    return;
+  }
+
+  std::shared_ptr<bool> isDestroyed = m_destroyed;
+  m_executorMessageQueueThread->runOnQueue(
+      [this, isDestroyed, task = std::move(task)] {
+        if (*isDestroyed) {
+          return;
+        }
+
+        // The executor is guaranteed to be valid for the duration of the task
+        // because:
+        // 1. the executor is only destroyed after it is unregistered
+        // 2. the executor is unregistered on this queue
+        // 3. we just confirmed that the executor hasn't been unregistered above
+        task(m_executor.get());
+      });
+}
+
+std::shared_ptr<CallInvoker> NativeToJsBridge::getDecoratedNativeCallInvoker(
+    std::shared_ptr<CallInvoker> nativeInvoker) {
+  class NativeCallInvoker : public CallInvoker {
+   private:
+    std::weak_ptr<JsToNativeBridge> m_jsToNativeBridge;
+    std::shared_ptr<CallInvoker> m_nativeInvoker;
+
+   public:
+    NativeCallInvoker(
+        std::weak_ptr<JsToNativeBridge> jsToNativeBridge,
+        std::shared_ptr<CallInvoker> nativeInvoker)
+        : m_jsToNativeBridge(jsToNativeBridge),
+          m_nativeInvoker(nativeInvoker) {}
+
+    void invokeAsync(std::function<void()> &&func) override {
+      if (auto strongJsToNativeBridge = m_jsToNativeBridge.lock()) {
+        strongJsToNativeBridge->recordTurboModuleAsyncMethodCall();
+      }
+      m_nativeInvoker->invokeAsync(std::move(func));
+    }
+
+    void invokeSync(std::function<void()> &&func) override {
+      m_nativeInvoker->invokeSync(std::move(func));
+    }
+  };
+
+  return std::make_shared<NativeCallInvoker>(m_delegate, nativeInvoker);
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/text/BaseTextProps.cpp

@@ -0,0 +1,313 @@
+/*
+ * 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.
+ */
+
+#include "BaseTextProps.h"
+
+#include <react/renderer/attributedstring/conversions.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/debug/DebugStringConvertibleItem.h>
+#include <react/renderer/graphics/conversions.h>
+
+#define GET_FIELD_VALUE(field, fieldName, defaultValue, rawValue) \
+  (rawValue.hasValue() ? ([&rawValue,&context]{                   \
+    decltype(defaultValue) res;                                   \
+    fromRawValue(context, rawValue, res);                         \
+    return res;                                                   \
+  }())                                                            \
+                       : defaultValue);
+
+#define REBUILD_FIELD_SWITCH_CASE(                                   \
+    defaults, rawValue, property, field, fieldName)                  \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                    \
+    property.field =                                                 \
+        GET_FIELD_VALUE(field, fieldName, defaults.field, rawValue); \
+    return;                                                          \
+  }
+
+
+namespace facebook {
+namespace react {
+
+bool BaseTextProps::enablePropIteratorSetter = false;
+
+static TextAttributes convertRawProp(
+    PropsParserContext const &context,
+    RawProps const &rawProps,
+    TextAttributes const &sourceTextAttributes,
+    TextAttributes const &defaultTextAttributes) {
+  auto textAttributes = TextAttributes{};
+
+  // Color (not accessed by ViewProps)
+  textAttributes.foregroundColor = convertRawProp(
+      context,
+      rawProps,
+      "color",
+      sourceTextAttributes.foregroundColor,
+      defaultTextAttributes.foregroundColor);
+
+  // Font
+  textAttributes.fontFamily = convertRawProp(
+      context,
+      rawProps,
+      "fontFamily",
+      sourceTextAttributes.fontFamily,
+      defaultTextAttributes.fontFamily);
+  textAttributes.fontSize = convertRawProp(
+      context,
+      rawProps,
+      "fontSize",
+      sourceTextAttributes.fontSize,
+      defaultTextAttributes.fontSize);
+  textAttributes.fontSizeMultiplier = convertRawProp(
+      context,
+      rawProps,
+      "fontSizeMultiplier",
+      sourceTextAttributes.fontSizeMultiplier,
+      defaultTextAttributes.fontSizeMultiplier);
+  textAttributes.fontWeight = convertRawProp(
+      context,
+      rawProps,
+      "fontWeight",
+      sourceTextAttributes.fontWeight,
+      defaultTextAttributes.fontWeight);
+  textAttributes.fontStyle = convertRawProp(
+      context,
+      rawProps,
+      "fontStyle",
+      sourceTextAttributes.fontStyle,
+      defaultTextAttributes.fontStyle);
+  textAttributes.fontVariant = convertRawProp(
+      context,
+      rawProps,
+      "fontVariant",
+      sourceTextAttributes.fontVariant,
+      defaultTextAttributes.fontVariant);
+  textAttributes.allowFontScaling = convertRawProp(
+      context,
+      rawProps,
+      "allowFontScaling",
+      sourceTextAttributes.allowFontScaling,
+      defaultTextAttributes.allowFontScaling);
+  textAttributes.letterSpacing = convertRawProp(
+      context,
+      rawProps,
+      "letterSpacing",
+      sourceTextAttributes.letterSpacing,
+      defaultTextAttributes.letterSpacing);
+  textAttributes.textTransform = convertRawProp(
+      context,
+      rawProps,
+      "textTransform",
+      sourceTextAttributes.textTransform,
+      defaultTextAttributes.textTransform);
+
+  // Paragraph
+  textAttributes.lineHeight = convertRawProp(
+      context,
+      rawProps,
+      "lineHeight",
+      sourceTextAttributes.lineHeight,
+      defaultTextAttributes.lineHeight);
+  textAttributes.alignment = convertRawProp(
+      context,
+      rawProps,
+      "textAlign",
+      sourceTextAttributes.alignment,
+      defaultTextAttributes.alignment);
+  textAttributes.baseWritingDirection = convertRawProp(
+      context,
+      rawProps,
+      "baseWritingDirection",
+      sourceTextAttributes.baseWritingDirection,
+      defaultTextAttributes.baseWritingDirection);
+
+  // Decoration
+  textAttributes.textDecorationColor = convertRawProp(
+      context,
+      rawProps,
+      "textDecorationColor",
+      sourceTextAttributes.textDecorationColor,
+      defaultTextAttributes.textDecorationColor);
+  textAttributes.textDecorationLineType = convertRawProp(
+      context,
+      rawProps,
+      "textDecorationLine",
+      sourceTextAttributes.textDecorationLineType,
+      defaultTextAttributes.textDecorationLineType);
+  textAttributes.textDecorationStyle = convertRawProp(
+      context,
+      rawProps,
+      "textDecorationStyle",
+      sourceTextAttributes.textDecorationStyle,
+      defaultTextAttributes.textDecorationStyle);
+
+  // Shadow
+  textAttributes.textShadowOffset = convertRawProp(
+      context,
+      rawProps,
+      "textShadowOffset",
+      sourceTextAttributes.textShadowOffset,
+      defaultTextAttributes.textShadowOffset);
+  textAttributes.textShadowRadius = convertRawProp(
+      context,
+      rawProps,
+      "textShadowRadius",
+      sourceTextAttributes.textShadowRadius,
+      defaultTextAttributes.textShadowRadius);
+  textAttributes.textShadowColor = convertRawProp(
+      context,
+      rawProps,
+      "textShadowColor",
+      sourceTextAttributes.textShadowColor,
+      defaultTextAttributes.textShadowColor);
+
+  // Special
+  textAttributes.isHighlighted = convertRawProp(
+      context,
+      rawProps,
+      "isHighlighted",
+      sourceTextAttributes.isHighlighted,
+      defaultTextAttributes.isHighlighted);
+
+  // In general, we want this class to access props in the same order
+  // that ViewProps accesses them in, so that RawPropParser can optimize
+  // accesses. This is both theoretical, and ParagraphProps takes advantage
+  // of this.
+  // In particular: accessibilityRole, opacity, and backgroundColor also
+  // are parsed first by ViewProps (and indirectly AccessibilityProps).
+  // However, since RawPropsParser will always store these props /before/
+  // the unique BaseTextProps props, it is most efficient to parse these, in
+  // order, /after/ all of the other BaseTextProps, so that the RawPropsParser
+  // index rolls over only once instead of twice.
+  textAttributes.accessibilityRole = convertRawProp(
+      context,
+      rawProps,
+      "accessibilityRole",
+      sourceTextAttributes.accessibilityRole,
+      defaultTextAttributes.accessibilityRole);
+
+  // Color (accessed in this order by ViewProps)
+  textAttributes.opacity = convertRawProp(
+      context,
+      rawProps,
+      "opacity",
+      sourceTextAttributes.opacity,
+      defaultTextAttributes.opacity);
+  textAttributes.backgroundColor = convertRawProp(
+      context,
+      rawProps,
+      "backgroundColor",
+      sourceTextAttributes.backgroundColor,
+      defaultTextAttributes.backgroundColor);
+
+  return textAttributes;
+}
+
+BaseTextProps::BaseTextProps(
+    const PropsParserContext &context,
+    const BaseTextProps &sourceProps,
+    const RawProps &rawProps)
+    : textAttributes(
+          BaseTextProps::enablePropIteratorSetter
+              ? sourceProps.textAttributes
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    sourceProps.textAttributes,
+                    TextAttributes{})){};
+
+void BaseTextProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  static auto defaults = TextAttributes{};
+
+  switch (hash) {
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, foregroundColor, "color");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, fontFamily, "fontFamily");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, fontSize, "fontSize");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        fontSizeMultiplier,
+        "fontSizeMultiplier");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, fontWeight, "fontWeight");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, fontStyle, "fontStyle");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, fontVariant, "fontVariant");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, allowFontScaling, "allowFontScaling");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, letterSpacing, "letterSpacing");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, textTransform, "textTransform");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, lineHeight, "lineHeight");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, alignment, "textAlign");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        baseWritingDirection,
+        "baseWritingDirection");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        textDecorationColor,
+        "textDecorationColor");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        textDecorationLineType,
+        "textDecorationLine");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        textDecorationStyle,
+        "textDecorationStyle");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, textShadowOffset, "textShadowOffset");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, textShadowRadius, "textShadowRadius");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, textShadowColor, "textShadowColor");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, isHighlighted, "isHighlighted");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults,
+        value,
+        textAttributes,
+        accessibilityRole,
+        "accessibilityRole");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, opacity, "opacity");
+    REBUILD_FIELD_SWITCH_CASE(
+        defaults, value, textAttributes, backgroundColor, "backgroundColor");
+  }
+}
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList BaseTextProps::getDebugProps() const {
+  return textAttributes.getDebugProps();
+}
+#endif
+
+} // namespace react
+} // namespace facebook