feat(runtime): Add ability to provide a CT for InvokeAsync

Author: dr1rrb

src/Uno.Foundation.Runtime.WebAssembly/Interop/Runtime.wasm.cs

@@ -1,4 +1,6 @@
-using System;
+#nullable enable
+
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel;
@@ -87,7 +89,7 @@ public static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0)
 		/// Invoke a Javascript method using unmarshaled conversion.
 		/// </summary>
 		/// <param name="functionIdentifier">A function identifier name</param>
-		internal static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, out Exception exception)
+		internal static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, out Exception? exception)
 		{
 			if (_trace.IsEnabled)
 			{
@@ -102,7 +104,7 @@ internal static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0
 			}
 		}
 
-		private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, out Exception exception)
+		private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, out Exception? exception)
 		{
 			exception = null;
 			var methodId = GetMethodId(functionIdentifier);
@@ -115,7 +117,7 @@ private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr
 				{
 					_trace.WriteEvent(
 						TraceProvider.InvokeException,
-						new object[] { functionIdentifier, exception.ToString() }
+						new object[] { functionIdentifier, exceptionMessage }
 					);
 				}
 
@@ -169,7 +171,7 @@ private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr
 		/// <summary>
 		/// Provides an override for javascript invokes.
 		/// </summary>
-		public static Func<string, string> InvokeJSOverride;
+		public static Func<string, string>? InvokeJSOverride;
 
 		public static string InvokeJS(string str)
 		{
@@ -222,7 +224,7 @@ private static string InnerInvokeJS(String str)
 			return result;
 		}
 
-		public static object GetObjectFromGcHandle(string intPtr)
+		public static object? GetObjectFromGcHandle(string intPtr)
 		{
 			var ptr = Marshal.StringToHGlobalAuto(intPtr);
 			var handle = GCHandle.FromIntPtr(ptr);
@@ -268,74 +270,81 @@ public static string InvokeJSWithInterop(FormattableString formattable)
 			return InvokeJS(command);
 		}
 
-		private static readonly Dictionary<long, TaskCompletionSource<string>> _asyncWaitingList = new Dictionary<long, TaskCompletionSource<string>>();
+		private static readonly Dictionary<long, (TaskCompletionSource<string> task, CancellationTokenRegistration ctReg)> _asyncWaitingList
+			= new Dictionary<long, (TaskCompletionSource<string> task, CancellationTokenRegistration ctReg)>();
 
 		private static long _nextAsync;
 
+
+		/// <summary>
+		/// DO NOT USE, use overload with CancellationToken instead
+		/// </remarks>
+		public static Task<string> InvokeAsync(string promiseCode)
+			=> InvokeAsync(promiseCode, CancellationToken.None);
+
 		/// <summary>
 		/// Invoke async javascript code.
 		/// </summary>
 		/// <remarks>
 		/// The javascript code is expected to return a Promise&lt;string&gt;
 		/// </remarks>
-		public static Task<string> InvokeAsync(string promiseCode)
+		public static Task<string> InvokeAsync(string promiseCode, CancellationToken ct)
 		{
-			var id = Interlocked.Increment(ref _nextAsync);
-
+			var handle = Interlocked.Increment(ref _nextAsync);
 			var tcs = new TaskCompletionSource<string>();
+			var ctReg = ct.CanBeCanceled ? ct.Register(() => RemoveAsyncTask(handle)?.TrySetCanceled()) : default;
 
 			lock (_asyncWaitingList)
 			{
-				_asyncWaitingList[id] = tcs;
+				_asyncWaitingList[handle] = (tcs, ctReg);
 			}
 
 			var js = new[]
 			{
 				"const __f = ()=>",
 				promiseCode,
 				";\nUno.UI.Interop.AsyncInteropHelper.Invoke(",
-				id.ToStringInvariant(),
+				handle.ToStringInvariant(),
 				", __f);"
 			};
 
 			try
 			{
-
 				WebAssemblyRuntime.InvokeJS(string.Concat(js));
+
+				return tcs.Task;
 			}
 			catch (Exception ex)
 			{
+				RemoveAsyncTask(handle);
+
 				return Task.FromException<string>(ex);
 			}
-
-			return tcs.Task;
 		}
 
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public static void DispatchAsyncResult(long handle, string result)
-		{
-			lock (_asyncWaitingList)
-			{
-				if (_asyncWaitingList.TryGetValue(handle, out var tcs))
-				{
-					tcs.TrySetResult(result);
-					_asyncWaitingList.Remove(handle);
-				}
-			}
-		}
+			=> RemoveAsyncTask(handle)?.TrySetResult(result);
 
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public static void DispatchAsyncError(long handle, string error)
+			=> RemoveAsyncTask(handle)?.TrySetException(new ApplicationException(error));
+
+		private static TaskCompletionSource<string>? RemoveAsyncTask(long handle)
 		{
+			(TaskCompletionSource<string> task, CancellationTokenRegistration ctReg) listener;
 			lock (_asyncWaitingList)
 			{
-				if (_asyncWaitingList.TryGetValue(handle, out var tcs))
+				if (!_asyncWaitingList.TryGetValue(handle, out listener))
 				{
-					var exception = new ApplicationException(error);
-					tcs.TrySetException(exception);
-					_asyncWaitingList.Remove(handle);
+					return default;
 				}
+				_asyncWaitingList.Remove(handle);
 			}
+
+			listener.ctReg.Dispose();
+
+			return listener.task;
 		}
 
 		[Pure]
@@ -417,7 +426,7 @@ bool NeedsEscape(string s2)
 			}
 		}
 
-		private static IDisposable WritePropertyEventTrace(int startEventId, int stopEventId, string script)
+		private static IDisposable? WritePropertyEventTrace(int startEventId, int stopEventId, string script)
 		{
 			if (_trace.IsEnabled)
 			{

src/Uno.Foundation.Runtime.WebAssembly/Interop/TSInteropMarshaller.wasm.cs

@@ -7,6 +7,7 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading;
 using Uno.Extensions;
 using Uno.Foundation;
 
@@ -104,6 +105,97 @@ public static object InvokeJS(
 			}
 		}
 
+		public static HandleRef<T> Allocate<T>(string propertySetterName, string? propertyResetName = null)
+			where T : struct
+		{
+			var value = new HandleRef<T>(propertyResetName);
+			try
+			{
+				WebAssemblyRuntime.InvokeJSUnmarshalled(propertySetterName, value.Handle);
+			}
+			catch (Exception e)
+			{
+				value.Dispose();
+
+				if (_logger.Value.IsEnabled(LogLevel.Error))
+				{
+					_logger.Value.LogDebug($"Failed Allocate {propertySetterName}/{value.Type}: {e}");
+				}
+
+				throw;
+			}
+
+			return value;
+		}
+
+		public sealed class HandleRef<T> : IDisposable
+			where T : struct
+		{
+			private readonly string? _jsDisposeMethodName;
+
+			private int _isDisposed = 0;
+
+			public HandleRef(string? jsDisposeMethodName)
+			{
+				_jsDisposeMethodName = jsDisposeMethodName;
+				Type = typeof(T);
+				Handle = Marshal.AllocHGlobal(Marshal.SizeOf(Type));
+
+				DumpStructureLayout(Type);
+
+				// Make sure to init the allocated memory
+				Marshal.StructureToPtr(default(T), Handle, false);
+			}
+
+			public Type Type { get; }
+
+			public IntPtr Handle { get; }
+
+			public T Value
+			{
+				get
+				{
+					CheckDisposed();
+					return (T)Marshal.PtrToStructure(Handle, Type);
+				}
+				set
+				{
+					CheckDisposed();
+					Marshal.StructureToPtr(value, Handle, true);
+				}
+			}
+
+			private void CheckDisposed()
+			{
+				if (_isDisposed != 0)
+				{
+					throw new ObjectDisposedException(GetType().Name, "Marshalled object have been disposed.");
+				}
+			}
+
+			/// <inheritdoc />
+			public void Dispose()
+			{
+				if (Interlocked.CompareExchange(ref _isDisposed, 1, 0) == 0)
+				{
+					Marshal.DestroyStructure(Handle, Type);
+					Marshal.FreeHGlobal(Handle);
+
+					if (_jsDisposeMethodName.HasValue())
+					{
+						WebAssemblyRuntime.InvokeJSUnmarshalled(_jsDisposeMethodName!, Handle);
+					}
+
+					GC.SuppressFinalize(this);
+				}
+			}
+
+			~HandleRef()
+			{
+				Dispose();
+			}
+		}
+
 #if TRACE_MEMORY_LAYOUT
 		private static HashSet<Type> _structureDump = new HashSet<Type>();
 #endif