upgrade-dev v2.3.13

cef/cef-application-callback.go

@@ -30,7 +30,6 @@ func appMainRunCallback() {
 
 // renderProcessMessageReceived 渲染进程消息 - 默认实现
 func renderProcessMessageReceived(browser *ICefBrowser, frame *ICefFrame, sourceProcess consts.CefProcessId, message *ICefProcessMessage) (result bool) {
-	fmt.Println("render name", message.Name())
 	if message.Name() == internalProcessMessageIPCEmitReply {
 		result = ipcRender.ipcJSExecuteGoEventMessageReply(browser, frame, sourceProcess, message)
 	} else if message.Name() == internalProcessMessageIPCOn {
@@ -41,7 +40,6 @@ func renderProcessMessageReceived(browser *ICefBrowser, frame *ICefFrame, source
 
 // browserProcessMessageReceived 主进程消息 - 默认实现
 func browserProcessMessageReceived(browser *ICefBrowser, frame *ICefFrame, sourceProcess consts.CefProcessId, message *ICefProcessMessage) (result bool) {
-	fmt.Println("browser name", message.Name())
 	if message.Name() == internalProcessMessageIPCEmit {
 		result = ipcBrowser.ipcGoExecuteMethodMessage(browser, frame, sourceProcess, message)
 	} else if message.Name() == internalProcessMessageIPCOn {

cef/cef-ipc-browser.go

@@ -84,14 +84,15 @@ func (m *ipcBrowserProcess) ipcGoExecuteMethodMessage(browser *ICefBrowser, fram
 		messageId = int32(argument.GetIntByKey(ipc_id))
 		emitName = argument.GetStringByKey(ipc_event)
 		argumentList = argument.GetArrayByKey(ipc_argumentList)
+		messageDataBytes = nil
 	}
 	defer func() {
-		if argument != nil {
-			argument.Free()
-		}
 		if argumentList != nil {
 			argumentList.Free()
 		}
+		if argument != nil {
+			argument.Free()
+		}
 	}()
 	argumentListBytes = nil
 	eventCallback := ipc.CheckOnEvent(emitName)
@@ -106,8 +107,6 @@ func (m *ipcBrowserProcess) ipcGoExecuteMethodMessage(browser *ICefBrowser, fram
 		argsCallback.Invoke(ipcContext)
 	}
 	if messageId != 0 { // 回调函数处理
-		//replyMessage := ProcessMessageRef.new(internalProcessMessageIPCEmitReply)
-		//replyMessage.ArgumentList().SetInt(0, messageId)
 		replyMessage := json.NewJSONArray(nil)
 		replyMessage.Add(messageId)
 		replyMessage.Add(false)
@@ -116,27 +115,19 @@ func (m *ipcBrowserProcess) ipcGoExecuteMethodMessage(browser *ICefBrowser, fram
 		if replay.Result() != nil && len(replay.Result()) > 0 {
 			switch replay.Result()[0].(type) {
 			case []byte:
-				//binaryValue := BinaryValueRef.New((replay.Result()[0]).([]byte))
-				//replyMessage.ArgumentList().SetBool(1, true)          //有返回值
-				//replyMessage.ArgumentList().SetBinary(2, binaryValue) //result []byte
 				replyMessage.SetByIndex(1, true)
 				replyMessage.Add((replay.Result()[0]).([]byte))
-			default:
-				//replyMessage.ArgumentList().SetBool(1, false) //无返回值
 			}
-		} else {
-			//replyMessage.ArgumentList().SetBool(1, false) //无返回值
 		}
-		//frame.SendProcessMessage(consts.PID_RENDER, replyMessage)
 		frame.SendProcessMessageForJSONBytes(internalProcessMessageIPCEmitReply, consts.PID_RENDER, replyMessage.Bytes())
 		replyMessage.Free()
 		replay.Clear()
-		//replyMessage.Free()
 	}
 	if ipcContext.ArgumentList() != nil {
 		ipcContext.ArgumentList().Free()
 	}
 	ipcContext.Result(nil)
+
 	return
 }
 

cef/cef-ipc-render.go

@@ -232,7 +232,7 @@ func (m *ipcRenderProcess) ipcJSExecuteGoEvent(name string, object *ICefV8Value,
 		context := V8ContextRef.Current()
 		var messageId int32 = 0
 		//回调函数
-		if emitCallback != nil && false {
+		if emitCallback != nil {
 			//回调函数临时存放到缓存中
 			emitCallback.SetCanNotFree(true)
 			messageId = ipcRender.emitHandler.addCallback(&ipcCallback{
@@ -247,10 +247,11 @@ func (m *ipcRenderProcess) ipcJSExecuteGoEvent(name string, object *ICefV8Value,
 		message.Set(ipc_id, messageId)
 		message.Set(ipc_event, emitNameValue)
 		message.Set(ipc_argumentList, json.NewJSONArray(args).Data())
-		//frame.SendProcessMessageForJSONBytes(internalProcessMessageIPCEmit, consts.PID_BROWSER, message.Bytes())
+		frame.SendProcessMessageForJSONBytes(internalProcessMessageIPCEmit, consts.PID_BROWSER, message.Bytes())
 		message.Free()
 		frame.Free()
-		context.Free() // TODO dev
+		args = nil
+		//context.Free() // TODO dev
 		retVal.SetResult(V8ValueRef.NewBool(true))
 	}
 	return
@@ -259,7 +260,6 @@ func (m *ipcRenderProcess) ipcJSExecuteGoEvent(name string, object *ICefV8Value,
 // ipcJSExecuteGoEventMessageReply JS执行Go监听，Go的消息回复
 func (m *ipcRenderProcess) ipcJSExecuteGoEventMessageReply(browser *ICefBrowser, frame *ICefFrame, sourceProcess consts.CefProcessId, message *ICefProcessMessage) (result bool) {
 	result = true
-	//messageId := message.ArgumentList().GetInt(0)
 	argumentListBytes := message.ArgumentList().GetBinary(0)
 	var messageDataBytes []byte
 	if argumentListBytes.IsValid() {
@@ -272,34 +272,35 @@ func (m *ipcRenderProcess) ipcJSExecuteGoEventMessageReply(browser *ICefBrowser,
 			return
 		}
 	}
-	var messageId int32
-	var isReturnArgs bool
-	var argumentList json.JSONArray
+	var (
+		messageId    int32
+		isReturnArgs bool
+		argumentList json.JSONArray
+	)
 	if messageDataBytes != nil {
 		argumentList = json.NewJSONArray(messageDataBytes)
 		messageId = int32(argumentList.GetIntByIndex(0))
 		isReturnArgs = argumentList.GetBoolByIndex(1)
+		messageDataBytes = nil
 	}
-	defer func() {}()
+	defer func() {
+		if argumentList != nil {
+			argumentList.Free()
+		}
+	}()
 
-	fmt.Println("messageId", messageId, isReturnArgs)
 	if callback := ipcRender.emitHandler.getCallback(messageId); callback != nil {
+		callback.function.SetCanNotFree(false)
 		//第二个参数 true 有返回参数
 		if isReturnArgs {
 			//[]byte
-			//returnArgs := argumentList.GetArrayByIndex(2)
-			//fmt.Println("returnArgs", argumentList.GetArrayByIndex(2).ToJSONString())
+			returnArgs := argumentList.GetArrayByIndex(2)
 			//解析 '[]byte' 参数
-			//if callback.context.Enter() {
-			//	if args, err := ipcValueConvert.BytesToV8ArrayValue(resultArgsBytes); err == nil {
-			//		callback.function.ExecuteFunctionWithContext(callback.context, nil, args).Free()
-			//		args.Free()
-			//	} else {
-			//		// parsing error
-			//		callback.function.ExecuteFunctionWithContext(callback.context, nil, nil).Free()
-			//	}
-			//}
-			//callback.context.Exit()
+			if callback.context.Enter() {
+				callback.function.ExecuteFunctionWithContextForArgsBytes(callback.context, nil, returnArgs.Bytes()).Free()
+				callback.context.Exit()
+			}
+			returnArgs.Free()
 		} else { //无返回参数
 			if callback.context.Enter() {
 				callback.function.ExecuteFunctionWithContext(callback.context, nil, nil).Free()

cef/cef-ipc-value-convert.go

@@ -15,6 +15,7 @@ package cef
 
 import (
 	"errors"
+	"fmt"
 	"github.com/energye/energy/common/imports"
 	"github.com/energye/energy/consts"
 	"github.com/energye/energy/pkgs/json"
@@ -563,10 +564,15 @@ func (m *v8ValueProcessMessageConvert) BytesToV8ValueArray(data []byte) *TCefV8V
 	var result uintptr
 	var resultLength uintptr
 	imports.Proc(internale_ValueConvert_BytesToV8ValueArray).Call(uintptr(unsafe.Pointer(&data[0])), uintptr(uint32(len(data))), uintptr(unsafe.Pointer(&result)), uintptr(unsafe.Pointer(&resultLength)))
+	fmt.Println("result", result, resultLength)
 	if result == 0 || resultLength == 0 {
 		return nil
 	}
-	return &TCefV8ValueArray{instance: unsafe.Pointer(result), argumentsLength: int(resultLength)}
+	v := &TCefV8ValueArray{instance: unsafe.Pointer(result), arguments: result, argumentsLength: int(resultLength) /*, argumentsCollect: make([]*ICefV8Value, int(resultLength))*/}
+	//for i := 0; i < v.argumentsLength; i++ {
+	//	v.Get(i)
+	//}
+	return v
 }
 
 // JSONArrayToV8ValueArray 转换 TCefV8ValueArray

cef/cef-proc-def.go

@@ -865,6 +865,7 @@ func init() {
 		dllimports.NewEnergyImport("CefV8Value_GetFunctionHandler", 0),
 		dllimports.NewEnergyImport("CefV8Value_ExecuteFunction", 0),
 		dllimports.NewEnergyImport("CefV8Value_ExecuteFunctionWithContext", 0),
+		dllimports.NewEnergyImport("CefV8Value_ExecuteFunctionWithContextForArgsBytes", 0),
 		dllimports.NewEnergyImport("CefV8Value_ResolvePromise", 0),
 		dllimports.NewEnergyImport("CefV8Value_RejectPromise", 0),
 		dllimports.NewEnergyImport("CefV8Value_Free", 0),
@@ -1102,6 +1103,7 @@ func init() {
 		dllimports.NewEnergyImport("ValueConvert_BytesToListValue", 0),
 		dllimports.NewEnergyImport("ValueConvert_BytesToDictionaryValue", 0),
 		dllimports.NewEnergyImport("ValueConvert_BytesToV8ValueArray", 0),
+		dllimports.NewEnergyImport("ValueConvert_BytesToV8ValueArrayFree", 0),
 		dllimports.NewEnergyImport("ValueConvert_BytesToV8Array", 0),
 		dllimports.NewEnergyImport("ValueConvert_BytesToV8Object", 0),
 	}
@@ -1956,6 +1958,7 @@ const (
 	internale_CefV8Value_GetFunctionHandler
 	internale_CefV8Value_ExecuteFunction
 	internale_CefV8Value_ExecuteFunctionWithContext
+	internale_CefV8Value_ExecuteFunctionWithContextForArgsBytes
 	internale_CefV8Value_ResolvePromise
 	internale_CefV8Value_RejectPromise
 	internale_CefV8Value_Free
@@ -2193,6 +2196,7 @@ const (
 	internale_ValueConvert_BytesToListValue
 	internale_ValueConvert_BytesToDictionaryValue
 	internale_ValueConvert_BytesToV8ValueArray
+	internale_ValueConvert_BytesToV8ValueArrayFree
 	internale_ValueConvert_BytesToV8Array
 	internale_ValueConvert_BytesToV8Object
 )

cef/cef-types-v8-value.go

@@ -490,15 +490,15 @@ func (m *ICefV8Value) GetFunctionHandler() *ICefV8Handler {
 
 func (m *ICefV8Value) ExecuteFunction(obj *ICefV8Value, arguments *TCefV8ValueArray) *ICefV8Value {
 	var result uintptr
-	var ptr uintptr
-	if arguments.Size() > 0 {
+	var argumentsPtr = arguments.Instance()
+	if arguments.Size() > 0 /*&& arguments.argumentsCollect != nil*/ {
 		var args = make([]uintptr, arguments.Size(), arguments.Size())
 		for i, a := range arguments.argumentsCollect {
 			args[i] = a.Instance()
 		}
-		ptr = uintptr(unsafe.Pointer(&args[0]))
+		argumentsPtr = uintptr(unsafe.Pointer(&args[0]))
 	}
-	imports.Proc(internale_CefV8Value_ExecuteFunction).Call(m.Instance(), obj.Instance(), uintptr(unsafe.Pointer(&result)), ptr, uintptr(int32(arguments.Size())))
+	imports.Proc(internale_CefV8Value_ExecuteFunction).Call(m.Instance(), obj.Instance(), uintptr(unsafe.Pointer(&result)), argumentsPtr, uintptr(int32(arguments.Size())))
 	return &ICefV8Value{
 		instance: unsafe.Pointer(result),
 	}
@@ -506,15 +506,25 @@ func (m *ICefV8Value) ExecuteFunction(obj *ICefV8Value, arguments *TCefV8ValueAr
 
 func (m *ICefV8Value) ExecuteFunctionWithContext(v8Context *ICefV8Context, obj *ICefV8Value, arguments *TCefV8ValueArray) *ICefV8Value {
 	var result uintptr
-	var ptr uintptr
-	if arguments.Size() > 0 {
+	var argumentsPtr = arguments.Instance()
+	if arguments.Size() > 0 && arguments.argumentsCollect != nil {
 		var args = make([]uintptr, arguments.Size(), arguments.Size())
-		for i, a := range arguments.argumentsCollect {
-			args[i] = a.Instance()
+		for i, v := range arguments.argumentsCollect {
+			args[i] = v.Instance()
 		}
-		ptr = uintptr(unsafe.Pointer(&args[0]))
+		argumentsPtr = uintptr(unsafe.Pointer(&args[0]))
 	}
-	imports.Proc(internale_CefV8Value_ExecuteFunctionWithContext).Call(m.Instance(), v8Context.Instance(), obj.Instance(), uintptr(unsafe.Pointer(&result)), ptr, uintptr(int32(arguments.Size())))
+	imports.Proc(internale_CefV8Value_ExecuteFunctionWithContext).Call(m.Instance(), v8Context.Instance(), obj.Instance(), uintptr(unsafe.Pointer(&result)), argumentsPtr, uintptr(int32(arguments.Size())))
+	return &ICefV8Value{
+		instance: unsafe.Pointer(result),
+	}
+}
+
+func (m *ICefV8Value) ExecuteFunctionWithContextForArgsBytes(v8Context *ICefV8Context, obj *ICefV8Value, arguments []byte) *ICefV8Value {
+	var result uintptr
+	var argumentsPtr = uintptr(unsafe.Pointer(&arguments[0]))
+	var argumentsLength = uintptr(uint32(len(arguments)))
+	imports.Proc(internale_CefV8Value_ExecuteFunctionWithContextForArgsBytes).Call(m.Instance(), v8Context.Instance(), obj.Instance(), argumentsPtr, argumentsLength, uintptr(unsafe.Pointer(&result)))
 	return &ICefV8Value{
 		instance: unsafe.Pointer(result),
 	}
@@ -536,6 +546,21 @@ func (m *ICefV8Value) SetCanNotFree(v bool) {
 
 func (m *ICefV8Value) Free() {
 	if m.instance != nil {
+		//if m.IsArray() {
+		//	for i := 0; i < m.GetArrayLength(); i++ {
+		//		if v := m.GetValueByIndex(i); v != nil {
+		//			v.Free()
+		//		}
+		//	}
+		//}
+		//if m.IsObject() {
+		//	keys := m.GetKeys()
+		//	for i := 0; i < keys.Count(); i++ {
+		//		if v := m.getValueByKey(keys.Get(i)); v != nil {
+		//			v.Free()
+		//		}
+		//	}
+		//}
 		if m.valueByIndex != nil {
 			for _, v := range m.valueByIndex {
 				if v != nil {
@@ -620,12 +645,16 @@ func (m *TCefV8ValueArray) Free() {
 	}
 	if m.argumentsCollect != nil {
 		for _, v := range m.argumentsCollect {
-			if v != nil && v.instance != nil {
+			if v != nil {
 				v.Free()
 			}
 		}
 		m.argumentsCollect = nil
 	}
+	if m.instance != nil {
+		//var ptr = m.Instance()
+		//imports.Proc(internale_ValueConvert_BytesToV8ValueArrayFree).Call(uintptr(unsafe.Pointer(&ptr)))
+	}
 	m.instance = nil
 	m.arguments = 0
 	m.argumentsLength = 0

example/dev-test/ipc-event/ipc-event.go

@@ -114,7 +114,7 @@ func main() {
 	ipc.On("testEmitName", func(context ipc.IContext) {
 		testEmitName++
 		argument := context.ArgumentList()
-		fmt.Println("testEmitName", argument.Size(), context.BrowserId(), context.FrameId(), testEmitName)
+		//fmt.Println("testEmitName", argument.Size(), context.BrowserId(), context.FrameId(), testEmitName)
 		//fmt.Println("data:", argument.GetByIndex(1).Data())
 		for i := 0; i < argument.Size(); i++ {
 			argument.GetByIndex(i)