fix: fix message and request leaks.

Author: andycall

bridge/scripts/code_generator/src/ts_types/dap/generateSource.ts

@@ -22,6 +22,12 @@ const initializeTypes: {
     array: boolean
   }
 } = {};
+const freeTypes: {
+  [key: string]: {
+    normal: boolean;
+    array: boolean
+  }
+} = {};
 
 function generateTypeStringify(object: ClassObject, propName: string, info: DAPInfoCollector, externalInitialize: string[]): void {
   if (stringifyTypes[object.name]) return;
@@ -431,6 +437,106 @@ function generateResponseBodyStringifyCode(info: DAPInfoCollector, responses: st
 }
 
 
+function generateTypeFree(object: ClassObject, propType: ParameterType, info: DAPInfoCollector, externalInitialize: string[], isArray?: boolean) {
+  if (freeTypes[object.name]) {
+    const type = freeTypes[object.name];
+    if (isArray) {
+      if (type.array) {
+        return;
+      }
+    } else {
+      if (type.normal) return;
+    }
+  }
+  freeTypes[object.name] = {
+    normal: !isArray,
+    array: !!isArray
+  };
+  let freeCode: string[] = [];
+  if (object.props) {
+    object.props.forEach(prop => {
+      let code = generatePropFree(prop, externalInitialize, info);
+      if (code) {
+        freeCode.push(code);
+      }
+    });
+  }
+
+  let initCode = '';
+
+  if (isArray) {
+    initCode = `
+  for(int i = 0; i < length; i ++) {   
+    ${freeCode.join('\n')}
+  }
+  js_free(ctx, args);
+`;
+  } else {
+    initCode = `
+    ${freeCode.join('\n')}
+    js_free(ctx, args);
+    `;
+  }
+
+  externalInitialize.push(`static ${object.name}* free_property_${getTypeName(propType)}${isArray ? '_1' : ''}(JSContext* ctx, ${object.name}* args${isArray ? ', size_t length' : ''}) {
+${initCode}
+}`);
+}
+
+function generatePropFree(prop: PropsDeclaration, externalInitialize: string[], info: DAPInfoCollector): string | null {
+  const typeKind = getTypeKind(prop.type);
+  let callCode = '';
+  if (typeKind === PropTypeKind.normal || typeKind === PropTypeKind.normalArray) {
+    let value = prop.type.value;
+    const isArray = prop.type.isArray;
+
+    if (value === FunctionArgumentType.dom_string) {
+      callCode += `free_property_string${isArray ? '_1' : ''}(ctx, args->${prop.name}${isArray ? `, args->${prop.name}Len` : ''});`
+    }
+  } else if (typeKind === PropTypeKind.reference || typeKind === PropTypeKind.referenceArray) {
+    let targetTypes = Array.from(info.others).find(o => {
+      return o.name === getTypeName(prop.type)
+    });
+    if (targetTypes) {
+      const isArray = prop.type.isArray;
+      generateTypeFree(targetTypes, prop.type, info, externalInitialize, isArray);
+      callCode += `free_property_${getTypeName(prop.type)}${isArray ? '_1' : ''}(ctx, args->${prop.name}${isArray ? `, args->${prop.name}Len` : ''});\n`;
+    }
+  }
+
+  return callCode;
+}
+
+function generateRequestArgumentFreeCode(info: DAPInfoCollector, requests: string[], externalInitialize: string[]) {
+  return requests.map(request => {
+    let targetArgument = Array.from(info.arguments).find((ag) => {
+      const prefix = ag.name.replace('Arguments', '');
+      return request.indexOf(prefix) >= 0;
+    });
+
+    if (!targetArgument) {
+      return '';
+    }
+
+    let freeCode: string[] = [];
+    if (targetArgument.props) {
+      targetArgument.props.forEach(prop => {
+        let code = generatePropFree(prop, externalInitialize, info);
+        if (code) {
+          freeCode.push(code);
+        }
+      });
+    }
+    const name = request.replace('Request', '');
+    return addIndent(`if (strcmp(command, "${_.camelCase(name)}") == 0) {
+    ${name}Arguments* args = (${name}Arguments*) arguments;
+    ${freeCode.join('\n')}  
+    js_free(ctx, args);
+}`, 2);
+
+  }).join('\n');
+}
+
 export function generateDAPSource(info: DAPInfoCollector) {
   const requests: string[] = getLists(info.requests);
   const events: string[] = getLists(info.events);
@@ -442,6 +548,7 @@ export function generateDAPSource(info: DAPInfoCollector) {
   const responseInit = generateResponseInitializer(info, responses, externalInitialize);
   const eventBodyStringifyCode = generateEventBodyStringifyCode(info, events, externalInitialize);
   const responseBodyStringifyCode = generateResponseBodyStringifyCode(info, responses, externalInitialize);
+  const freeEventArgument = generateRequestArgumentFreeCode(info, requests, externalInitialize);
   return _.template(readConverterTemplate())({
     info,
     requests,
@@ -450,7 +557,8 @@ export function generateDAPSource(info: DAPInfoCollector) {
     responseInit,
     eventBodyStringifyCode,
     responseBodyStringifyCode,
-    externalInitialize
+    externalInitialize,
+    freeEventArgument
   }).split('\n').filter(str => {
     return str.trim().length > 0;
   }).join('\n');

bridge/scripts/code_generator/templates/dap_templates/dap_converter.c.tpl

@@ -1,3 +1,6 @@
+// Generated from template:
+//   code_generator/templates/dap_templates/dap_converter.h.tpl
+
 /*
 * Copyright (C) 2022-present The WebF authors. All rights reserved.
 */
@@ -49,6 +52,15 @@ static const char** get_property_string_copy_1(JSContext* ctx, JSValue this_obje
 
   return return_value;
 }
+static void free_property_string(JSContext* ctx, const char* str) {
+  js_free(ctx, (void*) str);
+}
+
+static void free_property_string_1(JSContext* ctx, const char** str, size_t length) {
+  for(int i = 0; i < length; i ++) {
+    js_free(ctx, (void*) str[i]);
+  }
+}
 static int64_t get_property_int64(JSContext* ctx, JSValue this_object, const char* prop) {
  JSValue vp = JS_GetPropertyStr(ctx, this_object, prop);
  int64_t v;
@@ -152,4 +164,23 @@ const char* stringify_response(JSContext* ctx, Response* response) {
  JS_FreeValue(ctx, object);
  return result;
 }
+
+static void free_request_arguments(JSContext* ctx, void* arguments, const char* command) {
+  <%= freeEventArgument %>
+}
+
+void free_request(JSContext* ctx, Request* request) {
+  const char* command = request->command;
+  free_request_arguments(ctx, request->arguments, command);
+  js_free(ctx, request);
+}
+
+void free_response(JSContext* ctx, Response* response) {
+
+}
+
+void free_event(JSContext* const, Event* event) {
+
+}
+
 #endif

bridge/scripts/code_generator/templates/dap_templates/dap_converter.h.tpl

@@ -1,3 +1,6 @@
+// Generated from template:
+//   code_generator/templates/dap_templates/dap_converter.cc.tpl
+
 /*
 * Copyright (C) 2022-present The WebF authors. All rights reserved.
  */
@@ -14,5 +17,8 @@ const char* stringify_event(JSContext* ctx, Event* event, size_t* length);
 void* initialize_event(JSContext* ctx, const char* type);
 void* initialize_response(JSContext* ctx, const Request* corresponding_request, const char* type);
 const char* stringify_response(JSContext* ctx, Response* response);
+void free_request(JSContext* ctx, Request* request);
+void free_response(JSContext* ctx, Response* response);
+void free_event(JSContext* ctx, Event* event);
 
 #endif

bridge/scripts/code_generator/templates/dap_templates/dap_protocol.h.tpl

@@ -1,3 +1,5 @@
+// Generated from template:
+//   code_generator/templates/dap_templates/dap_protocol.h.tpl
 /*
  * Copyright (C) 2022-present The WebF authors. All rights reserved.
  */

bridge/third_party/quickjs/src/core/dap_protocol.d.ts

@@ -164,6 +164,22 @@ interface StoppedEventBody {
   hitBreakpointIds?: number[];
 }
 
+interface TerminatedEventBody {
+  /**
+   * A debug adapter may set `restart` to true (or to an arbitrary object) to
+   * request that the client restarts the session.
+   * The value is not interpreted by the client and passed unmodified as an
+   * attribute `__restart` to the `launch` and `attach` requests.
+   */
+  restart?: any;
+}
+
+interface TerminatedEvent extends Event {
+  event: 'terminated';
+
+  body?: TerminatedEventBody;
+}
+
 interface StoppedEvent extends Event {
   event: 'stopped';
   body: StoppedEventBody;

bridge/third_party/quickjs/src/core/debugger.c

@@ -199,35 +199,11 @@ static uint32_t write_backend_message(JSDebuggerInfo* info, const char* buffer,
   return 1;
 }
 
-static uint32_t js_transport_write_fully(JSDebuggerInfo* info, const char* buffer, size_t length) {
-  return write_backend_message(info, buffer, length);
-}
-
 static void js_transport_send_response(JSDebuggerInfo* info, JSContext* ctx, Response* response) {
   const char* buf = stringify_response(ctx, (Response*) response);
   write_backend_message(info, buf, strlen(buf));
 }
 
-static uint32_t js_transport_write_value(JSDebuggerInfo* info, JSValue value) {
-  JSValue stringified = JS_JSONStringify(info->ctx, value, JS_UNDEFINED, JS_UNDEFINED);
-  size_t len;
-  const char* str = JS_ToCStringLen(info->ctx, &len, stringified);
-  uint32_t ret = 0;
-  if (len)
-    ret = js_transport_write_fully(info, str, len);
-  // else send error somewhere?
-  JS_FreeCString(info->ctx, str);
-  JS_FreeValue(info->ctx, stringified);
-  JS_FreeValue(info->ctx, value);
-  return ret;
-}
-
-static JSValue js_transport_new_envelope(JSDebuggerInfo* info, const char* type) {
-  JSValue ret = JS_NewObject(info->ctx);
-  JS_SetPropertyStr(info->ctx, ret, "type", JS_NewString(info->ctx, type));
-  return ret;
-}
-
 static void js_transport_send_event(JSDebuggerInfo* info, Event* event) {
   size_t length;
   const char* buf = stringify_event(info->ctx, event, &length);
@@ -394,8 +370,7 @@ static void process_request(JSDebuggerInfo* info, struct DebuggerSuspendedState*
     response->body->type = variable_type.type;
     response->body->variablesReference = variable_type.variablesReference;
 
-    const char* buf = stringify_response(ctx, (Response*)response);
-    write_backend_message(info, buf, strlen(buf));
+    js_transport_send_response(info, ctx, (Response*) response);
 
     JS_FreeCString(ctx, evaluate_result);
     JS_FreeValue(ctx, result);
@@ -639,6 +614,9 @@ static void js_process_debugger_messages(JSDebuggerInfo* info, const uint8_t* cu
     Request* request = js_malloc(ctx, sizeof(Request));
     parse_request(ctx, request, item.buf, item.length);
     process_request(info, &state, request);
+    free_request(ctx, request);
+
+    js_free(ctx, item.buf);
   } while (info->is_paused);
 
 done:
@@ -780,8 +758,8 @@ void js_debugger_free(JSRuntime* rt, JSDebuggerInfo* info) {
     return;
 
   // don't use the JSContext because it might be in a funky state during teardown.
-  const char* terminated = "{\"type\":\"event\",\"event\":{\"type\":\"terminated\"}}";
-  js_transport_write_fully(info, terminated, strlen(terminated));
+  TerminatedEvent* event = initialize_event(info->ctx, "terminated");
+  js_transport_send_event(info, (Event*) event);
 
   struct list_head* el;
 

webf/lib/src/devtools/server.dart

@@ -6,7 +6,6 @@
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
-import 'dart:developer';
 import 'dart:io';
 import 'dart:isolate';
 import 'dart:ffi';
@@ -198,13 +197,15 @@ class IsolateInspector {
 
     DartDebuggerReadBackendCommands fn = debuggerMethods.ref.readBackendCommands.asFunction();
     if (fn != nullptr) {
-      Pointer<DebuggerMessageBuffer> buffer = malloc.allocate(sizeOf<DebuggerMessageBuffer>());
-      int result = fn(debuggerContext, buffer);
+      Pointer<DebuggerMessageBuffer> message = malloc.allocate(sizeOf<DebuggerMessageBuffer>());
+      int result = fn(debuggerContext, message);
       if (result == 0) {
-        Timer.run(readDebuggerBackendMessage);
+        malloc.free(message.ref.buffer);
+        malloc.free(message);
+        Timer(Duration(milliseconds: 1), readDebuggerBackendMessage);
         return;
       }
-      String str = buffer.ref.buffer.toDartString(length: buffer.ref.length);
+      String str = message.ref.buffer.toDartString(length: message.ref.length);
       print('backend $str');
       if (_ws != null) {
         if (clientKind == ConnectionClientKind.vscode) {
@@ -213,12 +214,13 @@ class IsolateInspector {
           // TODO: Add adaptor from DAP to CDP..
         }
       } else {
-        _pendingDebuggerMessages.add(str);
+        // _pendingDebuggerMessages.add(str);
       }
-      malloc.free(buffer);
+      malloc.free(message.ref.buffer);
+      malloc.free(message);
     }
 
-    Timer.run(readDebuggerBackendMessage);
+    Timer(Duration(seconds: 1), readDebuggerBackendMessage);
   }
 
   void _flushPendingDebuggerMessage() {