react-native-windows 0.75.4 → 0.76.0-preview.2

package/ReactCommon/TEMP_UntilReactCommonUpdate/jsinspector-modern/NetworkIOAgent.cpp

@@ -0,0 +1,441 @@
+/*
+ * 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 "NetworkIOAgent.h"
+#include <utility>
+#include "Base64.h"
+#include "Utf8.h"
+
+namespace facebook::react::jsinspector_modern {
+
+static constexpr long DEFAULT_BYTES_PER_READ =
+    1048576; // 1MB (Chrome v112 default)
+
+// https://github.com/chromium/chromium/blob/128.0.6593.1/content/browser/devtools/devtools_io_context.cc#L71-L73
+static constexpr std::array kTextMIMETypePrefixes{
+    "text/",
+    "application/x-javascript",
+    "application/json",
+    "application/xml",
+    "application/javascript" // Not in Chromium but emitted by Metro
+};
+
+// namespace { [Windows #13587]
+
+struct InitStreamResult {
+  int httpStatusCode;
+  Headers headers;
+  std::shared_ptr<Stream> stream;
+};
+using InitStreamError = const std::string;
+
+using StreamInitCallback =
+    std::function<void(std::variant<InitStreamError, InitStreamResult>)>;
+using IOReadCallback =
+    std::function<void(std::variant<IOReadError, IOReadResult>)>;
+
+/**
+ * Private class owning state and implementing the listener for a particular
+ * request
+ *
+ * NetworkRequestListener overrides are thread safe, all other methods must be
+ * called from the same thread.
+ */
+class Stream : public NetworkRequestListener,
+               public EnableExecutorFromThis<Stream> {
+ public:
+  Stream(const Stream& other) = delete;
+  Stream& operator=(const Stream& other) = delete;
+  Stream(Stream&& other) = default;
+  Stream& operator=(Stream&& other) = default;
+
+  /**
+   * Factory method to create a Stream with a callback for the initial result
+   * of a network request.
+   * \param executor An executor on which all processing of callbacks from
+   * the platform will be performed, and on which the passed callback will be
+   * called.
+   * \param initCb Will be called once either on receipt of HTTP headers or
+   * any prior error, using the given executor.
+   */
+  static std::shared_ptr<Stream> create(
+      VoidExecutor executor,
+      StreamInitCallback initCb) {
+    std::shared_ptr<Stream> stream{new Stream(initCb)};
+    stream->setExecutor(executor);
+    return stream;
+  }
+
+  /**
+   * Agent-facing API. Enqueue a read request for up to maxBytesToRead
+   * bytes, starting from the end of the previous read.
+   * \param maxBytesToRead The maximum number of bytes to read from the
+   * source stream.
+   * \param callback Will be called using the executor passed to create()
+   * with the result of the read, or an error string.
+   */
+  void read(long maxBytesToRead, const IOReadCallback& callback) {
+    pendingReadRequests_.emplace_back(
+        std::make_tuple(maxBytesToRead, callback));
+    processPending();
+  }
+
+  /**
+   * Agent-facing API. Call the platform-provided cancelFunction, if any,
+   * call the error callbacks of any in-flight read requests, and the initial
+   * error callback if it has not already fulfilled with success or error.
+   */
+  void cancel() {
+    if (cancelFunction_) {
+      (*cancelFunction_)();
+    }
+    error_ = "Cancelled";
+    if (initCb_) {
+      auto cb = std::move(initCb_);
+      (*cb)(InitStreamError{"Cancelled"});
+    }
+    // Respond to any in-flight read requests with an error.
+    processPending();
+  }
+
+  /**
+   * Begin implementation of NetworkRequestListener, to be called by platform
+   * HostTargetDelegate. Any of these methods may be called from any thread.
+   */
+
+  void onData(std::string_view data) override {
+    data_ << data;
+    bytesReceived_ += data.length();
+    processPending();
+  }
+
+  void onHeaders(int httpStatusCode, const Headers& headers) override {
+    // Find content-type through case-insensitive search of headers.
+    for (const auto& [name, value] : headers) {
+      std::string lowerName = name;
+      std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](unsigned char c) { // [Windows #13587]
+        return static_cast<char>(::tolower(c)); // [Windows #13587]
+      });
+      if (lowerName == "content-type") {
+        isText_ = isTextMimeType(value);
+        break;
+      };
+    }
+
+    // If we've already seen an error, the initial callback as already been
+    // called with it.
+    if (initCb_) {
+      auto cb = std::move(initCb_);
+      (*cb)(
+          InitStreamResult{httpStatusCode, headers, this->shared_from_this()});
+    }
+  }
+
+  void onError(const std::string& message) override {
+    // Only call the error callback once.
+    if (!error_) {
+      error_ = message;
+      if (initCb_) {
+        auto cb = std::move(initCb_);
+        (*cb)(InitStreamError{message});
+      }
+    }
+    processPending();
+  }
+
+  void onCompletion() override {
+    completed_ = true;
+    processPending();
+  }
+
+  void setCancelFunction(std::function<void()> cancelFunction) override {
+    cancelFunction_ = std::move(cancelFunction);
+  }
+
+  ~Stream() override {
+    // Cancel any incoming request, if the platform has provided a cancel
+    // callback.
+    if (cancelFunction_) {
+      (*cancelFunction_)();
+    }
+  }
+
+  /* End NetworkRequestListener */
+
+ private:
+  /**
+   * Private constructor. The caller must call setExecutor immediately
+   * afterwards.
+   */
+  explicit Stream(const StreamInitCallback& initCb)
+      : initCb_(std::make_unique<StreamInitCallback>(initCb)) {}
+
+  void processPending() {
+    // Go through each pending request in insertion order - execute the
+    // callback and remove it from pending if it can be satisfied.
+    for (auto it = pendingReadRequests_.begin();
+         it != pendingReadRequests_.end();) {
+      auto maxBytesToRead = std::get<0>(*it);
+      auto callback = std::get<1>(*it);
+
+      if (error_) {
+        callback(IOReadError{*error_});
+      } else if (
+          completed_ || (bytesReceived_ - data_.tellg() >= maxBytesToRead)) {
+        try {
+          callback(respond(maxBytesToRead));
+        } catch (const std::runtime_error& error) {
+          callback(IOReadError{error.what()});
+        }
+      } else {
+        // Not yet received enough data
+        ++it;
+        continue;
+      }
+      it = pendingReadRequests_.erase(it);
+    }
+  }
+
+  IOReadResult respond(long maxBytesToRead) {
+    std::vector<char> buffer(maxBytesToRead);
+    data_.read(buffer.data(), maxBytesToRead);
+    auto bytesRead = data_.gcount();
+    std::string output;
+
+    buffer.resize(static_cast<size_t>(bytesRead)); // [Windows #13587]
+    if (isText_) {
+      auto originalSize = buffer.size();
+      // Maybe resize to drop the last 1-3 bytes so that buffer is valid.
+      truncateToValidUTF8(buffer);
+      if (buffer.size() < originalSize) {
+        // Rewind the stream so that the next read starts from the start of
+        // the code point we're removing from this chunk.
+        data_.seekg(buffer.size() - originalSize, std::ios_base::cur);
+      }
+      output = std::string(buffer.begin(), buffer.begin() + buffer.size());
+    } else {
+      // Encode the slice as a base64 string.
+      output = base64Encode(std::string_view(buffer.data(), buffer.size()));
+    }
+
+    return IOReadResult{
+        .data = output,
+        .eof = output.length() == 0 && completed_,
+        .base64Encoded = !isText_};
+  }
+
+  // https://github.com/chromium/chromium/blob/128.0.6593.1/content/browser/devtools/devtools_io_context.cc#L70-L80
+  static bool isTextMimeType(const std::string& mimeType) {
+    for (auto& kTextMIMETypePrefix : kTextMIMETypePrefixes) {
+      if (mimeType.starts_with(kTextMIMETypePrefix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool completed_{false};
+  bool isText_{false};
+  std::optional<std::string> error_;
+  std::stringstream data_;
+  size_t bytesReceived_{0}; // [Windows #13587]
+  std::optional<std::function<void()>> cancelFunction_{std::nullopt};
+  std::unique_ptr<StreamInitCallback> initCb_;
+  std::vector<std::tuple<long /* bytesToRead */, IOReadCallback>>
+      pendingReadRequests_;
+};
+// } // namespace [Windows #13587]
+
+bool NetworkIOAgent::handleRequest(
+    const cdp::PreparsedRequest& req,
+    LoadNetworkResourceDelegate& delegate) {
+  if (req.method == "Network.loadNetworkResource") {
+    handleLoadNetworkResource(req, delegate);
+    return true;
+  } else if (req.method == "IO.read") {
+    handleIoRead(req);
+    return true;
+  } else if (req.method == "IO.close") {
+    handleIoClose(req);
+    return true;
+  }
+  return false;
+}
+
+void NetworkIOAgent::handleLoadNetworkResource(
+    const cdp::PreparsedRequest& req,
+    LoadNetworkResourceDelegate& delegate) {
+  long long requestId = req.id;
+
+  LoadNetworkResourceRequest params;
+
+  if (!req.params.isObject()) {
+    frontendChannel_(cdp::jsonError(
+        req.id,
+        cdp::ErrorCode::InvalidParams,
+        "Invalid params: not an object."));
+    return;
+  }
+  if ((req.params.count("url") == 0u) || !req.params.at("url").isString()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InvalidParams,
+        "Invalid params: url is missing or not a string."));
+    return;
+  } else {
+    params.url = req.params.at("url").asString();
+  }
+
+  // This is an opaque identifier, but an incrementing integer in a string is
+  // consistent with Chrome.
+  StreamID streamId = std::to_string(nextStreamId_++);
+
+  auto stream = Stream::create(
+      executor_,
+      [streamId,
+       requestId,
+       frontendChannel = frontendChannel_,
+       streamsWeak = std::weak_ptr(streams_)](auto resultOrError) {
+        NetworkResource resource;
+        std::string cdpError;
+        if (auto* error = std::get_if<InitStreamError>(&resultOrError)) {
+          resource = NetworkResource{.success = false, .netErrorName = *error};
+        } else if (
+            auto* result = std::get_if<InitStreamResult>(&resultOrError)) {
+          if (result->httpStatusCode >= 200 && result->httpStatusCode < 300) {
+            resource = NetworkResource{
+                .success = true,
+                .stream = streamId,
+                .httpStatusCode = result->httpStatusCode,
+                .headers = result->headers};
+          } else if (result->httpStatusCode >= 400) {
+            resource = NetworkResource{
+                .success = false,
+                .httpStatusCode = result->httpStatusCode,
+                .headers = result->headers};
+          } else {
+            // We can't deal with <200 or 3xx reponses here (though they may be
+            // transparently handled by the delegate). Return a CDP error (not
+            // an unsuccesful resource) to the frontend so that it falls back to
+            // a direct fetch.
+            cdpError = "Handling of status " +
+                std::to_string(result->httpStatusCode) + " not implemented.";
+          }
+        } else {
+          assert(false && "Unhandled IO init result type");
+        }
+        if (cdpError.length() > 0 || !resource.success) {
+          // Release and destroy the stream after the calling executor returns.
+          // ~Stream will handle cancelling any download in progress.
+          if (auto streams = streamsWeak.lock()) {
+            streams->erase(streamId);
+          }
+        }
+        frontendChannel(
+            cdpError.length()
+                ? cdp::jsonError(
+                      requestId, cdp::ErrorCode::InternalError, cdpError)
+                : cdp::jsonResult(
+                      requestId,
+                      folly::dynamic::object(
+                          "resource", resource.toDynamic())));
+      });
+
+  // Begin the network request on the platform, passing an executor scoped to
+  // a Stream (a NetworkRequestListener), which the implementation will call
+  // back into.
+  delegate.loadNetworkResource(params, stream->executorFromThis());
+
+  // Retain the stream only if delegate.loadNetworkResource does not throw.
+  streams_->emplace(streamId, stream);
+}
+
+void NetworkIOAgent::handleIoRead(const cdp::PreparsedRequest& req) {
+  long long requestId = req.id;
+  if (!req.params.isObject()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InvalidParams,
+        "Invalid params: not an object."));
+    return;
+  }
+  if ((req.params.count("handle") == 0u) ||
+      !req.params.at("handle").isString()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InvalidParams,
+        "Invalid params: handle is missing or not a string."));
+    return;
+  }
+  std::optional<int64_t> size = std::nullopt; // [Windows #13587]
+  if ((req.params.count("size") != 0u) && req.params.at("size").isInt()) {
+    size = req.params.at("size").asInt();
+  }
+
+  auto streamId = req.params.at("handle").asString();
+  auto it = streams_->find(streamId);
+  if (it == streams_->end()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InternalError,
+        "Stream not found with handle " + streamId));
+    return;
+  } else {
+    it->second->read(
+        size ? static_cast<unsigned long>(*size) : DEFAULT_BYTES_PER_READ, // [Windows #13587]
+        [requestId,
+         frontendChannel = frontendChannel_,
+         streamId,
+         streamsWeak = std::weak_ptr(streams_)](auto resultOrError) {
+          if (auto* error = std::get_if<IOReadError>(&resultOrError)) {
+            // NB: Chrome DevTools calls IO.close after a read error, so any
+            // continuing download or retained data is cleaned up at that point.
+            frontendChannel(cdp::jsonError(
+                requestId, cdp::ErrorCode::InternalError, *error));
+          } else if (auto* result = std::get_if<IOReadResult>(&resultOrError)) {
+            frontendChannel(cdp::jsonResult(requestId, result->toDynamic()));
+          } else {
+            assert(false && "Unhandled IO read result type");
+          }
+        });
+    return;
+  }
+}
+
+void NetworkIOAgent::handleIoClose(const cdp::PreparsedRequest& req) {
+  long long requestId = req.id;
+  if (!req.params.isObject()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InvalidParams,
+        "Invalid params: not an object."));
+    return;
+  }
+  if ((req.params.count("handle") == 0u) ||
+      !req.params.at("handle").isString()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InvalidParams,
+        "Invalid params: handle is missing or not a string."));
+    return;
+  }
+  auto streamId = req.params.at("handle").asString();
+
+  auto it = streams_->find(streamId);
+  if (it == streams_->end()) {
+    frontendChannel_(cdp::jsonError(
+        requestId,
+        cdp::ErrorCode::InternalError,
+        "Stream not found: " + streamId));
+  } else {
+    it->second->cancel();
+    streams_->erase(it->first);
+    frontendChannel_(cdp::jsonResult(requestId));
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/TEMP_UntilReactCommonUpdate/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 { [Windows #13587]
+class Stream; // Defined in NetworkIOAgent.cpp
+using StreamsMap = std::unordered_map<std::string, std::shared_ptr<Stream>>;
+// } // namespace [Windows #13587]
+
+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