// Copyright © 2019 The CefSharp Authors. All rights reserved.
|
//
|
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
|
|
using System;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace CefSharp.Internals
|
{
|
/// <summary>
|
/// ConcurrentMethodRunnerQueue - Async Javascript Binding methods are run
|
/// on the ThreadPool in parallel, when a method returns a Task
|
/// the we use ContinueWith to be notified of completion then
|
/// raise the MethodInvocationComplete event
|
/// </summary>
|
public sealed class ConcurrentMethodRunnerQueue : IMethodRunnerQueue
|
{
|
private static readonly Type VoidTaskResultType = Type.GetType("System.Threading.Tasks.VoidTaskResult");
|
private readonly IJavascriptObjectRepositoryInternal repository;
|
private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
|
|
/// <inheritdoc/>
|
public event EventHandler<MethodInvocationCompleteArgs> MethodInvocationComplete;
|
|
/// <summary>
|
/// Default constructor
|
/// </summary>
|
/// <param name="repository">javascript object repository</param>
|
public ConcurrentMethodRunnerQueue(IJavascriptObjectRepositoryInternal repository)
|
{
|
this.repository = repository;
|
}
|
|
/// <inheritdoc/>
|
public void Dispose()
|
{
|
MethodInvocationComplete = null;
|
cancellationTokenSource.Cancel();
|
}
|
|
/// <inheritdoc/>
|
public void Enqueue(MethodInvocation methodInvocation)
|
{
|
if (cancellationTokenSource.IsCancellationRequested)
|
{
|
return;
|
}
|
|
//Enqueue on ThreadPool
|
Task.Run(async () =>
|
{
|
if (cancellationTokenSource.IsCancellationRequested)
|
{
|
return;
|
}
|
|
var result = await ExecuteMethodInvocation(methodInvocation).ConfigureAwait(false);
|
|
if (cancellationTokenSource.IsCancellationRequested)
|
{
|
return;
|
}
|
|
//If the call failed or returned null then we'll fire the event immediately
|
if (!result.Success || result.Result == null)
|
{
|
OnMethodInvocationComplete(result, cancellationTokenSource.Token);
|
}
|
else
|
{
|
var resultType = result.Result.GetType();
|
|
//If the returned type is Task then we'll ContinueWith and perform the processing then.
|
if (typeof(Task).IsAssignableFrom(resultType))
|
{
|
var resultTask = (Task)result.Result;
|
|
if (resultType.IsGenericType)
|
{
|
//Discard the continuation as we rely on
|
//OnMethodInvocationComplete to send the response
|
//to the render process.
|
_ = resultTask.ContinueWith((t) =>
|
{
|
if (t.Status == TaskStatus.RanToCompletion)
|
{
|
//We use some reflection to get the Result
|
//If someone has a better way of doing this then please submit a PR
|
result.Result = resultType.GetProperty("Result").GetValue(resultTask);
|
|
if (result.Result != null && result.Result.GetType() == VoidTaskResultType)
|
{
|
result.Result = null;
|
}
|
}
|
else
|
{
|
result.Success = false;
|
result.Result = null;
|
var aggregateException = t.Exception;
|
//TODO: Add support for passing a more complex message
|
// to better represent the Exception
|
if (aggregateException.InnerExceptions.Count == 1)
|
{
|
result.Message = aggregateException.InnerExceptions[0].ToString();
|
}
|
else
|
{
|
result.Message = t.Exception.ToString();
|
}
|
}
|
|
OnMethodInvocationComplete(result, cancellationTokenSource.Token);
|
},
|
cancellationTokenSource.Token, TaskContinuationOptions.None, TaskScheduler.Default);
|
}
|
else
|
{
|
//If it's not a generic Task then it doesn't have a return object
|
//So we'll just set the result to null and continue on
|
result.Result = null;
|
|
OnMethodInvocationComplete(result, cancellationTokenSource.Token);
|
}
|
}
|
else
|
{
|
OnMethodInvocationComplete(result, cancellationTokenSource.Token);
|
}
|
}
|
|
}, cancellationTokenSource.Token);
|
}
|
|
private async Task<MethodInvocationResult> ExecuteMethodInvocation(MethodInvocation methodInvocation)
|
{
|
object returnValue = null;
|
string exception;
|
var success = false;
|
var nameConverter = repository.NameConverter;
|
|
//make sure we don't throw exceptions in the executor task
|
try
|
{
|
var result = await repository.TryCallMethodAsync(methodInvocation.ObjectId, methodInvocation.MethodName, methodInvocation.Parameters.ToArray()).ConfigureAwait(false);
|
|
success = result.Success;
|
returnValue = result.ReturnValue;
|
exception = result.Exception;
|
}
|
catch (Exception e)
|
{
|
exception = e.Message;
|
}
|
|
return new MethodInvocationResult
|
{
|
BrowserId = methodInvocation.BrowserId,
|
CallbackId = methodInvocation.CallbackId,
|
FrameId = methodInvocation.FrameId,
|
Message = exception,
|
Result = returnValue,
|
Success = success,
|
NameConverter = nameConverter
|
};
|
}
|
|
private void OnMethodInvocationComplete(MethodInvocationResult e, CancellationToken token)
|
{
|
//If cancellation has been requested we don't need to continue.
|
if (!token.IsCancellationRequested)
|
{
|
MethodInvocationComplete?.Invoke(this, new MethodInvocationCompleteArgs(e));
|
}
|
}
|
}
|
}
|
