react-native-windows 0.70.7 → 0.71.0-preview.1

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/slider/SliderMeasurementsManager.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <CppWinrtIncludes.h>
-#include <UI.Xaml.Controls.h>
-#include <react/renderer/core/ConcreteComponentDescriptor.h>
-#include <react/renderer/core/LayoutConstraints.h>
-#include <react/utils/ContextContainer.h>
-
-namespace facebook::react {
-
-/**
- * Class that manages slider measurements across platforms.
- * On iOS it is a noop, since the height is passed in from JS on iOS only.
- */
-class SliderMeasurementsManager {
- public:
-  SliderMeasurementsManager(const ContextContainer::Shared &contextContainer) : m_contextContainer(contextContainer) {}
-
-  static inline bool shouldMeasureSlider() {
-    return true;
-  }
-
-  Size measure(SurfaceId surfaceId, LayoutConstraints layoutConstraints) const;
-
- private:
-  ContextContainer::Shared m_contextContainer;
-  mutable xaml::Controls::Slider m_slider{nullptr};
-};
-
-} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/JSExecutor.h

@@ -1,145 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include <cxxreact/NativeModule.h>
-#include <folly/dynamic.h>
-
-#ifndef RN_EXPORT
-#define RN_EXPORT __attribute__((visibility("default")))
-#endif
-
-namespace facebook {
-namespace react {
-
-class JSBigString;
-class JSExecutor;
-class JSModulesUnbundle;
-class MessageQueueThread;
-class ModuleRegistry;
-class RAMBundleRegistry;
-
-// This interface describes the delegate interface required by
-// Executor implementations to call from JS into native code.
-class ExecutorDelegate {
- public:
-  virtual ~ExecutorDelegate() {}
-
-  virtual std::shared_ptr<ModuleRegistry> getModuleRegistry() = 0;
-
-  virtual void callNativeModules(
-      JSExecutor &executor,
-      folly::dynamic &&calls,
-      bool isEndOfBatch) = 0;
-  virtual MethodCallResult callSerializableNativeHook(
-      JSExecutor &executor,
-      unsigned int moduleId,
-      unsigned int methodId,
-      folly::dynamic &&args) = 0;
-};
-
-using NativeExtensionsProvider =
-    std::function<folly::dynamic(const std::string &)>;
-
-class JSExecutorFactory {
- public:
-  virtual std::unique_ptr<JSExecutor> createJSExecutor(
-      std::shared_ptr<ExecutorDelegate> delegate,
-      std::shared_ptr<MessageQueueThread> jsQueue) = 0;
-  virtual ~JSExecutorFactory() {}
-};
-
-class RN_EXPORT JSExecutor {
- public:
-  /**
-   * Prepares the JS runtime for React Native by installing global variables.
-   * Called once before any JS is evaluated.
-   */
-  virtual void initializeRuntime() = 0;
-  /**
-   * Execute an application script bundle in the JS context.
-   */
-  virtual void loadBundle(
-      std::unique_ptr<const JSBigString> script,
-      std::string sourceURL) = 0;
-
-  /**
-   * Add an application "RAM" bundle registry
-   */
-  virtual void setBundleRegistry(
-      std::unique_ptr<RAMBundleRegistry> bundleRegistry) = 0;
-
-  /**
-   * Register a file path for an additional "RAM" bundle
-   */
-  virtual void registerBundle(
-      uint32_t bundleId,
-      const std::string &bundlePath) = 0;
-
-  /**
-   * Executes BatchedBridge.callFunctionReturnFlushedQueue with the module ID,
-   * method ID and optional additional arguments in JS. The executor is
-   * responsible for using Bridge->callNativeModules to invoke any necessary
-   * native modules methods.
-   */
-  virtual void callFunction(
-      const std::string &moduleId,
-      const std::string &methodId,
-      const folly::dynamic &arguments) = 0;
-
-  /**
-   * Executes BatchedBridge.invokeCallbackAndReturnFlushedQueue with the cbID,
-   * and optional additional arguments in JS and returns the next queue. The
-   * executor is responsible for using Bridge->callNativeModules to invoke any
-   * necessary native modules methods.
-   */
-  virtual void invokeCallback(
-      const double callbackId,
-      const folly::dynamic &arguments) = 0;
-
-  virtual void setGlobalVariable(
-      std::string propName,
-      std::unique_ptr<const JSBigString> jsonValue) = 0;
-
-  virtual void *getJavaScriptContext() {
-    return nullptr;
-  }
-
-  /**
-   * Returns whether or not the underlying executor supports debugging via the
-   * Chrome remote debugging protocol.
-   */
-  virtual bool isInspectable() {
-    return false;
-  }
-
-  /**
-   * The description is displayed in the dev menu, if there is one in
-   * this build.  There is a default, but if this method returns a
-   * non-empty string, it will be used instead.
-   */
-  virtual std::string getDescription() = 0;
-
-  virtual void handleMemoryPressure(__unused int pressureLevel) {
-  }
-
-  virtual void destroy() {}
-  virtual ~JSExecutor() {}
-
-  virtual void flush() {}
-
-  static std::string getSyntheticBundlePath(
-      uint32_t bundleId,
-      const std::string &bundlePath);
-};
-
-} // namespace react
-} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/NativeToJsBridge.cpp

@@ -1,344 +0,0 @@
-/*
- * 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