Get strings from message

function_template.go

@@ -78,7 +78,10 @@ func NewFunctionTemplate(iso *Isolate, callback FunctionCallback) *FunctionTempl
 // NewFunctionTemplateWithError creates a FunctionTemplate for a given
 // callback. If the callback returns an error, it will be thrown as a
 // JS error.
-func NewFunctionTemplateWithError(iso *Isolate, callback FunctionCallbackWithError) *FunctionTemplate {
+func NewFunctionTemplateWithError(
+	iso *Isolate,
+	callback FunctionCallbackWithError,
+) *FunctionTemplate {
 	if iso == nil {
 		panic("nil Isolate argument not supported")
 	}
@@ -111,7 +114,12 @@ func (tmpl *FunctionTemplate) GetFunction(ctx *Context) *Function {
 // to workaround an ERROR_COMMITMENT_LIMIT error on windows that was detected in CI.
 //
 //export goFunctionCallback
-func goFunctionCallback(ctxref int, cbref int, thisAndArgs *C.ValuePtr, argsCount int) (rval C.ValuePtr, rerr C.ValuePtr) {
+func goFunctionCallback(
+	ctxref int,
+	cbref int,
+	thisAndArgs *C.ValuePtr,
+	argsCount int,
+) (rval C.ValuePtr, rerr C.ValuePtr) {
 	ctx := getContext(ctxref)
 
 	this := *thisAndArgs

inspector.cc

@@ -11,10 +11,7 @@ class InspectorClient : public V8InspectorClient {
   int _callbackRef;
 
  public:
-  InspectorClient(int callbackRef) {
-    _callbackRef = callbackRef;
-    printf("Client from C++");
-  }
+  InspectorClient(int callbackRef) { _callbackRef = callbackRef; }
   void consoleAPIMessage(int contextGroupId,
                          v8::Isolate::MessageErrorLevel level,
                          const StringView& message,
@@ -31,15 +28,11 @@ void InspectorClient::consoleAPIMessage(int contextGroupId,
                                         unsigned lineNumber,
                                         unsigned columnNumber,
                                         V8StackTrace*) {
-  printf("Hello from C++");
-  goHandleConsoleAPIMessageCallback(_callbackRef);
-  // if (message.is8Bit()) {
-  //   goConsoleAPIMessageUtf8(level, lineNumber, (char*)message.characters8());
-  // } else {
-  //   goConsoleAPIMessageUtf16(level, lineNumber,
-  //   (char*)message.characters16(),
-  //                            message.length() * 2);
-  // }
+  StringViewData msg;
+  msg.is8bit = message.is8Bit();
+  msg.data = message.characters8();
+  msg.length = message.length();
+  goHandleConsoleAPIMessageCallback(_callbackRef, contextGroupId, level, msg);
 }
 
 extern "C" {

inspector.go

@@ -5,6 +5,18 @@ import "C"
 import (
 	"fmt"
 	"sync"
+	"unicode/utf16"
+)
+
+type MessageErrorLevel uint8
+
+const (
+	ErrorLevelLog MessageErrorLevel = 1 << iota
+	ErrorLevelDebug
+	ErrorLevelInfo
+	ErrorLevelError
+	ErrorLevelWarning
+	ErrorLevelAll = ErrorLevelLog | ErrorLevelDebug | ErrorLevelInfo | ErrorLevelError | ErrorLevelWarning
 )
 
 type Inspector struct {
@@ -16,8 +28,6 @@ type InspectorClient struct {
 	handler ConsoleAPIMessageHandler
 }
 
-type MessageErrorLevel int
-
 // registry is a simple map of int->something. Allows passing an int to C-code
 // that can be used in a callback; then Go code can retrieve the right object
 // afterwards.
@@ -60,7 +70,7 @@ func (r *registry[T]) get(id C.int) T {
 
 type ConsoleAPIMessage struct {
 	contextGroupId int
-	errorLevel     MessageErrorLevel
+	ErrorLevel     MessageErrorLevel
 	Message        string
 	url            string
 	lineNumber     int
@@ -111,13 +121,34 @@ func (c *InspectorClient) Dispose() {
 	C.DeleteInspectorClient(c.ptr)
 }
 
+func stringViewToString(d C.StringViewData) string {
+	if d.is8bit {
+		data := C.GoBytes(d.data, d.length)
+		return string(data)
+	} else {
+		data := C.GoBytes(d.data, d.length*2)
+		shorts := make([]uint16, len(data)/2)
+		for i := 0; i < len(data); i += 2 {
+			shorts[i/2] = (uint16(data[i+1]) << 8) | uint16(data[i])
+		}
+		return string(utf16.Decode(shorts))
+	}
+}
+
+//
 //export goHandleConsoleAPIMessageCallback
-func goHandleConsoleAPIMessageCallback(callbackRef C.int) {
+func goHandleConsoleAPIMessageCallback(
+	callbackRef C.int,
+	contextGroupId C.int,
+	errorLevel C.int,
+	message C.StringViewData,
+) {
 	fmt.Println("Callback from Go")
 	// Convert data to Go data
 	client := clientRegistry.get(callbackRef)
 	client.handler.ConsoleAPIMessage(ConsoleAPIMessage{
-		Message: "Hello",
+		Message:    stringViewToString(message),
+		ErrorLevel: MessageErrorLevel(errorLevel),
 	})
 	// client.handleConsoleAPIMessageCallback(data)
 }

inspector.h

@@ -26,6 +26,8 @@ typedef v8InspectorClient* InspectorClientPtr;
 
 typedef struct v8Isolate v8Isolate;
 
+typedef _Bool bool;
+
 #endif
 
 #include <stddef.h>
@@ -43,6 +45,12 @@ extern void InspectorContextDestroyed(InspectorPtr inspector,
 extern InspectorClientPtr NewInspectorClient(int callbackRef);
 extern void DeleteInspectorClient(InspectorClientPtr client);
 
+typedef struct StringViewData {
+  bool is8bit;
+  void const* data;
+  int length;
+} StringViewData;
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif

inspector_test.go

@@ -27,14 +27,27 @@ func TestMonitorCreateDispose(t *testing.T) {
 	defer context.Close()
 	inspector.ContextCreated(context)
 	defer inspector.ContextDestroyed(context)
-	_, err := context.RunScript("console.log('Hello, world!')", "")
+	_, err := context.RunScript("console.log('Hello, world!'); console.error('Error, world!');", "")
 	if err != nil {
 		t.Error("Error occurred: " + err.Error())
 		return
 	}
-	if len(recorder.messages) != 1 {
+	if len(recorder.messages) != 2 {
 		t.Error("Expected exactly one message")
-	} else if recorder.messages[0].Message != "Hello, world!" {
-		t.Error("Expected Hello, World")
+	} else {
+		msg1 := recorder.messages[0]
+		msg2 := recorder.messages[1]
+		if msg1.ErrorLevel != v8.ErrorLevelLog {
+			t.Errorf("Expected Log error level. Got %d", msg1.ErrorLevel)
+		}
+		if msg2.ErrorLevel != v8.ErrorLevelError {
+			t.Errorf("Expected Error error level. Got: %d", msg2.ErrorLevel)
+		}
+		if msg1.Message != "Hello, world!" {
+			t.Errorf("Expected Hello, World, got %s", msg1.Message)
+		}
+		if msg2.Message != "Error, world!" {
+			t.Errorf("Expected Error, world!, got %s", msg2.Message)
+		}
 	}
 }