react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactCommon/jsinspector-modern/NetworkIOAgent.h

@@ -0,0 +1,266 @@
+/*
+ * 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 "CdpJson.h"
+#include "InspectorInterfaces.h"
+#include "ScopedExecutor.h"
+
+#include <folly/dynamic.h>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+
+namespace facebook::react::jsinspector_modern {
+
+using StreamID = const std::string;
+using Headers = std::map<std::string, std::string>;
+using IOReadError = const std::string;
+
+namespace {
+class Stream; // Defined in NetworkIOAgent.cpp
+using StreamsMap = std::unordered_map<std::string, std::shared_ptr<Stream>>;
+} // namespace
+
+struct LoadNetworkResourceRequest {
+  std::string url;
+};
+
+struct ReadStreamParams {
+  StreamID handle;
+  std::optional<unsigned long> size;
+  std::optional<unsigned long> offset;
+};
+
+struct NetworkResource {
+  bool success{};
+  std::optional<std::string> stream;
+  std::optional<int> httpStatusCode;
+  std::optional<std::string> netErrorName;
+  std::optional<Headers> headers;
+  folly::dynamic toDynamic() const {
+    auto dynamicResource = folly::dynamic::object("success", success);
+
+    if (success) { // stream IFF successful
+      assert(stream);
+      dynamicResource("stream", *stream);
+    }
+
+    if (netErrorName) { // Only if unsuccessful
+      assert(!success);
+      dynamicResource("netErrorName", *netErrorName);
+    }
+
+    if (httpStatusCode) { // Guaranteed if successful
+      dynamicResource("httpStatusCode", *httpStatusCode);
+    } else {
+      assert(!success);
+    }
+
+    if (headers) { // Guaranteed if successful
+      auto dynamicHeaders = folly::dynamic::object();
+      for (const auto& pair : *headers) {
+        dynamicHeaders(pair.first, pair.second);
+      }
+      dynamicResource("headers", std::move(dynamicHeaders));
+    } else {
+      assert(!success);
+    }
+    return dynamicResource;
+  }
+};
+
+struct IOReadResult {
+  std::string data;
+  bool eof;
+  bool base64Encoded;
+  folly::dynamic toDynamic() const {
+    auto obj = folly::dynamic::object("data", data);
+    obj("eof", eof);
+    obj("base64Encoded", base64Encoded);
+    return obj;
+  }
+};
+
+/**
+ * Passed to `loadNetworkResource`, provides callbacks for processing incoming
+ * data and other events.
+ */
+class NetworkRequestListener {
+ public:
+  NetworkRequestListener() = default;
+  NetworkRequestListener(const NetworkRequestListener&) = delete;
+  NetworkRequestListener& operator=(const NetworkRequestListener&) = delete;
+  NetworkRequestListener(NetworkRequestListener&&) noexcept = default;
+  NetworkRequestListener& operator=(NetworkRequestListener&&) noexcept =
+      default;
+  virtual ~NetworkRequestListener() = default;
+
+  /**
+   * To be called by the delegate on receipt of response headers, including
+   * on "unsuccessful" status codes.
+   *
+   * \param httpStatusCode The HTTP status code received.
+   * \param headers Response headers as an unordered_map.
+   */
+  virtual void onHeaders(int httpStatusCode, const Headers& headers) = 0;
+
+  /**
+   * To be called by the delegate on receipt of data chunks.
+   * \param data The data received.
+   */
+  virtual void onData(std::string_view data) = 0;
+
+  /**
+   * To be called by the delegate on any error with the request, either before
+   * headers are received or for a subsequent interrupion.
+   *
+   * \param message A short, human-readable message, which may be forwarded to
+   * the CDP client either in the `loadNetworkResource` response (if headers
+   * were not yet received), or as a CDP error in response to a subsequent
+   * `IO.read`.
+   */
+  virtual void onError(const std::string& message) = 0;
+
+  /**
+   * To be called by the delegate on successful completion of the request.
+   * Delegates must call *either* onCompletion() or onError() exactly once.
+   */
+  virtual void onCompletion() = 0;
+
+  /**
+   * Optionally (preferably) used to give NetworkIOAgent
+    a way to cancel an
+   * in-progress download.
+   *
+   * \param cancelFunction A function that can be called to cancel a download,
+   * may be called before or after the download is complete.
+   */
+  virtual void setCancelFunction(std::function<void()> cancelFunction) = 0;
+};
+
+/**
+ * Implemented by the HostTargetDelegate per-platform to perform network
+ * requests.
+ */
+class LoadNetworkResourceDelegate {
+ public:
+  LoadNetworkResourceDelegate() = default;
+  LoadNetworkResourceDelegate(const LoadNetworkResourceDelegate&) = delete;
+  LoadNetworkResourceDelegate& operator=(const LoadNetworkResourceDelegate&) =
+      delete;
+  LoadNetworkResourceDelegate(LoadNetworkResourceDelegate&&) noexcept = delete;
+  LoadNetworkResourceDelegate& operator=(
+      LoadNetworkResourceDelegate&&) noexcept = delete;
+  virtual ~LoadNetworkResourceDelegate() = default;
+
+  /**
+   * Called by NetworkIOAgent on handling a
+   * `Network.loadNetworkResource` CDP request. Platform implementations should
+   * override this to perform a network request of the given URL, and use
+   * listener's callbacks (via the executor) on receipt of headers, data chunks,
+   * and errors.
+   *
+   * \param params A LoadNetworkResourceRequest, including the url.
+   * \param executor A listener-scoped executor used by the delegate to execute
+   * listener callbacks on headers, data chunks, and errors. Implementations
+   * *should* call listener->setCancelFunction() to provide a lambda that can be
+   * called to abort any in-flight network operation that is no longer needed.
+   */
+  virtual void loadNetworkResource(
+      [[maybe_unused]] const LoadNetworkResourceRequest& params,
+      [[maybe_unused]] ScopedExecutor<NetworkRequestListener> executor) = 0;
+};
+
+/**
+ * Provides an agent for handling CDP's Network.loadNetworkResource, IO.read and
+ * IO.close.
+ *
+ * Owns state of all in-progress and completed HTTP requests - ensure
+ * IO.close is used to free resources once consumed.
+ *
+ * Public methods must be called the same thread as the given executor.
+ */
+class NetworkIOAgent {
+ public:
+  /**
+   * \param frontendChannel A channel used to send responses to the
+   * frontend.
+   * \param executor An executor used for any callbacks provided, and for
+   * processing incoming data or other events from network operations.
+   */
+  NetworkIOAgent(FrontendChannel frontendChannel, VoidExecutor executor)
+      : frontendChannel_(frontendChannel),
+        executor_(executor),
+        streams_(std::make_shared<StreamsMap>()) {}
+
+  /**
+   * Handle a CDP request. The response will be sent over the provided
+   * \c FrontendChannel synchronously or asynchronously.
+   * \param req The parsed request.
+   */
+  bool handleRequest(
+      const cdp::PreparsedRequest& req,
+      LoadNetworkResourceDelegate& delegate);
+
+ private:
+  /**
+   * A channel used to send responses and events to the frontend.
+   */
+  FrontendChannel frontendChannel_;
+
+  /**
+   * An executor used to create NetworkRequestListener-scoped executors for the
+   * delegate.
+   */
+  VoidExecutor executor_;
+
+  /**
+   * Map of stream objects, which contain data received, accept read requests
+   * and listen for delegate events. Delegates have a scoped executor for Stream
+   * instances, but Streams will not live beyond the destruction of this
+   * NetworkIOAgent instance + executor scope.
+   *
+   * This is a shared_ptr so that we may capture a weak_ptr in our
+   * Stream::create callback without creating a cycle.
+   */
+  std::shared_ptr<StreamsMap> streams_;
+
+  /**
+   * Stream IDs are strings of an incrementing integer, unique within each
+   * NewtworkIOAgent instance. This stores the next one to use.
+   */
+  unsigned long nextStreamId_{0};
+
+  /**
+   * Begin loading an HTTP resource, delegating platform-specific
+   * implementation, responding to the frontend on headers received or on error.
+   * Does not catch exceptions thrown by the delegate (such as
+   * NotImplementedException).
+   */
+  void handleLoadNetworkResource(
+      const cdp::PreparsedRequest& req,
+      LoadNetworkResourceDelegate& delegate);
+
+  /**
+   * Handle an IO.read CDP request. Emit a chunk of data from the stream, once
+   * enough has been downloaded, or report an error.
+   */
+  void handleIoRead(const cdp::PreparsedRequest& req);
+
+  /**
+   * Handle an IO.close CDP request. Safely aborts any in-flight request.
+   * Reports CDP ok if the stream is found, or a CDP error if not.
+   */
+  void handleIoClose(const cdp::PreparsedRequest& req);
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/React-jsinspector.podspec

@@ -54,6 +54,7 @@ Pod::Spec.new do |s|
   s.dependency "DoubleConversion"
   s.dependency "React-runtimeexecutor", version
   s.dependency "React-jsi"
+  s.dependency "React-perflogger", version
   if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
     s.dependency "hermes-engine"
   end

package/ReactCommon/jsinspector-modern/RuntimeAgent.cpp

@@ -26,6 +26,11 @@ RuntimeAgent::RuntimeAgent(
       targetController_.installBindingHandler(name);
     }
   }
+
+  if (sessionState_.isRuntimeDomainEnabled &&
+      sessionState_.isLogDomainEnabled) {
+    targetController_.notifyDebuggerSessionCreated();
+  }
 }
 
 bool RuntimeAgent::handleRequest(const cdp::PreparsedRequest& req) {
@@ -83,6 +88,18 @@ bool RuntimeAgent::handleRequest(const cdp::PreparsedRequest& req) {
 
     return true;
   }
+  if (req.method == "Runtime.enable" && sessionState_.isLogDomainEnabled) {
+    targetController_.notifyDebuggerSessionCreated();
+  }
+  if (req.method == "Log.enable" && sessionState_.isRuntimeDomainEnabled) {
+    targetController_.notifyDebuggerSessionCreated();
+  }
+  if (req.method == "Runtime.disable" && sessionState_.isLogDomainEnabled) {
+    targetController_.notifyDebuggerSessionDestroyed();
+  }
+  if (req.method == "Log.disable" && sessionState_.isRuntimeDomainEnabled) {
+    targetController_.notifyDebuggerSessionDestroyed();
+  }
   if (delegate_) {
     return delegate_->handleRequest(req);
   }
@@ -120,6 +137,11 @@ RuntimeAgent::ExportedState RuntimeAgent::getExportedState() {
 }
 
 RuntimeAgent::~RuntimeAgent() {
+  if (sessionState_.isRuntimeDomainEnabled &&
+      sessionState_.isLogDomainEnabled) {
+    targetController_.notifyDebuggerSessionDestroyed();
+  }
+
   // TODO: Eventually, there may be more than one Runtime per Page, and we'll
   // need to store multiple agent states here accordingly. For now let's do
   // the simple thing and assume (as we do elsewhere) that only one Runtime

package/ReactCommon/jsinspector-modern/RuntimeTarget.cpp

@@ -13,6 +13,21 @@ using namespace facebook::jsi;
 
 namespace facebook::react::jsinspector_modern {
 
+namespace {
+
+void emitSessionStatusChangeForObserverWithValue(
+    jsi::Runtime& runtime,
+    const jsi::Value& value) {
+  auto globalObj = runtime.global();
+  auto observer =
+      globalObj.getPropertyAsObject(runtime, "__DEBUGGER_SESSION_OBSERVER__");
+  auto onSessionStatusChange =
+      observer.getPropertyAsFunction(runtime, "onSessionStatusChange");
+  onSessionStatusChange.call(runtime, value);
+}
+
+} // namespace
+
 std::shared_ptr<RuntimeTarget> RuntimeTarget::create(
     const ExecutionContextDescription& executionContextDescription,
     RuntimeTargetDelegate& delegate,
@@ -36,6 +51,7 @@ RuntimeTarget::RuntimeTarget(
 void RuntimeTarget::installGlobals() {
   // NOTE: RuntimeTarget::installConsoleHandler is in RuntimeTargetConsole.cpp
   installConsoleHandler();
+  installDebuggerSessionObserver();
 }
 
 std::shared_ptr<RuntimeAgent> RuntimeTarget::createAgent(
@@ -105,6 +121,28 @@ void RuntimeTarget::installBindingHandler(const std::string& bindingName) {
   });
 }
 
+void RuntimeTarget::emitDebuggerSessionCreated() {
+  jsExecutor_([selfExecutor = executorFromThis()](jsi::Runtime& runtime) {
+    try {
+      emitSessionStatusChangeForObserverWithValue(runtime, jsi::Value(true));
+    } catch (jsi::JSError&) {
+      // Suppress any errors, they should not be visible to the user
+      // and should not affect runtime.
+    }
+  });
+}
+
+void RuntimeTarget::emitDebuggerSessionDestroyed() {
+  jsExecutor_([selfExecutor = executorFromThis()](jsi::Runtime& runtime) {
+    try {
+      emitSessionStatusChangeForObserverWithValue(runtime, jsi::Value(false));
+    } catch (jsi::JSError&) {
+      // Suppress any errors, they should not be visible to the user
+      // and should not affect runtime.
+    }
+  });
+}
+
 RuntimeTargetController::RuntimeTargetController(RuntimeTarget& target)
     : target_(target) {}
 
@@ -113,4 +151,12 @@ void RuntimeTargetController::installBindingHandler(
   target_.installBindingHandler(bindingName);
 }
 
+void RuntimeTargetController::notifyDebuggerSessionCreated() {
+  target_.emitDebuggerSessionCreated();
+}
+
+void RuntimeTargetController::notifyDebuggerSessionDestroyed() {
+  target_.emitDebuggerSessionDestroyed();
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/RuntimeTarget.h

@@ -106,6 +106,18 @@ class RuntimeTargetController {
    */
   void installBindingHandler(const std::string& bindingName);
 
+  /**
+   * Notifies the target to emit some message that debugger session is
+   * created.
+   */
+  void notifyDebuggerSessionCreated();
+
+  /**
+   * Notifies the target to emit some message that debugger session is
+   * destroyed.
+   */
+  void notifyDebuggerSessionDestroyed();
+
  private:
   RuntimeTarget& target_;
 };
@@ -206,6 +218,25 @@ class JSINSPECTOR_EXPORT RuntimeTarget
    */
   void installConsoleHandler();
 
+  /**
+   * Installs __DEBUGGER_SESSION_OBSERVER__ object on the JavaScript's global
+   * object, which later could be referenced from JavaScript side for
+   * determining the status of the debugger session.
+   */
+  void installDebuggerSessionObserver();
+
+  /**
+   * Propagates the debugger session state change to the JavaScript via calling
+   * onStatusChange on __DEBUGGER_SESSION_OBSERVER__.
+   */
+  void emitDebuggerSessionCreated();
+
+  /**
+   * Propagates the debugger session state change to the JavaScript via calling
+   * onStatusChange on __DEBUGGER_SESSION_OBSERVER__.
+   */
+  void emitDebuggerSessionDestroyed();
+
   // Necessary to allow RuntimeAgent to access RuntimeTarget's internals in a
   // controlled way (i.e. only RuntimeTargetController gets friend access, while
   // RuntimeAgent itself doesn't).

package/ReactCommon/jsinspector-modern/RuntimeTargetConsole.cpp

@@ -369,8 +369,8 @@ void RuntimeTarget::installConsoleHandler() {
         };
 
     /**
-     * Call \param innerFn and forward any arguments to the original console
-     * method named \param methodName, if possible.
+     * Call innerFn and forward any arguments to the original console method
+     * named methodName, if possible.
      */
     auto forwardToOriginalConsole = [originalConsole](
                                         const char* methodName,

package/ReactCommon/jsinspector-modern/RuntimeTargetDebuggerSessionObserver.cpp

@@ -0,0 +1,112 @@
+/*
+ * 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 <jsinspector-modern/RuntimeTarget.h>
+
+namespace facebook::react::jsinspector_modern {
+
+void RuntimeTarget::installDebuggerSessionObserver() {
+  jsExecutor_([](jsi::Runtime& runtime) {
+    auto globalObj = runtime.global();
+    try {
+      auto observer = jsi::Object(runtime);
+
+      observer.setProperty(runtime, "hasActiveSession", jsi::Value(false));
+
+      auto setFunction = globalObj.getPropertyAsFunction(runtime, "Set");
+      auto set = setFunction.callAsConstructor(runtime);
+      observer.setProperty(runtime, "subscribers", set);
+
+      observer.setProperty(
+          runtime,
+          "onSessionStatusChange",
+          jsi::Function::createFromHostFunction(
+              runtime,
+              jsi::PropNameID::forAscii(runtime, "onSessionStatusChange"),
+              1,
+              [](jsi::Runtime& onSessionStatusChangeRuntime,
+                 const jsi::Value& /* onSessionStatusChangeThisVal */,
+                 const jsi::Value* onSessionStatusChangeArgs,
+                 size_t onSessionStatusChangeArgsCount) {
+                if (onSessionStatusChangeArgsCount != 1 ||
+                    !onSessionStatusChangeArgs[0].isBool()) {
+                  throw jsi::JSError(
+                      onSessionStatusChangeRuntime,
+                      "Invalid arguments: onSessionStatusChange expects 1 boolean argument");
+                }
+
+                bool updatedStatus = onSessionStatusChangeArgs[0].getBool();
+
+                auto observerInstanceFromOnSessionStatusChange =
+                    onSessionStatusChangeRuntime.global().getPropertyAsObject(
+                        onSessionStatusChangeRuntime,
+                        "__DEBUGGER_SESSION_OBSERVER__");
+                auto subscribersToNotify =
+                    observerInstanceFromOnSessionStatusChange
+                        .getPropertyAsObject(
+                            onSessionStatusChangeRuntime, "subscribers");
+
+                observerInstanceFromOnSessionStatusChange.setProperty(
+                    onSessionStatusChangeRuntime,
+                    "hasActiveSession",
+                    updatedStatus);
+
+                if (subscribersToNotify
+                        .getProperty(onSessionStatusChangeRuntime, "size")
+                        .asNumber() == 0) {
+                  return jsi::Value::undefined();
+                }
+
+                auto forEachSubscriber =
+                    subscribersToNotify.getPropertyAsFunction(
+                        onSessionStatusChangeRuntime, "forEach");
+                auto forEachSubscriberCallback =
+                    jsi::Function::createFromHostFunction(
+                        onSessionStatusChangeRuntime,
+                        jsi::PropNameID::forAscii(
+                            onSessionStatusChangeRuntime, "forEachCallback"),
+                        1,
+                        [updatedStatus](
+                            jsi::Runtime& forEachCallbackRuntime,
+                            const jsi::Value& /* forEachCallbackThisVal */,
+                            const jsi::Value* forEachCallbackArgs,
+                            size_t forEachCallbackArgsCount) {
+                          if (forEachCallbackArgsCount < 1 ||
+                              !forEachCallbackArgs[0].isObject() ||
+                              !forEachCallbackArgs[0]
+                                   .getObject(forEachCallbackRuntime)
+                                   .isFunction(forEachCallbackRuntime)) {
+                            throw jsi::JSError(
+                                forEachCallbackRuntime,
+                                "Invalid arguments: forEachSubscriberCallback expects function as a first argument");
+                          }
+
+                          forEachCallbackArgs[0]
+                              .getObject(forEachCallbackRuntime)
+                              .asFunction(forEachCallbackRuntime)
+                              .call(forEachCallbackRuntime, updatedStatus);
+
+                          return jsi::Value::undefined();
+                        });
+
+                forEachSubscriber.callWithThis(
+                    onSessionStatusChangeRuntime,
+                    subscribersToNotify,
+                    forEachSubscriberCallback);
+
+                return jsi::Value::undefined();
+              }));
+
+      globalObj.setProperty(runtime, "__DEBUGGER_SESSION_OBSERVER__", observer);
+    } catch (jsi::JSError&) {
+      // Suppress any errors, they should not be visible to the user
+      // and should not affect runtime.
+    }
+  });
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/Utf8.h

@@ -0,0 +1,56 @@
+/*
+ * 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 <vector>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Takes a vector of bytes representing a fragment of a UTF-8 string, and
+ * removes the minimum number (0-3) of trailing bytes so that the remainder is
+ * valid UTF-8. Useful for slicing binary data into UTF-8 strings.
+ *
+ * \param buffer Buffer to operate on - will be resized if necessary.
+ */
+inline void truncateToValidUTF8(std::vector<char>& buffer) {
+  const auto length = buffer.size();
+  // Ensure we don't cut a UTF-8 code point in the middle by removing any
+  // trailing bytes representing an incomplete UTF-8 code point.
+
+  // If the last byte is a UTF-8 first byte or continuation byte (topmost bit
+  // is 1) (otherwise the last char is ASCII and we don't need to do
+  // anything).
+  if (length > 0 && (buffer[length - 1] & 0b10000000) == 0b10000000) {
+    int continuationBytes = 0;
+    // Find the first byte of the UTF-8 code point (topmost bits 11) and count
+    // the number of continuation bytes following it.
+    while ((buffer[length - continuationBytes - 1] & 0b11000000) !=
+           0b11000000) {
+      continuationBytes++;
+      if (continuationBytes > 3 || continuationBytes >= length - 1) {
+        throw std::runtime_error("Invalid UTF-8 sequence");
+      }
+    }
+    char firstByteOfSequence = buffer[length - continuationBytes - 1];
+    // Check for the special case that our original cut point was at the end
+    // of a UTF-8 code-point, and therefore already valid. This will be the
+    // case if the first byte indicates continuationBytes continuation bytes
+    // should follow, i.e. its top bits are (1+continuationBytes) 1's followed
+    // by a 0.
+    char mask = static_cast<char>(0b11111000 << (3 - continuationBytes));
+    char expectedBitsAfterMask = static_cast<char>(mask << 1);
+    if (continuationBytes == 0 ||
+        (firstByteOfSequence & mask) != expectedBitsAfterMask) {
+      // Remove the trailing continuation bytes, if any, and the first byte.
+      buffer.resize(length - (continuationBytes + 1));
+    }
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/WebSocketInterfaces.h

@@ -39,6 +39,8 @@ class IWebSocketDelegate {
 
   /**
    * Called when the socket has encountered an error.
+   * This method must be called on the inspector queue, and the
+   * WebSocketDelegate may not be destroyed while it is executing.
    * \param posixCode POSIX errno value if available, otherwise nullopt.
    * \param error Error description.
    */
@@ -48,6 +50,8 @@ class IWebSocketDelegate {
 
   /**
    * Called when a message has been received from the socket.
+   * This method must be called on the inspector queue, and the
+   * WebSocketDelegate may not be destroyed while it is executing.
    * \param message Message received, in UTF-8 encoding.
    */
   virtual void didReceiveMessage(std::string_view message) = 0;
@@ -55,6 +59,8 @@ class IWebSocketDelegate {
   /**
    * Called when the socket has been closed. The call is not required if
    * didFailWithError was called instead.
+   * This method must be called on the inspector queue, and the
+   * WebSocketDelegate may not be destroyed while it is executing.
    */
   virtual void didClose() = 0;
 };