feat: Re-add NativeScript inspector sources

These were removed in the upgrade to V8 10.3.22. Re-add them. Note that
the ObjC++ files need to be compiled with -fobjc-arc or else connecting
the inspector crashes.

Author: ptomato

NativeScript/inspector/InspectorServer.h

@@ -0,0 +1,20 @@
+#ifndef InspectorServer_h
+#define InspectorServer_h
+
+#include <functional>
+#include <string>
+#include <sys/types.h>
+#include <dispatch/dispatch.h>
+
+namespace v8_inspector {
+
+class InspectorServer {
+public:
+    static in_port_t Init(std::function<void (std::function<void (std::string)>)> onClientConnected, std::function<void (std::string)> onMessage);
+private:
+    static void Send(dispatch_io_t channel, dispatch_queue_t queue, std::string message);
+};
+
+}
+
+#endif /* InspectorServer_h */

NativeScript/inspector/InspectorServer.mm

@@ -0,0 +1,147 @@
+#include "InspectorServer.h"
+#include <Foundation/Foundation.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+namespace v8_inspector {
+
+in_port_t InspectorServer::Init(std::function<void (std::function<void (std::string)>)> onClientConnected, std::function<void (std::string)> onMessage) {
+    in_port_t listenPort = 18183;
+
+    int serverSocket = -1;
+    if ((serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+        assert(false);
+    }
+
+    struct sockaddr_in serverAddress;
+    memset(&serverAddress, 0, sizeof(serverAddress));
+    serverAddress.sin_family = AF_INET;
+    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    do {
+        serverAddress.sin_port = htons(listenPort);
+    } while (bind(serverSocket, (struct sockaddr *) &serverAddress, sizeof(serverAddress)) < 0 && ++listenPort);
+
+    // Make the socket non-blocking
+    if (fcntl(serverSocket, F_SETFL, O_NONBLOCK) < 0) {
+        shutdown(serverSocket, SHUT_RDWR);
+        close(serverSocket);
+        assert(false);
+    }
+
+    // Set up the dispatch source that will alert us to new incoming connections
+    dispatch_queue_t q = dispatch_queue_create("server_queue", DISPATCH_QUEUE_CONCURRENT);
+    dispatch_source_t acceptSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, serverSocket, 0, q);
+    dispatch_source_set_event_handler(acceptSource, ^{
+        const unsigned long numPendingConnections = dispatch_source_get_data(acceptSource);
+        for (unsigned long i = 0; i < numPendingConnections; i++) {
+            int clientSocket = -1;
+            struct sockaddr_in echoClntAddr;
+            unsigned int clntLen = sizeof(echoClntAddr);
+
+            // Wait for a client to connect
+            if ((clientSocket = accept(serverSocket, (struct sockaddr *) &echoClntAddr, &clntLen)) >= 0) {
+                dispatch_io_t channel = dispatch_io_create(DISPATCH_IO_STREAM, clientSocket, q, ^(int error) {
+                    if (error) {
+                        NSLog(@"Error: %s", strerror(error));
+                    }
+                    close(clientSocket);
+                });
+
+                onClientConnected([channel, q](std::string message) {
+                    Send(channel, q, message);
+                });
+
+                __block dispatch_io_handler_t receiver = ^(bool done, dispatch_data_t data, int error) {
+                    if (error) {
+                        NSLog(@"Error: %s", strerror(error));
+                    }
+
+                    const void* bytes = [(NSData*)data bytes];
+                    if (!bytes) {
+                        return;
+                    }
+
+                    uint32_t length = ntohl(*(uint32_t*)bytes);
+
+                    // Configure the channel...
+                    dispatch_io_set_low_water(channel, length);
+
+                    // Setup read handler
+                    dispatch_io_read(channel, 0, length, q, ^(bool done, dispatch_data_t data, int error) {
+                        BOOL close = NO;
+                        if (error) {
+                            NSLog(@"Error: %s", strerror(error));
+                            close = YES;
+                        }
+
+                        const size_t size = data ? dispatch_data_get_size(data) : 0;
+                        if (size) {
+                            NSString* payload = [[NSString alloc] initWithData:(NSData*)data encoding:NSUTF16LittleEndianStringEncoding];
+
+                            onMessage([payload UTF8String]);
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-retain-cycles"
+                            dispatch_io_read(channel, 0, 4, q, receiver);
+#pragma clang diagnostic pop
+                        } else {
+                            close = YES;
+                        }
+
+                        if (close) {
+                            dispatch_io_close(channel, DISPATCH_IO_STOP);
+                        }
+                    });
+                };
+
+                if (channel) {
+                    dispatch_io_read(channel, 0, 4, q, receiver);
+                }
+            }
+            else {
+                NSLog(@"accept() failed;\n");
+            }
+        }
+    });
+
+    // Resume the source so we're ready to accept once we listen()
+    dispatch_resume(acceptSource);
+
+    // Listen() on the socket
+    if (listen(serverSocket, SOMAXCONN) < 0) {
+        shutdown(serverSocket, SHUT_RDWR);
+        close(serverSocket);
+        assert(false);
+    }
+
+    return listenPort;
+}
+
+void InspectorServer::Send(dispatch_io_t channel, dispatch_queue_t queue, std::string message) {
+    NSString* str = [NSString stringWithUTF8String:message.c_str()];
+    NSUInteger length = [str lengthOfBytesUsingEncoding:NSUTF16LittleEndianStringEncoding];
+
+    uint8_t* buffer = (uint8_t*)malloc(length + sizeof(uint32_t));
+
+    *(uint32_t*)buffer = htonl(length);
+
+    [str getBytes:&buffer[sizeof(uint32_t)]
+         maxLength:length
+         usedLength:NULL
+         encoding:NSUTF16LittleEndianStringEncoding
+         options:0
+         range:NSMakeRange(0, str.length)
+         remainingRange:NULL];
+
+    dispatch_data_t data = dispatch_data_create(buffer, length + sizeof(uint32_t), queue, ^{
+        free(buffer);
+    });
+
+    dispatch_io_write(channel, 0, data, queue, ^(bool done, dispatch_data_t data, int error) {
+        if (error) {
+            NSLog(@"Error: %s", strerror(error));
+        }
+    });
+}
+
+}

NativeScript/inspector/JsV8InspectorClient.cpp

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include "JsV8InspectorClient.h"
+#include "src/inspector/v8-inspector-session-impl.h"
+#include "Helpers.h"
+
+using namespace v8;
+
+namespace v8_inspector {
+
+void JsV8InspectorClient::inspectorSendEventCallback(const FunctionCallbackInfo<Value>& args) {
+    Local<External> data = args.Data().As<External>();
+    v8_inspector::JsV8InspectorClient* client = static_cast<v8_inspector::JsV8InspectorClient*>(data->Value());
+    Isolate* isolate = args.GetIsolate();
+    Local<v8::String> arg = args[0].As<v8::String>();
+    std::string message = tns::ToString(isolate, arg);
+
+    if (message.find("\"Network.") != std::string::npos) {
+        // The Network domain is handled directly by the corresponding backend
+        V8InspectorSessionImpl* session = (V8InspectorSessionImpl*)client->session_.get();
+        session->networkArgent()->dispatch(message);
+        return;
+    }
+
+    if (message.find("\"DOM.") != std::string::npos) {
+        // The DOM domain is handled directly by the corresponding backend
+        V8InspectorSessionImpl* session = (V8InspectorSessionImpl*)client->session_.get();
+        session->domArgent()->dispatch(message);
+        return;
+    }
+
+    client->dispatchMessage(message);
+}
+
+}

NativeScript/inspector/JsV8InspectorClient.h

@@ -0,0 +1,66 @@
+#ifndef JsV8InspectorClient_h
+#define JsV8InspectorClient_h
+
+#include <functional>
+#include <dispatch/dispatch.h>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "include/v8-inspector.h"
+#include "runtime/Runtime.h"
+
+namespace v8_inspector {
+
+class JsV8InspectorClient : V8InspectorClient, V8Inspector::Channel {
+public:
+    JsV8InspectorClient(tns::Runtime* runtime);
+    void init();
+    void connect(int argc, char** argv);
+    void createInspectorSession();
+    void disconnect();
+    void dispatchMessage(const std::string& message);
+
+    void sendResponse(int callId, std::unique_ptr<StringBuffer> message) override;
+    void sendNotification(std::unique_ptr<StringBuffer> message) override;
+    void flushProtocolNotifications() override;
+
+    void runMessageLoopOnPause(int contextGroupId) override;
+    void quitMessageLoopOnPause() override;
+    v8::Local<v8::Context> ensureDefaultContextInGroup(int contextGroupId) override;
+
+    void scheduleBreak();
+    void registerModules();
+
+    static std::map<std::string, v8::Persistent<v8::Object>*> Domains;
+private:
+    static int contextGroupId;
+    bool isConnected_;
+    std::unique_ptr<V8Inspector> inspector_;
+    v8::Persistent<v8::Context> context_;
+    std::unique_ptr<V8InspectorSession> session_;
+    tns::Runtime* runtime_;
+    bool terminated_;
+    std::vector<std::string> messages_;
+    bool runningNestedLoops_;
+    dispatch_queue_t messagesQueue_;
+    dispatch_queue_t messageLoopQueue_;
+    dispatch_semaphore_t messageArrived_;
+    std::function<void (std::string)> sender_;
+    bool isWaitingForDebugger_;
+
+    void enableInspector(int argc, char** argv);
+    void notify(std::unique_ptr<StringBuffer> message);
+    void onFrontendConnected(std::function<void (std::string)> sender);
+    void onFrontendMessageReceived(std::string message);
+    template <class TypeName>
+    static v8::Local<TypeName> PersistentToLocal(v8::Isolate* isolate, const v8::Persistent<TypeName>& persistent);
+    std::string PumpMessage();
+    static void registerDomainDispatcherCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void inspectorSendEventCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void inspectorTimestampCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+};
+
+}
+
+#endif /* JsV8InspectorClient_h */