Merge pull request #51 from lightpanda-io/unwrapObject

unwrapObject

Author: sjorsdonkers

src/binding.cpp

@@ -6,6 +6,7 @@
 #include "include/v8.h"
 #include "src/api/api.h"
 #include "src/inspector/protocol/Runtime.h"
+#include "src/inspector/v8-string-conversions.h"
 
 #include "inspector.h"
 
@@ -1556,6 +1557,11 @@ void v8__base__SetDcheckFunction(void (*func)(const char*, int, const char*)) {
 
 // Utils
 
+struct CZigString {
+    const char *ptr = nullptr;
+    uint64_t len = 0;
+};
+
 /// Header for Zig
 /// Allocates `bytes` bytes of memory using the allocator.
 /// @param allocator: A Zig std.mem.Allocator
@@ -1567,6 +1573,12 @@ static inline v8_inspector::StringView toStringView(const char *str, size_t leng
     auto* stringView = reinterpret_cast<const uint8_t*>(str);
     return { stringView, length };
 }
+/// Overload for safety in case the function is called with a string literal
+static inline v8_inspector::StringView toStringView(const char *str) {
+    size_t length = strlen(str);
+    auto* stringView = reinterpret_cast<const uint8_t*>(str);
+    return { stringView, length };
+}
 static inline v8_inspector::StringView toStringView(const std::string &str) {
     return toStringView(str.c_str(), str.length());
 }
@@ -1586,7 +1598,7 @@ static inline std::string fromStringView(v8::Isolate* isolate, const v8_inspecto
 /// @param str: The string to return
 /// @param allocator: A Zig std.mem.Allocator
 /// @returns string pointer with null terminator, null if allocation failed
-const char* toHeapCharPtr(const v8_inspector::String16& str, const void* allocator) {
+const char* allocStringWith0(const v8_inspector::String16& str, const void* allocator) {
     std::string utf8_str = str.utf8(); // Note the data*'s lifetime is tied to utf8_str and this may hold the string data on the stack as an SSO, so we need to copy it onto the heap.
     char* heap_str = zigAlloc(allocator, utf8_str.length() + 1); // +1 for null terminator, needed to communicate the length to Zig
     if (heap_str == nullptr) {
@@ -1596,6 +1608,41 @@ const char* toHeapCharPtr(const v8_inspector::String16& str, const void* allocat
     return heap_str;   
 }
 
+/// Allocates a string as utf8 on the allocator without \0 terminator, for use in Zig.
+/// The strings pointer and length should therefore be returned together
+/// @param str: The string contents to allocate
+/// @param allocator: A Zig std.mem.Allocator
+/// @param out: Points to the now allocated string on the heap (without sentinel \0), NULL if view was null, invalid if allocation failed
+/// @returns false if allocation errored
+bool allocString(const v8_inspector::StringView& input, const void* allocator, CZigString& output) {
+    if (input.characters8() == nullptr) {
+        output.ptr = nullptr;
+        output.len = 0;
+        return true;
+    }
+
+    std::string utf8_str; // Harmless if not used by 8bit string
+    if (input.is8Bit()) {
+        output.len = input.length();
+    } else {
+        utf8_str = v8_inspector::UTF16ToUTF8(input.characters16(), input.length());
+        output.len = utf8_str.length();
+    }
+
+    char* heap_str = zigAlloc(allocator, output.len);
+    if (heap_str == nullptr) {
+        return false;
+    }
+    
+    if (input.is8Bit()) {
+        memcpy(heap_str, input.characters8(), output.len);
+    } else {
+        memcpy(heap_str, utf8_str.c_str(), output.len);
+    }
+    output.ptr = heap_str;
+    return true;
+}
+
 
 // Inspector
 
@@ -1666,6 +1713,32 @@ v8_inspector::protocol::Runtime::RemoteObject* v8_inspector__Session__wrapObject
   return static_cast<v8_inspector::protocol::Runtime::RemoteObject*>(remote_object.release());
 }
 
+bool v8_inspector__Session__unwrapObject(
+    v8_inspector::V8InspectorSession *session,
+    const void *allocator,
+    CZigString &out_error,
+    CZigString in_objectId,
+    v8::Local<v8::Value> &out_value,
+    v8::Local<v8::Context> &out_context,
+    CZigString &out_objectGroup
+) {
+  auto objectId = toStringView(in_objectId.ptr, in_objectId.len);
+  auto error = v8_inspector::StringBuffer::create({});
+  auto objectGroup = v8_inspector::StringBuffer::create({});  
+        
+  // [out optional ] std::unique_ptr<StringBuffer>* error,
+  // [in  required ] StringView                     objectId,
+  // [out required ] v8::Local<v8::Value>         * value
+  // [out required ] v8::Local<v8::Context>       * context
+  // [out optional ] std::unique_ptr<StringBuffer>* objectGroup
+  bool result = session->unwrapObject(&error, objectId, &out_value, &out_context, &objectGroup);
+  if (!result) {
+    allocString(error->string(), allocator, out_error);
+    return false;
+  }
+  return allocString(objectGroup->string(), allocator, out_objectGroup);
+}
+
 // RemoteObject
 
 // To prevent extra allocations on every call a single default value is reused everytime.
@@ -1679,7 +1752,7 @@ void v8_inspector__RemoteObject__DELETE(v8_inspector::protocol::Runtime::RemoteO
 // RemoteObject - Type
 const char* v8_inspector__RemoteObject__getType(v8_inspector::protocol::Runtime::RemoteObject* self, const void* allocator) {
   auto str = self->getType();
-  return toHeapCharPtr(str, allocator);
+  return allocStringWith0(str, allocator);
 }
 void v8_inspector__RemoteObject__setType(v8_inspector::protocol::Runtime::RemoteObject* self, const char* type, int type_len) {
   self->setType(v8_inspector::String16::fromUTF8(type, type_len));
@@ -1691,7 +1764,7 @@ bool v8_inspector__RemoteObject__hasSubtype(v8_inspector::protocol::Runtime::Rem
 }
 const char* v8_inspector__RemoteObject__getSubtype(v8_inspector::protocol::Runtime::RemoteObject* self, const void* allocator) {
   auto str = self->getSubtype(DEFAULT_STRING);
-  return toHeapCharPtr(str, allocator);
+  return allocStringWith0(str, allocator);
 }
 void v8_inspector__RemoteObject__setSubtype(v8_inspector::protocol::Runtime::RemoteObject* self, const char* subtype, int subtype_len) {
   self->setSubtype(v8_inspector::String16::fromUTF8(subtype, subtype_len));
@@ -1703,7 +1776,7 @@ bool v8_inspector__RemoteObject__hasClassName(v8_inspector::protocol::Runtime::R
 }
 const char* v8_inspector__RemoteObject__getClassName(v8_inspector::protocol::Runtime::RemoteObject* self, const void* allocator) {
   auto str = self->getClassName(DEFAULT_STRING);
-  return toHeapCharPtr(str, allocator);
+  return allocStringWith0(str, allocator);
 }
 void v8_inspector__RemoteObject__setClassName(v8_inspector::protocol::Runtime::RemoteObject* self, const char* className, int className_len) {
   self->setClassName(v8_inspector::String16::fromUTF8(className, className_len));
@@ -1726,7 +1799,7 @@ bool v8_inspector__RemoteObject__hasUnserializableValue(v8_inspector::protocol::
 }
 const char* v8_inspector__RemoteObject__getUnserializableValue(v8_inspector::protocol::Runtime::RemoteObject* self, const void* allocator) {
   auto str = self->getUnserializableValue(DEFAULT_STRING);
-  return toHeapCharPtr(str, allocator);
+  return allocStringWith0(str, allocator);
 }
 void v8_inspector__RemoteObject__setUnserializableValue(v8_inspector::protocol::Runtime::RemoteObject* self, const char* unserializableValue, int unserializableValue_len) {
   self->setUnserializableValue(v8_inspector::String16::fromUTF8(unserializableValue, unserializableValue_len));
@@ -1738,7 +1811,7 @@ bool v8_inspector__RemoteObject__hasDescription(v8_inspector::protocol::Runtime:
 }
 const char* v8_inspector__RemoteObject__getDescription(v8_inspector::protocol::Runtime::RemoteObject* self, const void* allocator) {
   auto str = self->getDescription(DEFAULT_STRING);
-  return toHeapCharPtr(str, allocator);
+  return allocStringWith0(str, allocator);
 }
 void v8_inspector__RemoteObject__setDescription(v8_inspector::protocol::Runtime::RemoteObject* self, const char* description, int description_len) {
   self->setDescription(v8_inspector::String16::fromUTF8(description, description_len));
@@ -1762,7 +1835,7 @@ bool v8_inspector__RemoteObject__hasObjectId(v8_inspector::protocol::Runtime::Re
 
 const char* v8_inspector__RemoteObject__getObjectId(v8_inspector::protocol::Runtime::RemoteObject* self, const void* allocator) {
   auto str = self->getObjectId(DEFAULT_STRING);
-  return toHeapCharPtr(str, allocator);
+  return allocStringWith0(str, allocator);
 }
   void v8_inspector__RemoteObject__setObjectId(v8_inspector::protocol::Runtime::RemoteObject* self, const char* objectId, int objectId_len) {
   self->setObjectId(v8_inspector::String16::fromUTF8(objectId, objectId_len));

src/binding.h

@@ -958,6 +958,13 @@ const String* v8__JSON__Stringify(
 // Misc.
 void v8__base__SetDcheckFunction(void (*func)(const char*, int, const char*));
 
+// Utils
+
+typedef struct {
+    const char *ptr;
+    uint64_t len;
+} CZigString;
+
 // Inspector
 // ---------
 
@@ -1015,7 +1022,6 @@ char* v8_inspector__Client__IMPL__valueSubtype(
 char* v8_inspector__Client__IMPL__descriptionForValueSubtype(
     InspectorClientImpl* self, Context context, Value value);
 
-
 // RemoteObject
 typedef struct RemoteObject RemoteObject;
 typedef struct WebDriverValue WebDriverValue;
@@ -1032,6 +1038,16 @@ RemoteObject* v8_inspector__Session__wrapObject(
     const Context* ctx, const Value* val,
     const char *grpname, usize grpname_len, bool generatepreview);
 
+bool v8_inspector__Session__unwrapObject(
+    InspectorSession *session,
+    const void* allocator,
+    CZigString* out_error,
+    CZigString in_objectId,
+    Value** out_value,
+    Context** out_context,
+    CZigString* out_objectGroup
+);
+
 // Inspector
 typedef struct Inspector Inspector;
 Inspector* v8_inspector__Inspector__Create(Isolate* isolate, InspectorClientImpl* client);

src/v8.zig

@@ -2719,6 +2719,51 @@ pub const InspectorSession = struct {
         ).?;
         return RemoteObject{ .handle = remote_object };
     }
+
+    pub fn unwrapObject(self: InspectorSession, allocator: std.mem.Allocator, objectId: []const u8) !UnwrappedObject {
+        const in_objectId = c.CZigString{
+            .ptr = objectId.ptr,
+            .len = objectId.len,
+        };
+        var out_error: c.CZigString = .{ .ptr = null, .len = 0 };
+        var out_value_handle: ?*c.Value = null;
+        var out_context_handle: ?*c.Context = null;
+        var out_objectGroup: c.CZigString = .{ .ptr = null, .len = 0 };
+
+        const result = c.v8_inspector__Session__unwrapObject(
+            self.handle,
+            &allocator,
+            &out_error,
+            in_objectId,
+            &out_value_handle,
+            &out_context_handle,
+            &out_objectGroup,
+        );
+        if (!result) {
+            if (CZigStringToString(out_error)) |err| {
+                if (std.mem.eql(u8, err, "Invalid remote object id")) return error.InvalidRemoteObjectId;
+                if (std.mem.eql(u8, err, "Cannot find context with specified id")) return error.CannotFindContextWithSpecifiedId;
+                if (std.mem.eql(u8, err, "Could not find object with given id")) return error.CouldNotFindObjectWithGivenId;
+                return error.NewUnwrapErrorPleaseReport;
+            }
+            return error.V8AllocFailed;
+        }
+        return .{
+            .value = Value{ .handle = out_value_handle.? },
+            .context = Context{ .handle = out_context_handle.? },
+            .objectGroup = CZigStringToString(out_objectGroup),
+        };
+    }
+};
+
+pub fn CZigStringToString(slice: c.CZigString) ?[]const u8 {
+    return if (slice.ptr == null) null else slice.ptr[0..slice.len];
+}
+
+pub const UnwrappedObject = struct {
+    value: Value,
+    context: Context,
+    objectGroup: ?[]const u8,
 };
 
 /// Note: Some getters return owned memory (strings), while others return memory owned by V8 (objects).