energy/cef/ipc_render.go

//----------------------------------------
//
// Copyright © yanghy. All Rights Reserved.
//
// Licensed under Apache License Version 2.0, January 2004
//
// https://www.apache.org/licenses/LICENSE-2.0
//
//----------------------------------------

// energy 渲染进程 IPC

package cef

import (
	"errors"
	"github.com/energye/energy/v2/cef/internal/ipc"
	ipcArgument "github.com/energye/energy/v2/cef/ipc/argument"
	"github.com/energye/energy/v2/cef/ipc/context"
	"github.com/energye/energy/v2/cef/ipc/target"
	"github.com/energye/energy/v2/consts"
	"github.com/energye/energy/v2/pkgs/json"
	"time"
)

// ipcRenderProcess 渲染进程
type ipcRenderProcess struct {
	isInitRenderIPC bool
	ipcObject       *ICefV8Value            // ipc object
	emitHandler     *ipcEmitHandler         // ipc.emit handler
	onHandler       map[int64]*ipcOnHandler // ipc.on handler
	waitChan        *ipc.WaitChan
}

func (m *ipcRenderProcess) clear(frameId int64) {
	if m.ipcObject != nil {
		m.ipcObject.Free()
		m.ipcObject = nil
	}
	if m.onHandler != nil {
		if on, ok := m.onHandler[frameId]; ok {
			on.clear()
			delete(m.onHandler, frameId)
		}
	}
}

// JS ipc.on 监听事件
func (m *ipcOnHandler) jsOnEvent(name string, object *ICefV8Value, arguments *TCefV8ValueArray, retVal *ResultV8Value, exception *ResultString) (result bool) {
	if name != internalIPCOn {
		return
	} else if arguments.Size() != 2 { //必须是2个参数
		exception.SetValue("ipc.on parameter should be 2 quantity")
		arguments.Free()
		return
	}
	var (
		onName      *ICefV8Value // 事件名
		onNameValue string       // 事件名
		onCallback  *ICefV8Value // 事件回调函数
	)
	onName = arguments.Get(0)
	//事件名，第一个参数必须是字符串
	if !onName.IsString() {
		exception.SetValue("ipc.on event name should be a string")
		arguments.Free()
		return
	}
	onCallback = arguments.Get(1)
	//回调函数，第二个参数必须是函数
	if !onCallback.IsFunction() {
		exception.SetValue("ipc.on event callback should be a function")
		arguments.Free()
		return
	}
	retVal.SetResult(V8ValueRef.NewBool(true))
	onCallback.SetCanNotFree(true)
	onNameValue = onName.GetStringValue()
	//ipc on
	m.addCallback(onNameValue, &ipcCallback{function: V8ValueRef.UnWrap(onCallback), name: V8ValueRef.UnWrap(onName)})
	result = true
	return
}

// Go ipc.emit 执行JS事件
func (m *ipcRenderProcess) ipcGoExecuteJSEvent(browser *ICefBrowser, frame *ICefFrame, sourceProcess consts.CefProcessId, message *ICefProcessMessage) (result bool) {
	on, ok := m.onHandler[frame.Identifier()]
	if !ok {
		return false
	}
	result = true
	argumentListBytes := message.ArgumentList().GetBinary(0)
	//接收二进制数据失败
	if argumentListBytes == nil {
		return
	}
	var messageDataBytes []byte
	if argumentListBytes.IsValid() {
		size := argumentListBytes.GetSize()
		messageDataBytes = make([]byte, size)
		c := argumentListBytes.GetData(messageDataBytes, 0)
		argumentListBytes.Free()
		message.Free()
		if c == 0 {
			return
		}
	}
	var messageId int32
	var emitName string
	var argument ipcArgument.IList
	var argumentList json.JSONArray
	if messageDataBytes != nil {
		argument = ipcArgument.UnList(messageDataBytes)
		messageId = argument.MessageId()
		emitName = argument.GetEventName()
		if argument.JSON() != nil {
			argumentList = argument.JSON().JSONArray()
		}
		messageDataBytes = nil
	}
	defer func() {
		if argument != nil {
			argument.Reset()
		}
		if argumentList != nil {
			argumentList.Free()
		}
	}()

	if callback := on.getCallback(emitName); callback != nil {
		var callbackArgsBytes interface{}
		//enter v8context
		ctx := frame.V8Context()
		if ctx.Enter() {
			var ret *ICefV8Value
			var argsArray *TCefV8ValueArray
			var err error
			if argumentList != nil {
				//bytes to v8array value
				argsArray, err = ValueConvert.BytesToV8ArrayValue(argumentList.Bytes())
			}
			if argsArray != nil && err == nil {
				// parse v8array success
				ret = callback.function.ExecuteFunctionWithContext(ctx, nil, argsArray)
				argsArray.Free()
			} else {
				// parse v8array fail
				ret = callback.function.ExecuteFunctionWithContext(ctx, nil, nil)
			}
			if ret != nil && ret.IsValid() && messageId != 0 { // messageId != 0 callback func args
				// v8value to process message bytes
				callbackArgsBytes = ValueConvert.V8ValueToProcessMessageArray(ret)
				ret.Free()
			} else if ret != nil {
				ret.Free()
			}
			//exit v8context
			ctx.Exit()
		}
		ctx.Free()
		if messageId != 0 { //messageId != 0 callback func
			callbackMessage := &ipcArgument.List{
				Id:   messageId,
				BId:  ipc.RenderChan().BrowserId(),
				Name: internalIPCGoExecuteJSEventReplay,
			}
			if callbackArgsBytes != nil {
				callbackMessage.Data = callbackArgsBytes //json.NewJSONArray(callbackArgsBytes).Data()
			}
			// send ipc message
			// send bytes data to browser ipc
			ipc.RenderChan().IPC().Send(callbackMessage.Bytes())
			callbackMessage.Reset()
		}
	}
	return
}

// 规则选项名定义
const (
	ruleName      = "name"
	ruleArguments = "arguments"
	ruleCallback  = "callback"
	ruleMode      = "mode"
	ruleWaitTime  = "waitTime"
	ruleTarget    = "target"
)

// 触发模式
type modelRule int8

const (
	modelAsync modelRule = iota // 异步
	modelWait                   // 等待结果
)

// 触发接收目标
type targetRule int8

const (
	targetMain    targetRule = iota //主进程
	targetCurrent                   //当前进程
	targetOther                     //其它子进程
)

// 执行规则
type executeRule int8

const (
	exerOption executeRule = iota //选项
	exerArgs                      //参数
)

// 触发模式是 modelWait 时的默认等待时间
const defaultEmitWaitTime = 5 * time.Second

// jsExecuteRule
//
//	JS 执行规则
type jsExecuteRule struct {
	rule          executeRule   //规则
	model         modelRule     //模式 默认 modelAsync
	waitTime      time.Duration //等待时间，当触发模式为 modelWait 有效, 默认5000毫秒
	target        targetRule    //目标 默认 targetMain
	first         *ICefV8Value  //
	emitName      *ICefV8Value  //事件名
	emitNameValue string        //事件名值
	emitArgs      *ICefV8Value  //事件参数
	emitCallback  *ICefV8Value  //事件回调函数
}

// freeV8Value
func (*jsExecuteRule) freeV8Value(value *ICefV8Value) {
	if value != nil {
		value.Free()
	}
}

// freeAll
func (m *jsExecuteRule) freeAll() {
	m.freeV8Value(m.first)
	m.freeV8Value(m.emitName)
	m.freeV8Value(m.emitArgs)
	m.freeV8Value(m.emitCallback)
	m.emitNameValue = ""
}

// 执行规则
func (*ipcRenderProcess) jsExecuteGoRule(name string, arguments *TCefV8ValueArray) (*jsExecuteRule, error) {
	if arguments.Size() >= 1 {
		m := new(jsExecuteRule)
		m.first = arguments.Get(0)
		m.waitTime = defaultEmitWaitTime // default
		if m.first.IsString() {          // args
			m.emitName = m.first
			m.emitNameValue = m.emitName.GetStringValue()
			if name == internalIPCEmitWait { // 等待超时返回结果
				m.model = modelWait
			} else {
				m.model = modelAsync // default
			}
			if arguments.Size() == 2 {
				args2 := arguments.Get(1)
				if args2.IsArray() {
					m.emitArgs = args2
				} else if m.model == modelAsync && args2.IsFunction() {
					m.emitCallback = args2
				} else if m.model == modelWait && args2.IsUInt() {
					// 等待超时触发
					waitTimeValue := args2.GetUIntValue()
					args2.Free()
					if waitTimeValue > 0 {
						m.waitTime = time.Duration(waitTimeValue) * time.Millisecond
					}
				} else {
					m.freeAll()
					if m.model == modelAsync {
						return nil, errors.New("ipc.emit second argument can only be a input parameter. third parameter can only be a callback function")
					} else {
						return nil, errors.New("ipc.emitWait second argument can only be a input parameter. third parameter can only be a timeout time")
					}
				}
			} else if arguments.Size() == 3 {
				m.emitArgs = arguments.Get(1)
				// 第三个参数, 根据触发模式
				args3 := arguments.Get(2)
				// 异步触发
				if m.model == modelAsync && args3.IsFunction() {
					m.emitCallback = args3
				} else if m.model == modelWait && args3.IsUInt() {
					// 等待超时触发
					waitTimeValue := args3.GetUIntValue()
					args3.Free()
					if waitTimeValue > 0 {
						m.waitTime = time.Duration(waitTimeValue) * time.Millisecond
					}
				} else {
					m.freeAll()
					if m.model == modelAsync {
						return nil, errors.New("ipc.emit second argument can only be a input parameter. third parameter can only be a callback function")
					} else {
						return nil, errors.New("ipc.emitWait second argument can only be a input parameter. third parameter can only be a timeout time")
					}
				}
			}

			m.rule = exerArgs
			m.target = targetMain // default
			return m, nil
		} else if m.first.IsObject() { // options
			keys := m.first.GetKeys()
			keyMap := make(map[string]bool, keys.Count())
			for i := 0; i < keys.Count(); i++ {
				keyMap[keys.Get(i)] = true
			}
			keys.Free()
			// 事件名称
			if _, ok := keyMap[ruleName]; ok {
				m.emitName = m.first.getValueByKey(ruleName)
				if !m.emitName.IsString() {
					m.freeAll()
					return nil, errors.New("ipc.emit event name is incorrect, Pass as an string")
				}
				m.emitNameValue = m.emitName.GetStringValue()
			} else {
				m.freeAll()
				return nil, errors.New("ipc.emit event name is incorrect, Pass as an string")
			}
			// 参数列表
			if _, ok := keyMap[ruleArguments]; ok {
				m.emitArgs = m.first.getValueByKey(ruleArguments) // array
				if !m.emitArgs.IsArray() {
					m.freeAll()
					return nil, errors.New("ipc.emit event arguments is incorrect, Pass as an array")
				}
			}
			// 回调函数
			if _, ok := keyMap[ruleCallback]; ok {
				m.emitCallback = m.first.getValueByKey(ruleCallback) // function
				if !m.emitCallback.IsFunction() {
					m.freeAll()
					return nil, errors.New("ipc.emit event callback function is incorrect, Pass as an function")
				}
			}
			// 触发模式
			if _, ok := keyMap[ruleMode]; ok {
				mode := m.first.getValueByKey(ruleMode) // int 0:async or 1:sync, default 0:async
				if !mode.IsInt() {
					m.freeAll()
					return nil, errors.New("ipc.emit event mode is incorrect, Pass as an integer")
				}
				modeValue := modelRule(mode.GetIntValue())
				mode.Free()
				if modeValue == modelAsync || modeValue == modelWait {
					m.model = modeValue
				} else {
					m.model = modelAsync // default
				}
			} else {
				m.model = modelAsync // default
			}
			// 触发等待时间，触发模式为 modelWait 有效
			if _, ok := keyMap[ruleWaitTime]; ok && m.model == modelWait {
				waitTime := m.first.getValueByKey(ruleWaitTime) // int 0:async or 1:sync, default 0:async
				if !waitTime.IsUInt() {
					m.freeAll()
					return nil, errors.New("ipc.emitWait The timeout waiting time is incorrect, Pass as an uint, unit millisecond")
				}
				// 单位 毫秒
				waitTimeValue := waitTime.GetUIntValue()
				waitTime.Free()
				if waitTimeValue > 0 {
					m.waitTime = time.Duration(waitTimeValue) * time.Millisecond
				}
			}
			// 触发目标
			if _, ok := keyMap[ruleTarget]; ok {
				target := m.first.getValueByKey(ruleTarget) // int 0:main 1:current 2:other
				if !target.IsInt() {
					m.freeAll()
					return nil, errors.New("ipc.emit event target is incorrect, Pass as an integer")
				}
				targetValue := targetRule(target.GetIntValue())
				target.Free()
				if targetValue == targetMain || targetValue == targetCurrent || targetValue == targetOther {
					m.target = targetValue
				} else {
					m.target = targetMain // default
				}
			} else {
				m.target = targetMain // default
			}
			m.rule = exerOption
			return m, nil
		}
	}
	return nil, errors.New("ipc.emit first argument must be the event name or option rule")
}

// JS 执行 GO 监听事件
func (m *ipcRenderProcess) jsExecuteGoEvent(name string, object *ICefV8Value, arguments *TCefV8ValueArray, retVal *ResultV8Value, exception *ResultString) (result bool) {
	result = true
	var args interface{}
	defer func() {
		if args != nil {
			args = nil
		}
	}()
	rule, err := m.jsExecuteGoRule(name, arguments)
	if err == nil {
		defer rule.freeAll()
		v8ctx := V8ContextRef.Current()
		defer v8ctx.Free()
		if rule.emitArgs != nil { //入参
			//V8Value 转换
			args = ValueConvert.V8ValueToProcessMessageArray(rule.emitArgs)
			if args == nil {
				exception.SetValue("ipc.emit convert parameter to value value error")
				return
			}
		}
		var isWait = rule.model == modelWait //等待超时返回结果
		//单进程 不通过进程消息, 全是同步
		if application.SingleProcess() {
			callback := &ipcCallback{}
			if rule.emitCallback != nil { //callback function
				callback.resultType = rt_function
				callback.function = rule.emitCallback
			} else { //variable
				callback.resultType = rt_variable
			}
			m.singleProcess(v8ctx, rule.emitNameValue, callback, args)
			if callback.resultType == rt_variable {
				if callback.variable != nil {
					retVal.SetResult(callback.variable)
				} else {
					retVal.SetResult(V8ValueRef.NewBool(true))
				}
			} else {
				retVal.SetResult(V8ValueRef.NewBool(true))
			}
		} else { //多进程
			// 等待超时 或 当前子进程
			if isWait || rule.target == targetCurrent {
				callback := &ipcCallback{isSync: true}
				// 回调函数或变量方式接收返回值, 优先回调函数
				if rule.emitCallback != nil { //callback function
					callback.resultType = rt_function
					callback.function = rule.emitCallback
				} else { //variable
					callback.resultType = rt_variable
				}
				//当前子进程
				if rule.target == targetCurrent {
					m.multiProcessCurrentProcess(v8ctx, rule.emitNameValue, callback, args)
				} else { //等待 - 主进程
					m.multiProcessWait(v8ctx, rule.emitNameValue, callback, rule.waitTime, args)
				}
				if callback.resultType == rt_variable {
					if callback.variable != nil {
						retVal.SetResult(callback.variable)
					} else {
						retVal.SetResult(V8ValueRef.NewBool(true))
					}
				} else {
					retVal.SetResult(V8ValueRef.NewBool(true))
				}
			} else { // 异步 - 主进程
				var messageId int32 = 0
				if rule.emitCallback != nil {
					rule.emitCallback.SetCanNotFree(true)
					callback := &ipcCallback{resultType: rt_function, function: V8ValueRef.UnWrap(rule.emitCallback)}
					messageId = m.emitHandler.addCallback(callback)
				}
				var message target.IProcessMessage
				if application.IsSpecVer49() {
					// CEF49
					message = v8ctx.Browser()
				} else {
					message = v8ctx.Frame()
				}
				// 在多进程时，发送多进程异步消息，如果当前CEF版本是CEF49使用Browser的发送消息函数
				if success := m.multiProcessAsync(message, messageId, rule.emitNameValue, args); !success {
					//失败，释放回调函数
					rule.emitCallback.SetCanNotFree(false)
				}
				retVal.SetResult(V8ValueRef.NewBool(true))
			}
		}
	} else {
		// emit rule error
		println("js execute go event error:", err.Error())
	}
	return
}

// 多进程消息 -  当前进程
func (m *ipcRenderProcess) multiProcessCurrentProcess(v8ctx *ICefV8Context, emitName string, callback *ipcCallback, data interface{}) {
	// 主进程
	eventCallback := ipc.CheckOnEvent(emitName)
	var ipcContext context.IContext
	if eventCallback != nil {
		ipcContext = context.NewContext(v8ctx.Browser().Identifier(), v8ctx.Frame().Identifier(), true, json.NewJSONArray(data))
		//调用监听函数
		if ctxCallback := eventCallback.ContextCallback(); ctxCallback != nil {
			ctxCallback.Invoke(ipcContext)
		} else if argsCallback := eventCallback.ArgumentCallback(); argsCallback != nil {
			argsCallback.Invoke(ipcContext)
		}
	}
	if ipcContext != nil && callback != nil {
		//处理回复消息
		replay := ipcContext.Replay()
		if replay.Result() != nil && len(replay.Result()) > 0 {
			m.executeCallbackFunction(v8ctx, true, callback, json.NewJSONArray(replay.Result()))
			return
		}
	}
	m.executeCallbackFunction(v8ctx, false, callback, nil)
}

// 单进程
func (m *ipcRenderProcess) singleProcess(v8ctx *ICefV8Context, emitName string, callback *ipcCallback, data interface{}) {
	if ipcBrowser == nil {
		return
	}
	// 当前为主进程
	ipcContext := ipcBrowser.jsExecuteGoMethod(v8ctx.Browser().Identifier(), v8ctx.Frame().Identifier(), emitName, json.NewJSONArray(data))
	if ipcContext != nil && callback != nil {
		// 处理回复消息
		replay := ipcContext.Replay()
		if replay.Result() != nil && len(replay.Result()) > 0 {
			m.executeCallbackFunction(v8ctx, true, callback, json.NewJSONArray(replay.Result()))
			return
		}
	}
	m.executeCallbackFunction(v8ctx, false, callback, nil)
}

// 多进程消息 - 会阻塞渲染进程，并等待 delay 时间后自动返回
func (m *ipcRenderProcess) multiProcessWait(v8ctx *ICefV8Context, emitName string, callback *ipcCallback, delay time.Duration, data interface{}) {
	//延迟等待接收结果，默认5秒
	messageId := m.waitChan.NextMessageId()
	resultChan := make(chan interface{})
	m.waitChan.Pending.Store(messageId, func(result interface{}) {
		select {
		case resultChan <- result:
		}
	})
	// 组装消息
	message := &ipcArgument.List{
		Id:        messageId,
		BId:       ipc.RenderChan().BrowserId(),
		Name:      internalIPCJSExecuteGoWaitEvent,
		EventName: emitName,
		Data:      data,
	}
	//发送数据到主进程
	ipc.RenderChan().IPC().Send(message.Bytes())
	message.Reset()
	// 开始计时, 直到 delay 时间结束，或正常返回结果
	delayer := m.waitChan.NewDelayer(messageId, delay)
	select {
	case resultData := <-resultChan:
		//接收成功，停止
		delayer.Stop()
		delayer = nil
		var argumentList json.JSONArray
		if resultData != nil {
			argumentList = resultData.(json.JSONArray)
		}
		if argumentList != nil {
			m.executeCallbackFunction(v8ctx, true, callback, argumentList)
			argumentList.Free()
		} else {
			m.executeCallbackFunction(v8ctx, false, callback, nil)
		}
	}

}

// 多进程消息 - 异步
func (m *ipcRenderProcess) multiProcessAsync(processMessage target.IProcessMessage, messageId int32, emitName string, data interface{}) bool {
	if processMessage != nil {
		message := &ipcArgument.List{
			Id:        messageId,
			EventName: emitName,
			Data:      data,
		}
		processMessage.SendProcessMessageForJSONBytes(internalIPCJSExecuteGoEvent, consts.PID_BROWSER, message.Bytes())
		message.Reset()
		return true
	}
	return false
}

// JS执行Go监听，Go的消息回复
func (m *ipcRenderProcess) ipcJSExecuteGoEventMessageReply(browser *ICefBrowser, frame *ICefFrame, sourceProcess consts.CefProcessId, message *ICefProcessMessage) (result bool) {
	result = true
	argumentListBytes := message.ArgumentList().GetBinary(0)
	if argumentListBytes == nil {
		return
	}
	var messageDataBytes []byte
	if argumentListBytes.IsValid() {
		size := argumentListBytes.GetSize()
		messageDataBytes = make([]byte, size)
		c := argumentListBytes.GetData(messageDataBytes, 0)
		argumentListBytes.Free()
		if c == 0 {
			return
		}
	}
	var (
		messageId    int32
		isReturnArgs bool
		argumentList ipcArgument.IList // json.JSONArray
	)
	if messageDataBytes != nil {
		argumentList = ipcArgument.UnList(messageDataBytes)
		messageId = argumentList.MessageId()
		isReturnArgs = argumentList.JSON() != nil
		messageDataBytes = nil
	}
	defer func() {
		if argumentList != nil {
			argumentList.Reset()
		}
	}()
	if callback := m.emitHandler.getCallback(messageId); callback != nil {
		var returnArgs json.JSONArray
		defer func() {
			if returnArgs != nil {
				returnArgs.Free()
			}
		}()
		if callback.function != nil {
			//设置允许释放
			callback.function.SetCanNotFree(false)
		}
		if isReturnArgs {
			//[]byte
			returnArgs = argumentList.JSON().JSONArray()
		}
		v8ctx := frame.V8Context()
		if returnArgs != nil {
			m.executeCallbackFunction(v8ctx, isReturnArgs, callback, returnArgs)
		} else {
			m.executeCallbackFunction(v8ctx, isReturnArgs, callback, nil)
		}
		callback.function.Free()
		callback.name.Free()
		v8ctx.Free()
	}
	return
}

// 执行 v8 function 回调函数
func (m *ipcRenderProcess) executeCallbackFunction(v8ctx *ICefV8Context, isReturnArgs bool, callback *ipcCallback, returnArgs json.JSONArray) {
	if isReturnArgs { //有返回参数
		//enter v8context
		if v8ctx.Enter() {
			var argsArray *TCefV8ValueArray
			var err error
			if callback.resultType == rt_function {
				if returnArgs != nil {
					//bytes to v8array value
					argsArray, err = ValueConvert.JSONArrayToV8ArrayValue(returnArgs)
				}
				if argsArray != nil && err == nil {
					// parse v8array success
					callback.function.ExecuteFunctionWithContext(v8ctx, nil, argsArray).Free()
					argsArray.Free()
				} else {
					// parse v8array fail
					callback.function.ExecuteFunctionWithContext(v8ctx, nil, nil).Free()
				}
			} else if callback.resultType == rt_variable {
				if returnArgs != nil && returnArgs.Size() > 0 {
					//bytes to v8array value
					argsArray, err = ValueConvert.JSONArrayToV8ArrayValue(returnArgs)
					if argsArray != nil && err == nil {
						if argsArray.Size() == 1 {
							callback.variable = argsArray.Get(0)
							callback.variable.SetCanNotFree(true)
						} else {
							callback.variable = V8ValueRef.NewArray(int32(argsArray.Size()))
							for i := 0; i < argsArray.Size(); i++ {
								callback.variable.SetValueByIndex(int32(i), argsArray.Get(i))
							}
						}
						argsArray.Free()
					} else {
						callback.variable = V8ValueRef.NewBool(true)
					}
				} else {
					callback.variable = V8ValueRef.NewBool(true)
				}
			}
			//exit v8context
			v8ctx.Exit()
		}
	} else { //无返回参数
		if callback.resultType == rt_function {
			if v8ctx.Enter() {
				callback.function.ExecuteFunctionWithContext(v8ctx, nil, nil).Free()
				v8ctx.Exit()
			}
		} else if callback.resultType == rt_variable {
			// null
		}
	}
}

// Go IPC 渲染进程监听
func (m *ipcRenderProcess) registerGoWaitReplayEvent() {
	if m.isInitRenderIPC {
		return
	}
	m.isInitRenderIPC = true
	ipc.RenderChan().AddCallback(func(channelId int64, argument ipcArgument.IList) bool {
		if argument != nil {
			name := argument.GetName()
			if name == internalIPCJSExecuteGoWaitEventReplay {
				var (
					messageId    = argument.MessageId()
					argumentList json.JSONArray
				)
				if argument.JSON() != nil {
					argumentList = argument.JSON().JSONArray()
				}
				m.ipcJSExecuteGoSyncEventMessageReply(messageId, argumentList)
				return true
			}
		}
		return false
	})

}

// JS执行Go事件 - 同步回复接收
func (m *ipcRenderProcess) ipcJSExecuteGoSyncEventMessageReply(messageId int32, argumentList json.JSONArray) {
	m.waitChan.Done(messageId, argumentList)
}

// ipc
func (m *ipcRenderProcess) makeIPC(frameId int64, context *ICefV8Context) {
	if m.ipcObject != nil {
		// 刷新时释放掉
		m.clear(frameId)
	}
	// ipc emit
	m.emitHandler.handler = V8HandlerRef.New()
	m.emitHandler.handler.Execute(m.jsExecuteGoEvent)

	// ipc emit sync
	m.emitHandler.handlerSync = V8HandlerRef.New()
	m.emitHandler.handlerSync.Execute(m.jsExecuteGoEvent)

	// ipc on
	var on *ipcOnHandler
	if handler, ok := m.onHandler[frameId]; ok {
		on = handler
	} else {
		on = &ipcOnHandler{handler: V8HandlerRef.New(), callbackList: make(map[string]*ipcCallback)}
		on.handler.Execute(on.jsOnEvent)
		m.onHandler[frameId] = on
	}

	//m.onHandler.handler = V8HandlerRef.New()
	//m.onHandler.handler.Execute(m.jsOnEvent)
	//on.handler = V8HandlerRef.New()

	// ipc object
	m.ipcObject = V8ValueRef.NewObject(nil)
	m.ipcObject.setValueByKey(internalIPCEmit, V8ValueRef.newFunction(internalIPCEmit, m.emitHandler.handler), consts.V8_PROPERTY_ATTRIBUTE_READONLY)
	m.ipcObject.setValueByKey(internalIPCEmitWait, V8ValueRef.newFunction(internalIPCEmitWait, m.emitHandler.handlerSync), consts.V8_PROPERTY_ATTRIBUTE_READONLY)
	m.ipcObject.setValueByKey(internalIPCOn, V8ValueRef.newFunction(internalIPCOn, on.handler), consts.V8_PROPERTY_ATTRIBUTE_READONLY)

	// ipc key to v8 global
	context.Global().setValueByKey(internalIPC, m.ipcObject, consts.V8_PROPERTY_ATTRIBUTE_READONLY)
}