protected unsafe override void OnContextReleased(CefBrowser browser, CefFrame frame, CefV8Context context)
{
if (_context.MainFrame != null)
{
_context.MainFrame.UnbindV8Context();
}
}
public CefUncaughtExceptionEventArgs(CefBrowser browser, CefFrame frame, CefV8Context context, CefV8Exception exception, CefV8StackTrace stackTrace)
{
this.browser = browser;
this.frame = frame;
this.context = context;
this.exception = exception;
this.stackTrace = stackTrace;
}
public void BindCurrentV8Context()
{
if (this.v8Context != null) throw new InvalidOperationException();
var context = CefV8Context.GetCurrentContext();
if (context == null) throw new InvalidOperationException();
this.v8Context = context;
}
public void BindContext(CefV8Context v8Context)
{
if (this.v8Context != null)
throw new InvalidOperationException();
if (v8Context == null)
throw new ArgumentNullException("v8Context");
this.v8Context = v8Context;
}
protected unsafe override void OnContextCreated(CefBrowser browser, CefFrame frame, CefV8Context context)
{
if (frame.IsMain)
{
_context.MainFrame.BindContext(context);
}
var obj = context.GetGlobal();
Cef.JSBindingContext.BindObjects(obj);
_context.JSBindingContext.BindObjects(obj);
obj.Dispose();
}
public void printToPDF(string path, CefPdfPrintSettings settings, CefPdfPrintCallback callback)
{
var _context = CefV8Context.GetCurrentContext();
if (_context != null)
{
var _browser = _context.GetBrowser();
if (_browser != null)
{
var _host = _browser.GetHost();
if (_host != null)
{
_host.PrintToPdf(path, settings, callback);
}
}
}
}
internal static void OnContextReleased(CefV8Context context)
{
List <XrayObject> values;
lock (XrayRoots)
{
XrayRoots.Remove(context, out values);
}
if (values == null)
{
return;
}
foreach (XrayObject obj in values)
{
obj.Dispose();
}
}
/// <summary>
/// Remove a JavaScript listener function from a native event.
/// </summary>
/// <param name="context">The current V8 JavaScript context.</param>
/// <param name="eventName">The name of the event to detach the function from.</param>
/// <param name="callback"> The function to detach from the event.</param>
public void RemoveEventListener(CefV8Context context, string eventName, CefV8Value callback)
{
if (string.IsNullOrEmpty(eventName) || !Descriptor.Events.Contains(eventName))
{
throw new Exception("Unknown event name");
}
if (callback == null)
{
throw new Exception("Missing event listener");
}
var v8Callback = _retainedCallbacks.GetAndRemoveCallback(eventName, callback);
// Execute the call through the router, so that the router keeps track of the call
OnRemoveEventListener(context, eventName, v8Callback);
}
internal static CefV8Value CastDotnetTypeToCefV8Value(CefV8Context context, object value, out bool isNew)
{
isNew = true;
if (value is null)
{
return(CefV8Value.CreateNull());
}
if (value is V8Undefined)
{
return(CefV8Value.CreateUndefined());
}
switch (value)
{
case string v:
return(new CefV8Value(v));
case int v:
return(new CefV8Value(v));
case double v:
return(new CefV8Value(v));
case bool v:
return(new CefV8Value(v));
case DateTime v:
return(new CefV8Value(v));
case XrayHandle v:
isNew = (v.dataType != XrayDataType.Object && v.dataType != XrayDataType.Function);
return(v.ToCefV8Value(context.Frame));
case ScriptableObject v:
XrayHandle hv = (XrayHandle)v;
isNew = (hv.dataType != XrayDataType.Object && hv.dataType != XrayDataType.Function);
CefV8Value cv8 = hv.ToCefV8Value(context.Frame);
GC.KeepAlive(v);
return(cv8);
}
throw new NotImplementedException("Type: " + value.GetType().Name);
}
protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
string paramSampler = arguments[0].GetStringValue();
switch (name)
{
//获取异常信息
case "GetHitchs":
//异常信息
string machineCode = string.Empty;
if (paramSampler == "#1")
{
machineCode = GlobalVars.MachineCode_QZDZYJ_1;
}
else if (paramSampler == "#2")
{
machineCode = GlobalVars.MachineCode_QZDZYJ_2;
}
equInfHitchs = CommonDAO.GetInstance().GetEquInfHitchsByTime(machineCode, DateTime.Now);
returnValue = CefV8Value.CreateString(Newtonsoft.Json.JsonConvert.SerializeObject(equInfHitchs.Select(a => new { MachineCode = a.MachineCode, HitchTime = a.HitchTime.ToString("yyyy-MM-dd HH:mm"), HitchDescribe = a.HitchDescribe })));
break;
case "OpenAutoMaker":
CefProcessMessage OpenAutoMaker = CefProcessMessage.Create("OpenAutoMaker");
int f = 0;
foreach (CefV8Value item in arguments)
{
CefValue model = CefValue.Create();
model.SetString(item.GetStringValue());
OpenAutoMaker.Arguments.SetValue(f, model);
f++;
}
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, OpenAutoMaker);
break;
default:
returnValue = null;
break;
}
return(true);
}
/// <summary>
/// create js func from userJsCode, userJsCode will be wraped with anonymous func before it is send to js
/// </summary>
/// <param name="ownerContext"></param>
/// <param name="userJsCode"></param>
/// <returns></returns>
public static MyJsFunc Create(CefV8Context ownerContext, string userJsCode)
{
IntPtr v8JsFuncPtr;
if (CreateFromJsCode(ownerContext,
"(function(){ return " + userJsCode + "})()",
out v8JsFuncPtr))
{
MyJsFunc func = new MyJsFunc();
func._cefV8Func = new CefV8Value(v8JsFuncPtr);
return(func);
}
else
{
//not success
return(null);
}
}
public double getZoomLevel()
{
var _context = CefV8Context.GetCurrentContext();
if (_context != null)
{
var _browser = _context.GetBrowser();
if (_browser != null)
{
var _host = _browser.GetHost();
if (_host != null)
{
_host.GetZoomLevel();
}
}
}
return(0);
}
/// <summary>
/// Called by <see cref="OnBrowserCallbackInvokeReceived(PluginMessage,ResultData)"/>
/// to invoke a V8 callback.
/// </summary>
/// <param name="context"></param>
/// <param name="info"></param>
/// <param name="result"></param>
private void InvokeV8Callback(CefV8Context context, RenderCallInfo info, ResultData result)
{
try
{
if (context != null && info.Callback != null)
{
info.Callback.Invoke(this, context, result, result.ErrorCode, result.Error);
}
if (!info.IsRetained)
{
info.Dispose();
}
}
catch (Exception exception)
{
Logger.Error("InvokeV8Callback Failed: {0}", exception);
}
}
private PluginMessage CreateMessage(
CefV8Context context,
PluginDescriptor targetPlugin,
string memberName,
IV8Callback callback)
{
var message = new PluginMessage
{
PluginId = targetPlugin.PluginId,
MemberName = memberName,
BrowserId = context.GetBrowserId(),
ContextId = GetIdForContext(context, false),
FrameId = context.GetFrame().Identifier,
V8CallbackId = callback != null ? callback.Identifier : Guid.Empty
};
return(message);
}
private Reko.Decompiler CreateRekoInstance(CefV8Context context)
{
var fsSvc = new FileSystemServiceImpl();
var listener = new ListenerService(context, eventListeners);
var dfSvc = new DecompiledFileService(fsSvc, listener);
services.AddService(typeof(IFileSystemService), fsSvc);
services.AddService(typeof(DecompilerEventListener), listener);
var configSvc = RekoConfigurationService.Load(services, "reko/reko.config");
services.AddService(typeof(IConfigurationService), configSvc);
services.AddService(typeof(IDecompiledFileService), dfSvc);
services.AddService(typeof(ITypeLibraryLoaderService), new TypeLibraryLoaderServiceImpl(services));
services.AddService(typeof(IPluginLoaderService), new PluginLoaderService());
var loader = new Reko.Loading.Loader(services);
return(new Reko.Decompiler(loader, services));
}
protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
string param = arguments.Length > 0 ? arguments[0].GetStringValue() : string.Empty;
CefProcessMessage cefMsg = null;
switch (name)
{
// 打开火车机械采样机监控界面
case "OpenTrainMachinerySampler":
//CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, CefProcessMessage.Create("OpenTrainMachinerySampler"));
break;
// 打开汽车入厂重车衡监控
case "OpenTruckWeighter":
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, CefProcessMessage.Create("OpenTruckWeighter"));
break;
// 打开汽车机械采样机监控
case "OpenTruckMachinerySampler":
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, CefProcessMessage.Create("OpenTruckMachinerySampler"));
break;
// 打开化验室监控
case "OpenAssayManage":
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, CefProcessMessage.Create("OpenAssayManage"));
break;
// 打开实时视频预览
case "OpenHikVideo":
cefMsg = CefProcessMessage.Create("OpenHikVideo");
cefMsg.Arguments.SetSize(1);
cefMsg.Arguments.SetString(0, param);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, cefMsg);
break;
default:
returnValue = null;
break;
}
return(true);
}
public void launchappindifferentoem(
string oem,
string abiValue,
string vmname,
string packageName,
string actionWithRemainingInstances)
{
Logger.Info("Get Call from browser of launchappindifferentoem oem: " + oem + ", abiValue: " + abiValue + ", packageName: " + packageName + ", actionWithRemainingInstances: " + actionWithRemainingInstances);
using (CefProcessMessage message = CefProcessMessage.Create("LaunchAppInDifferentOem"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, oem);
arguments.SetString(1, abiValue);
arguments.SetString(2, vmname);
arguments.SetString(3, packageName);
arguments.SetString(4, actionWithRemainingInstances);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public void Then(CefV8Value promise, CefV8Context context, Action <PromiseResult> continuation)
{
var id = pendingPromises.Save(context.GetFrame().Identifier, new PendingPromise
{
Continuation = continuation
});
using (new ContextHelper(context))
using (var global = context.GetGlobal())
using (var s = global.GetValue(HelperObjectName))
{
var userData = s.GetUserData() as PromiseUserData;
var waitForPromise = userData.WaitForPromise;
using (var idValue = CefV8Value.CreateString(id.ToString()))
{
waitForPromise.ExecuteFunctionWithContext(context, null, new[] { promise, idValue }).Dispose();
}
}
}
/// <summary>
/// Returns the number of queries currently pending for the specified |browser|
/// and/or |context|. Either or both values may be empty.
/// </summary>
public int GetPendingCount(CefBrowser browser = null, CefV8Context context = null)
{
Helpers.RequireRendererThread();
if (_browserRequestInfoMap.IsEmpty) return 0;
if (context != null)
{
var contextId = GetIDForContext(context, false);
if (contextId == CefMessageRouter.ReservedId)
return 0; // Nothing associated with the specified context.
int count = 0;
BrowserRequestInfoMap.Visitor visitor = (int browserId, KeyValuePair<int, int> infoId, RequestInfo info, ref bool remove) =>
{
if (infoId.Key == contextId) count++;
return true;
};
if (browser != null)
{
// Count requests associated with the specified browser.
_browserRequestInfoMap.FindAll(browser.Identifier, visitor);
}
else
{
// Count all requests for all browsers.
_browserRequestInfoMap.FindAll(visitor);
}
return count;
}
else if (browser != null)
{
return _browserRequestInfoMap.Count(browser.Identifier);
}
else
{
return _browserRequestInfoMap.Count();
}
return 0;
}
/// <summary>
/// Run in context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action.</param>
/// <exception cref="System.ArgumentNullException">
/// context
/// or
/// action
/// </exception>
public static void RunInContext(CefV8Context context, Action action)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (action == null)
{
throw new ArgumentNullException("action");
}
CefUtility.RunInContext <object>(context, () =>
{
action();
return(null);
});
}
public void installapp_google_popup(
string appIcon,
string appName,
string apkUrl,
string packageName,
string source = "")
{
Logger.Info("Get Call from browser of Install App from googleplay in popup :" + appName);
using (CefProcessMessage message = CefProcessMessage.Create("InstallAppGooglePlayPopup"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, appIcon);
arguments.SetString(1, appName);
arguments.SetString(2, apkUrl);
arguments.SetString(3, packageName);
arguments.SetString(4, source);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
/// <summary>
/// Call from CefRenderProcessHandler::OnContextCreated. Registers the
/// JavaScripts functions with the new context.
/// </summary>
public void OnContextCreated(CefBrowser browser, CefFrame frame, CefV8Context context)
{
Helpers.RequireRendererThread();
// Register function handlers with the 'window' object.
var window = context.GetGlobal();
var handler = new V8HandlerImpl(this, _config);
CefV8PropertyAttribute attributes = CefV8PropertyAttribute.ReadOnly | CefV8PropertyAttribute.DontEnum | CefV8PropertyAttribute.DontDelete;
// Add the query function.
var queryFunc = CefV8Value.CreateFunction(_config.JSQueryFunction, handler);
window.SetValue(_config.JSQueryFunction, queryFunc, attributes);
// Add the cancel function.
var cancelFunc = CefV8Value.CreateFunction(_config.JSCancelFunction, handler);
window.SetValue(_config.JSCancelFunction, cancelFunc, attributes);
}
private CefV8Value DontMeetRequirements(CefV8Context context, CefV8Value callback)
{
var msg = JsonMapper.ToJson(new StatusHelper("Error", "Arguments do not meet function requirement"));
if (callback != null)
{
var runner = CefTaskRunner.GetForCurrentThread();
new Task(() =>
{
context.Enter();
runner.PostTask(new CallbackTask(context, callback, msg));
context.Exit();
}).Start();
return(CefV8Value.CreateNull());
}
else
{
return(CefV8Value.CreateString(msg));
}
}
public void ContextCreated(CefBrowser browser, CefFrame frame, CefV8Context context)
{
Logger.Info("ContextCreated Browser {0} Frame {1}", browser.Identifier, frame.Identifier);
if (!EnsureOnRendererThread())
{
return;
}
try
{
CreateIdForContext(context);
InitializeContext(browser, frame, context);
}
catch (Exception exception)
{
Logger.Info("ContextCreated Failed Browser {0} Frame {1}: {2}", browser.Identifier, frame.Identifier, exception);
}
}
protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
switch (name)
{
// 道闸1升杆
case "Gate1Up":
commonDAO.SendAppRemoteControlCmd(MonitorCommon.GetInstance().GetTruckWeighterMachineCodeBySelected(arguments[0].GetStringValue()), "控制道闸", "Gate1Up");
break;
// 道闸1降杆
case "Gate1Down":
commonDAO.SendAppRemoteControlCmd(MonitorCommon.GetInstance().GetTruckWeighterMachineCodeBySelected(arguments[0].GetStringValue()), "控制道闸", "Gate1Down");
break;
// 道闸2升杆
case "Gate2Up":
commonDAO.SendAppRemoteControlCmd(MonitorCommon.GetInstance().GetTruckWeighterMachineCodeBySelected(arguments[0].GetStringValue()), "控制道闸", "Gate2Up");
break;
// 道闸2降杆
case "Gate2Down":
commonDAO.SendAppRemoteControlCmd(MonitorCommon.GetInstance().GetTruckWeighterMachineCodeBySelected(arguments[0].GetStringValue()), "控制道闸", "Gate2Down");
break;
case "ChangeSelected":
CefProcessMessage cefMsg = CefProcessMessage.Create("TruckWeighterChangeSelected");
cefMsg.Arguments.SetSize(0);
cefMsg.Arguments.SetString(0, arguments[0].GetStringValue());
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, cefMsg);
break;
default:
returnValue = null;
break;
}
return(true);
}
internal static CefV8Value InvokeMember(CefV8Context context, XrayObject target, CefListValue args)
{
CefV8Value thisArg = GetSafeThisArg(context, target);
CefV8Value func = thisArg.GetValue(args.GetString(3));
if (!func.IsFunction)
{
func.Dispose();
throw new MissingMethodException();
}
int size = (int)(args.GetSize() - 4);
var xraylist = new List <int>(size);
var fnArgs = new CefV8Value[size];
try
{
for (int i = 0; i < fnArgs.Length; i++)
{
int index = (i + 4);
fnArgs[i] = CastCefValueToCefV8Value(context, args.GetValue(index), out bool isNew);
if (!isNew)
{
xraylist.Add(index);
}
}
return(func.ExecuteFunction(thisArg, fnArgs));
}
finally
{
func.Dispose();
for (int i = 0; i < fnArgs.Length; i++)
{
if (!xraylist.Contains(i))
{
fnArgs[i].Dispose();
}
}
}
}
public string installapp(
string appIcon,
string appName,
string apkUrl,
string packageName,
string timestamp = "",
string source = "")
{
Logger.Info("Get Call from browser of Install App :" + appName);
using (CefProcessMessage message = CefProcessMessage.Create("InstallApp"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, appIcon);
arguments.SetString(1, appName);
arguments.SetString(2, apkUrl);
arguments.SetString(3, packageName);
arguments.SetString(4, timestamp);
arguments.SetString(5, source);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
return("true");
}
}
private Guid?AddCallback(CefV8Value callbackFunction, CefV8Context context)
{
if (callbackFunction != null)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (!callbackFunction.IsFunction)
{
throw new ArgumentException("Not a function.", "callbackFunction");
}
var callback = new JavascriptFunction(callbackFunction, context);
Callbacks.Add(callback.Id, callback);
return(callback.Id);
}
return(null);
}
/// <summary>
/// Add a local V8 callback to a local event as a listener.
/// </summary>
/// <param name="context">
/// The current V8 context that is adding the listener.
/// </param>
/// <param name="targetPlugin">
/// The local plugin that owns the event.
/// </param>
/// <param name="eventName">
/// The name of the event to attach to.
/// </param>
/// <param name="callback">
/// The callback to V8 to invoke when the event is raised.
/// </param>
public void AddEventListener(CefV8Context context, JavaScriptPlugin targetPlugin, string eventName, IV8Callback callback)
{
Logger.Info("AddEventListener Local Plugin {0} Event {1}", targetPlugin.Descriptor.PluginId, eventName);
if (!EnsureOnRendererThread())
{
return;
}
if (!targetPlugin.IsValid)
{
Logger.Warn("AddEventListener Local Plugin {0} is invalid", targetPlugin.Descriptor.PluginId);
if (callback != null)
{
callback.Invoke(this, context, null, CallInfo.ErrorCodeCallCanceled, CallInfo.ErrorCallCanceled);
}
return;
}
var addListenerMessage = CreateMessage(context, targetPlugin.Descriptor, eventName, callback);
addListenerMessage.MessageId = callback.Identifier;
addListenerMessage.MessageType = PluginMessageType.AddListener;
// Add the call info into the pending calls for the browser
var info = AddLocalCallback(addListenerMessage, callback, null);
try
{
targetPlugin.AddEventListener(eventName, info);
}
catch (Exception ex)
{
// Remove listener from calls cache
_pendingCallbacks.Remove(info);
info.Dispose();
Logger.Error("AddEventListener Failed Local Plugin {0} Event {1}: {2}", targetPlugin.Descriptor.PluginId, eventName, ex);
}
}
public bool Execute(string name, ICefV8Value obj, ICefV8Value[] arguments, out ICefV8Value returnValue,
out string exception)
{
returnValue = null;
exception = null;
long frameId = 0;
using (var context = CefV8Context.GetCurrentContext())
{
frameId = context.GetFrame().Identifier;
}
var executionId = functionCallRegistry.Save(frameId, out var promise);
returnValue = promise.Object;
var message = new RpcResponse <ICefValue>
{
MethodExecution = new MethodExecution <ICefValue>
{
ExecutionId = executionId,
MethodId = descriptor.Id,
ObjectId = objectId,
Parameters = arguments.Select(a => v8Serializer.Serialize(a)).ToArray()
}
};
using (var context = CefV8Context.GetCurrentContext())
{
var msg = CefProcessMessage.Create(Messages.RpcResponseMessage);
var serialized = v8Serializer.Serialize(message);
msg.Arguments.SetValue(0, serialized.Copy());
context.GetBrowser().SendProcessMessage(CefProcessId.Browser, msg);
}
return(true);
}
public CefV8Value OnBindingRequire(CefV8Value cefV8Value)
{
using (var context = CefV8Context.GetCurrentContext())
using (var frame = context.GetFrame())
{
var frameId = frame.Identifier;
var frameObjectCache = objectCache[frameId];
var id = dynamicObjectPromiseRegistry.Save(frameId, out var promise);
var objectName = cefV8Value.GetStringValue();
if (!frameObjectCache.TryGetValue(objectName, out var cached))
{
if (objectDescriptorCache.TryGetValue(objectName, out var descriptor))
{
CreateV8Value(descriptor, dynamicObjectPromiseRegistry.Get(id));
}
else
{
var response = new RpcResponse <CefValue>
{
DynamicObjectRequest = new DynamicObjectRequest
{
ExecutionId = id,
Name = objectName
}
};
SendResponse(response);
}
}
else
{
dynamicObjectPromiseRegistry.Get(id).Resolve(cached);
}
return(promise.Object);
}
}
public string isBTVInstalled()
{
if (!BTVManager.IsBTVInstalled())
{
using (CefProcessMessage message = CefProcessMessage.Create("DownloadBTV"))
{
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
return("false");
}
}
else
{
if (BTVManager.IsDirectXComponentsInstalled())
{
return("true");
}
using (CefProcessMessage message = CefProcessMessage.Create("DownloadDirectX"))
{
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
return("false");
}
}
}
/// <summary>
/// create
/// </summary>
/// <param name="userJsCode"></param>
/// <returns></returns>
protected static bool CreateFromJsCode(CefV8Context ownerContext,
string userJsCode,
out IntPtr nativeFunc)
{
IntPtr ret = IntPtr.Zero;
IntPtr exception = IntPtr.Zero;
//eval in js side
if (ownerContext.Eval(userJsCode, "", 1, ref ret, ref exception))
{
nativeFunc = ret;
return(true);
}
else
{
//dispose
nativeFunc = IntPtr.Zero;
CefV8Exception v8Exception = new CefV8Exception(exception);
v8Exception.Dispose();
return(false);
}
}
public ChromeDevToolsProtocol(CefBrowser browser, CefFrame frame, CefV8Context context)
{
try
{
configuration = Extension.GetConfiguration();
var _req = (HttpWebRequest)WebRequest.Create("http://127.0.0.1:" + configuration.RemoteDebuggingPort + "/json/protocol");
var _rsp = (HttpWebResponse)_req.GetResponse();
if (_rsp.StatusCode == HttpStatusCode.OK)
{
var jsProtocolJson = new StreamReader(_rsp.GetResponseStream()).ReadToEnd();
if (!string.IsNullOrEmpty(jsProtocolJson))
{
protocol = JsonMapper.ToObject(jsProtocolJson);
_req = (HttpWebRequest)WebRequest.Create("http://127.0.0.1:" + configuration.RemoteDebuggingPort + "/json");
_rsp = (HttpWebResponse)_req.GetResponse();
if (_rsp.StatusCode == HttpStatusCode.OK)
{
var jsJson = new StreamReader(_rsp.GetResponseStream()).ReadToEnd();
if (!string.IsNullOrEmpty(jsJson))
{
var settings = JsonMapper.ToObject(jsJson);
this.DevToolsSockets = new ObservableCollection <DevToolsSocket>();
foreach (JsonData setting in settings)
{
if (frame.Url == (string)setting["url"])// && frame.Url != "chrome-devtools://devtools/inspector.html"
{
this.DevToolsSockets.Add(new DevToolsSocket(frame.Url, (string)setting["webSocketDebuggerUrl"], this.DevToolsSockets));
}
}
}
}
}
}
}
catch (Exception ex) { Log.Trace(ex.Message, ex.StackTrace, true); }
}
/// <summary>
/// Handle execution of the function identified by |name|. |object| is the
/// receiver ('this' object) of the function. |arguments| is the list of
/// arguments passed to the function. If execution succeeds set |retval| to the
/// function return value. If execution fails set |exception| to the exception
/// that will be thrown. Return true if execution was handled.
/// </summary>
/// <param name="name">The name of the function to execute.</param>
/// <param name="obj">The receiver ('this' object) of the function.</param>
/// <param name="arguments">The list of arguments passed to the function</param>
/// <param name="returnValue">If execution succeeds set |retval| to the function return value.</param>
/// <param name="exception">If execution fails set |exception| to the exception that will be thrown.</param>
/// <returns>Return true if execution was handled.</returns>
protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
try
{
if (!string.IsNullOrEmpty(name))
{
var methodDescriptor = _plugin.Descriptor.Methods.Find(descriptor => descriptor.MethodName == name);
if (methodDescriptor == null)
{
Logger.Error("Plugin method {0} {1} not found", _plugin.Descriptor.PluginId, name);
return(false);
}
var context = CefV8Context.GetCurrentContext();
var v8Callback = arguments != null && arguments.Length != 0 && arguments[arguments.Length - 1].IsFunction
? arguments[arguments.Length - 1]
: null;
var parameters = v8Callback != null?arguments.Take(arguments.Length - 1).ToArray() : arguments;
_plugin.ExecuteFunction(context, name, parameters, v8Callback, out returnValue, out exception);
return(true);
}
}
catch (Exception ex)
{
Logger.Error("Execution of plugin method {0} {1} failed: {2}", _plugin.Descriptor.PluginId, name, ex);
exception = ex.Message;
}
returnValue = CefV8Value.CreateUndefined();
return(false);
}
/// <summary>
/// Add a local V8 callback to a remote event as a listener.
/// </summary>
/// <param name="context">
/// The current V8 context that is adding the listener.
/// </param>
/// <param name="targetPlugin">
/// The remote plugin that owns the event.
/// </param>
/// <param name="eventName">
/// The name of the event to attach to.
/// </param>
/// <param name="callback">
/// The callback to V8 to invoke when the remote event is raised.
/// </param>
public void AddEventListener(CefV8Context context, PluginDescriptor targetPlugin, string eventName, IV8Callback callback)
{
Logger.Info("AddEventListener Remote Plugin {0} Event {1}", targetPlugin.PluginId, eventName);
if (!EnsureOnRendererThread())
{
return;
}
var addListenerMessage = CreateMessage(context, targetPlugin, eventName, callback);
// Use identifier from callback as ID for listener message.
// When remote event fired, renderer will receive an EventFired message with this same ID as its MessageId.
addListenerMessage.MessageId = callback.Identifier;
addListenerMessage.MessageType = PluginMessageType.AddListener;
addListenerMessage.Data = string.Empty;
// Add the call info into the pending calls for the browser
var info = AddRemoteCallback(addListenerMessage, callback);
// Send the request message to the browser
try
{
using (var browser = context.GetBrowser())
{
SendMessage(browser, addListenerMessage);
}
}
catch (Exception ex)
{
// If the request could not be sent, remove the call from the list
_pendingCallbacks.Remove(info);
info.Dispose();
Logger.Error("AddEventListener Failed Remote Plugin {0} Event {1}: {2}", targetPlugin.PluginId, eventName, ex);
}
}
public void UnbindV8Context()
{
if (this.v8Context != null)
{
this.v8Context.Dispose();
this.v8Context = null;
}
}
internal void OnUncaughtException(CefBrowser browser, CefFrame frame, CefV8Context context, CefV8Exception exception, CefV8StackTrace stackTrace)
{
var handler = this.UncaughtException;
if (handler != null)
{
handler(this, new CefUncaughtExceptionEventArgs(browser, frame, context, exception, stackTrace));
}
}
/// <summary>
/// Call from CefRenderProcessHandler::OnContextCreated. Registers the
/// JavaScripts functions with the new context.
/// </summary>
public void OnContextCreated(CefBrowser browser, CefFrame frame, CefV8Context context)
{
Helpers.RequireRendererThread();
// Register function handlers with the 'window' object.
var window = context.GetGlobal();
var handler = new V8HandlerImpl(this, _config);
CefV8PropertyAttribute attributes = CefV8PropertyAttribute.ReadOnly | CefV8PropertyAttribute.DontEnum | CefV8PropertyAttribute.DontDelete;
// Add the query function.
var queryFunc = CefV8Value.CreateFunction(_config.JSQueryFunction, handler);
window.SetValue(_config.JSQueryFunction, queryFunc, attributes);
// Add the cancel function.
var cancelFunc = CefV8Value.CreateFunction(_config.JSCancelFunction, handler);
window.SetValue(_config.JSCancelFunction, cancelFunc, attributes);
}
// Don't create the context ID until it's actually needed.
private int GetIDForContext(CefV8Context context)
{
if (_contextId == CefMessageRouter.ReservedId)
_contextId = _router.CreateIDForContext(context);
return _contextId;
}
// Retrieves the existing ID value associated with the specified |context|.
// If |remove| is true the context will also be removed from the map.
private int GetIDForContext(CefV8Context context, bool remove)
{
Helpers.RequireRendererThread();
int contextId = CefMessageRouter.ReservedId;
int? removeContextId = null;
foreach (var kv in _contextMap)
{
if (kv.Value.IsSame(context))
{
contextId = kv.Key;
if (remove)
{
removeContextId = contextId;
}
break;
}
}
if (removeContextId.HasValue) _contextMap.Remove(removeContextId.Value);
return contextId;
}
/// <summary>
/// Call from CefRenderProcessHandler::OnContextReleased. Any pending queries
/// associated with the released context will be canceled and
/// Handler::OnQueryCanceled will be called in the browser process.
/// </summary>
public void OnContextReleased(CefBrowser browser, CefFrame frame, CefV8Context context)
{
Helpers.RequireRendererThread();
// Get the context ID and remove the context from the map.
var contextId = GetIDForContext(context, true);
if (contextId != CefMessageRouter.ReservedId)
{
// Cancel all pending requests for the context.
SendCancel(browser, frame.Identifier, contextId, CefMessageRouter.ReservedId);
}
}
protected override void OnUncaughtException(CefBrowser browser, CefFrame frame, CefV8Context context, CefV8Exception exception, CefV8StackTrace stackTrace)
{
_context.OnUncaughtException(browser, frame, context, exception, stackTrace);
}
private int CreateIDForContext(CefV8Context context)
{
Helpers.RequireRendererThread();
// The context should not already have an associated ID.
Debug.Assert(GetIDForContext(context, false) == CefMessageRouter.ReservedId);
var contextId = _contextIdGenerator.GetNextId();
_contextMap.Add(contextId, context);
return contextId;
}
private static object InvokeScript(CefV8Context context, string memberName, params object[] args)
{
if (context == null) throw new ArgumentNullException("context");
if (!context.Enter()) throw new CefException("Failed to enter V8 context.");
try
{
// TODO: this list can be private list of context, 'cause we can invoke only one function at one time
List<CefV8Value> proxies = new List<CefV8Value>(16);
// javascript 'this' object
CefV8Value obj = null;
CefV8Value target = context.GetGlobal();
proxies.Add(target);
if (!memberName.Contains('.'))
{
obj = target;
target = obj.GetValue(memberName);
proxies.Add(target);
}
else
{
foreach (var member in memberName.Split('.'))
{
obj = target;
target = obj.GetValue(member); // TODO: do analysis of target - if it is not an object - throw
if (!target.IsObject) throw new CefException("Argument 'memberName' must be member access expression to a function. Invalid object in path.");
proxies.Add(target);
}
}
if (!target.IsFunction) throw new ArgumentException("Argument 'memberName' must be member access expression to a function.");
CefV8Value[] v8Args;
if (args.Length == 0) v8Args = null;
else
{
v8Args = new CefV8Value[args.Length]; // TODO: InvokeScript core can be optimized by prevent recreating arrays
for (var i = 0; i < args.Length; i++)
{
var value = CefConvert.ToV8Value(args[i]);
v8Args[i] = value;
}
}
var v8RetVal = target.ExecuteFunctionWithContext(context, obj, v8Args);
// force destroing of proxies, to avoid unneccessary GC load (CLR and V8)
foreach (var proxy in proxies)
proxy.Dispose();
proxies.Clear();
// FIXME: not sure if exception CAN be null, this need to be checked
if (v8RetVal.HasException)
{
var exception = v8RetVal.GetException();
throw new JavaScriptException(exception.GetMessage());
}
//if (!string.IsNullOrEmpty(exception))
var result = CefConvert.ToObject(v8RetVal);
v8RetVal.Dispose();
return result;
}
finally
{
if (!context.Exit()) throw new CefException("Failed to exit V8 context.");
}
}
