Revert deletion of old Hermes CDPHandler (facebook#54078)

Summary:
Pull Request resolved: facebook#54078

Changelog:
[General][Fixed] 6e1c0a removed old Hermes CDPHandler, which is a
breaking change, revert here.

Reviewed By: cipolleschi

Differential Revision: D84076229

fbshipit-source-id: 7ac426178754d6320c1803a50d57afa10e3126e5

Author: lavenzg

packages/react-native/ReactCommon/hermes/executor/HermesExecutorFactory.cpp

@@ -15,13 +15,55 @@
 
 #include <hermes/inspector-modern/chrome/HermesRuntimeTargetDelegate.h>
 
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+#include <hermes/inspector-modern/chrome/Registration.h>
+#include <hermes/inspector/RuntimeAdapter.h>
+#endif
+
 using namespace facebook::hermes;
 using namespace facebook::jsi;
 
 namespace facebook::react {
 
 namespace {
 
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+
+class HermesExecutorRuntimeAdapter
+    : public facebook::hermes::inspector_modern::RuntimeAdapter {
+ public:
+  HermesExecutorRuntimeAdapter(
+      std::shared_ptr<HermesRuntime> runtime,
+      std::shared_ptr<MessageQueueThread> thread)
+      : runtime_(runtime), thread_(std::move(thread)) {}
+
+  virtual ~HermesExecutorRuntimeAdapter() = default;
+
+  HermesRuntime& getRuntime() override {
+    return *runtime_;
+  }
+
+  void tickleJs() override {
+    thread_->runOnQueue(
+        [weakRuntime = std::weak_ptr<HermesRuntime>(runtime_)]() {
+          auto runtime = weakRuntime.lock();
+          if (!runtime) {
+            return;
+          }
+          jsi::Function func =
+              runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
+          func.call(*runtime);
+        });
+  }
+
+ private:
+  std::shared_ptr<HermesRuntime> runtime_;
+
+  std::shared_ptr<MessageQueueThread> thread_;
+};
+
+#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+
 struct ReentrancyCheck {
 // This is effectively a very subtle and complex assert, so only
 // include it in builds which would include asserts.
@@ -105,17 +147,42 @@ class DecoratedRuntime : public jsi::WithRuntimeDecorator<ReentrancyCheck> {
       const std::string& debuggerName)
       : jsi::WithRuntimeDecorator<ReentrancyCheck>(*runtime, reentrancyCheck_),
         runtime_(std::move(runtime)) {
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+    enableDebugger_ = enableDebugger;
+    if (enableDebugger_) {
+      std::shared_ptr<HermesRuntime> rt(runtime_, &hermesRuntime);
+      auto adapter =
+          std::make_unique<HermesExecutorRuntimeAdapter>(rt, jsQueue);
+      debugToken_ = facebook::hermes::inspector_modern::chrome::enableDebugging(
+          std::move(adapter), debuggerName);
+    }
+#else
     (void)jsQueue;
+#endif // HERMES_ENABLE_DEBUGGER
   }
 
-  ~DecoratedRuntime() {}
+  ~DecoratedRuntime() {
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+    if (enableDebugger_) {
+      facebook::hermes::inspector_modern::chrome::disableDebugging(debugToken_);
+    }
+#endif // HERMES_ENABLE_DEBUGGER
+  }
 
  private:
   // runtime_ is a potentially decorated Runtime.
   // hermesRuntime is a reference to a HermesRuntime managed by runtime_.
+  //
+  // HermesExecutorRuntimeAdapter requirements are kept, because the
+  // dtor will disable debugging on the HermesRuntime before the
+  // member managing it is destroyed.
 
   std::shared_ptr<Runtime> runtime_;
   ReentrancyCheck reentrancyCheck_;
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+  bool enableDebugger_;
+  facebook::hermes::inspector_modern::chrome::DebugSessionToken debugToken_;
+#endif // HERMES_ENABLE_DEBUGGER
 };
 
 } // namespace

packages/react-native/ReactCommon/hermes/inspector-modern/chrome/ConnectionDemux.cpp

@@ -0,0 +1,142 @@
+/*
+ * 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 "ConnectionDemux.h"
+
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+
+#include <hermes/inspector/RuntimeAdapter.h>
+#include <hermes/inspector/chrome/CDPHandler.h>
+
+#include <jsinspector-modern/InspectorInterfaces.h>
+
+#include <utility>
+
+namespace facebook::hermes::inspector_modern::chrome {
+
+using ::facebook::react::jsinspector_modern::ILocalConnection;
+using ::facebook::react::jsinspector_modern::IRemoteConnection;
+
+namespace {
+
+class LocalConnection : public ILocalConnection {
+ public:
+  LocalConnection(
+      std::shared_ptr<hermes::inspector_modern::chrome::CDPHandler> conn,
+      std::shared_ptr<std::unordered_set<std::string>> inspectedContexts);
+  ~LocalConnection() override;
+
+  void sendMessage(std::string message) override;
+  void disconnect() override;
+
+ private:
+  std::shared_ptr<hermes::inspector_modern::chrome::CDPHandler> conn_;
+  std::shared_ptr<std::unordered_set<std::string>> inspectedContexts_;
+};
+
+LocalConnection::LocalConnection(
+    std::shared_ptr<hermes::inspector_modern::chrome::CDPHandler> conn,
+    std::shared_ptr<std::unordered_set<std::string>> inspectedContexts)
+    : conn_(conn), inspectedContexts_(std::move(inspectedContexts)) {
+  inspectedContexts_->insert(conn->getTitle());
+}
+
+LocalConnection::~LocalConnection() = default;
+
+void LocalConnection::sendMessage(std::string message) {
+  conn_->handle(std::move(message));
+}
+
+void LocalConnection::disconnect() {
+  inspectedContexts_->erase(conn_->getTitle());
+  conn_->unregisterCallbacks();
+}
+
+} // namespace
+
+ConnectionDemux::ConnectionDemux(
+    facebook::react::jsinspector_modern::IInspector& inspector)
+    : globalInspector_(inspector),
+      inspectedContexts_(std::make_shared<std::unordered_set<std::string>>()) {}
+
+ConnectionDemux::~ConnectionDemux() = default;
+
+DebugSessionToken ConnectionDemux::enableDebugging(
+    std::unique_ptr<RuntimeAdapter> adapter,
+    const std::string& title) {
+  std::scoped_lock lock(mutex_);
+
+  // TODO(#22976087): workaround for ComponentScript contexts never being
+  // destroyed.
+  //
+  // After a reload, the old ComponentScript VM instance stays alive. When we
+  // register the new CS VM instance, check for any previous CS VM (via strcmp
+  // of title) and remove them.
+  std::vector<int> pagesToDelete;
+  for (auto& conn : conns_) {
+    if (conn.second->getTitle() == title) {
+      pagesToDelete.push_back(conn.first);
+    }
+  }
+
+  for (auto pageId : pagesToDelete) {
+    removePage(pageId);
+  }
+
+  auto waitForDebugger =
+      (inspectedContexts_->find(title) != inspectedContexts_->end());
+  return addPage(hermes::inspector_modern::chrome::CDPHandler::create(
+      std::move(adapter), title, waitForDebugger));
+}
+
+void ConnectionDemux::disableDebugging(DebugSessionToken session) {
+  std::scoped_lock lock(mutex_);
+  if (conns_.find(session) == conns_.end()) {
+    return;
+  }
+  removePage(session);
+}
+
+int ConnectionDemux::addPage(
+    std::shared_ptr<hermes::inspector_modern::chrome::CDPHandler> conn) {
+  auto connectFunc = [conn, this](std::unique_ptr<IRemoteConnection> remoteConn)
+      -> std::unique_ptr<ILocalConnection> {
+    // This cannot be unique_ptr as std::function is copyable but unique_ptr
+    // isn't. TODO: Change the CDPHandler API to accommodate this and not
+    // require a copyable callback?
+    std::shared_ptr<IRemoteConnection> sharedConn = std::move(remoteConn);
+    if (!conn->registerCallbacks(
+            [sharedConn](const std::string& message) {
+              sharedConn->onMessage(message);
+            },
+            [sharedConn]() { sharedConn->onDisconnect(); })) {
+      return nullptr;
+    }
+
+    return std::make_unique<LocalConnection>(conn, inspectedContexts_);
+  };
+
+  int pageId = globalInspector_.addPage(
+      conn->getTitle(), "Hermes", std::move(connectFunc));
+  conns_[pageId] = std::move(conn);
+
+  return pageId;
+}
+
+void ConnectionDemux::removePage(int pageId) {
+  globalInspector_.removePage(pageId);
+
+  auto conn = conns_.at(pageId);
+  std::string title = conn->getTitle();
+  inspectedContexts_->erase(title);
+  conn->unregisterCallbacks();
+  conns_.erase(pageId);
+}
+
+} // namespace facebook::hermes::inspector_modern::chrome
+
+#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)

packages/react-native/ReactCommon/hermes/inspector-modern/chrome/ConnectionDemux.h

@@ -0,0 +1,62 @@
+/*
+ * 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
+
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include <hermes/hermes.h>
+#include <hermes/inspector-modern/chrome/Registration.h>
+#include <hermes/inspector/RuntimeAdapter.h>
+#include <hermes/inspector/chrome/CDPHandler.h>
+#include <jsinspector-modern/InspectorInterfaces.h>
+
+namespace facebook::hermes::inspector_modern::chrome {
+
+/*
+ * ConnectionDemux keeps track of all debuggable Hermes runtimes (called
+ * "pages" in the higher-level React Native API) in this process. See
+ * Registration.h for documentation of the public API.
+ */
+class ConnectionDemux {
+ public:
+  explicit ConnectionDemux(
+      facebook::react::jsinspector_modern::IInspector& inspector);
+  ~ConnectionDemux();
+
+  ConnectionDemux(const ConnectionDemux&) = delete;
+  ConnectionDemux& operator=(const ConnectionDemux&) = delete;
+
+  DebugSessionToken enableDebugging(
+      std::unique_ptr<RuntimeAdapter> adapter,
+      const std::string& title);
+  void disableDebugging(DebugSessionToken session);
+
+ private:
+  int addPage(
+      std::shared_ptr<hermes::inspector_modern::chrome::CDPHandler> conn);
+  void removePage(int pageId);
+
+  facebook::react::jsinspector_modern::IInspector& globalInspector_;
+
+  std::mutex mutex_;
+  std::unordered_map<
+      int,
+      std::shared_ptr<hermes::inspector_modern::chrome::CDPHandler>>
+      conns_;
+  std::shared_ptr<std::unordered_set<std::string>> inspectedContexts_;
+};
+
+} // namespace facebook::hermes::inspector_modern::chrome
+
+#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)

packages/react-native/ReactCommon/hermes/inspector-modern/chrome/Registration.cpp

@@ -0,0 +1,37 @@
+/*
+ * 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 "Registration.h"
+#include "ConnectionDemux.h"
+
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+
+namespace facebook::hermes::inspector_modern::chrome {
+
+namespace {
+
+ConnectionDemux& demux() {
+  static ConnectionDemux instance{
+      facebook::react::jsinspector_modern::getInspectorInstance()};
+  return instance;
+}
+
+} // namespace
+
+DebugSessionToken enableDebugging(
+    std::unique_ptr<RuntimeAdapter> adapter,
+    const std::string& title) {
+  return demux().enableDebugging(std::move(adapter), title);
+}
+
+void disableDebugging(DebugSessionToken session) {
+  demux().disableDebugging(session);
+}
+
+} // namespace facebook::hermes::inspector_modern::chrome
+
+#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)

packages/react-native/ReactCommon/hermes/inspector-modern/chrome/Registration.h

@@ -0,0 +1,41 @@
+/*
+ * 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
+
+#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
+
+#include <memory>
+#include <string>
+
+#include <hermes/hermes.h>
+#include <hermes/inspector/RuntimeAdapter.h>
+
+namespace facebook::hermes::inspector_modern::chrome {
+
+using DebugSessionToken = int;
+
+/*
+ * enableDebugging adds this runtime to the list of debuggable JS targets
+ * (called "pages" in the higher-level React Native API) in this process. It
+ * should be called before any JS runs in the runtime. The returned token
+ * can be used to disable debugging for this runtime.
+ */
+extern DebugSessionToken enableDebugging(
+    std::unique_ptr<RuntimeAdapter> adapter,
+    const std::string& title);
+
+/*
+ * disableDebugging removes this runtime from the list of debuggable JS targets
+ * in this process. The runtime to remove is identified by the token returned
+ * from enableDebugging.
+ */
+extern void disableDebugging(DebugSessionToken session);
+
+} // namespace facebook::hermes::inspector_modern::chrome
+
+#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)