[wasm][mt] Guard more places for blocking wait on JS interop threads

src/libraries/System.Private.CoreLib/src/System/Threading/LowLevelMonitor.Unix.cs

@@ -31,6 +31,9 @@ private void DisposeCore()
 
         private void AcquireCore()
         {
+#if FEATURE_WASM_MANAGED_THREADS
+            Thread.AssureBlockingPossible();
+#endif
             Interop.Sys.LowLevelMonitor_Acquire(_nativeMonitor);
         }
 
@@ -41,6 +44,9 @@ private void ReleaseCore()
 
         private void WaitCore()
         {
+#if FEATURE_WASM_MANAGED_THREADS
+            Thread.AssureBlockingPossible();
+#endif
             Interop.Sys.LowLevelMonitor_Wait(_nativeMonitor);
         }
 
@@ -54,6 +60,10 @@ private bool WaitCore(int timeoutMilliseconds)
                 return true;
             }
 
+#if FEATURE_WASM_MANAGED_THREADS
+            Thread.AssureBlockingPossible();
+#endif
+
             return Interop.Sys.LowLevelMonitor_TimedWait(_nativeMonitor, timeoutMilliseconds);
         }
 

src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/WebWorkerTest.cs

@@ -439,23 +439,31 @@ await executor.Execute(async () =>
         [Theory, MemberData(nameof(GetTargetThreadsAndBlockingCalls))]
         public async Task WaitAssertsOnJSInteropThreads(Executor executor, NamedCall method)
         {
-            using var cts = CreateTestCaseTimeoutSource();
-            await executor.Execute(Task () =>
+            CancellationTokenSource? cts = null;
+            try
             {
-                Exception? exception = null;
-                try
-                {
-                    method.Call(cts.Token);
-                }
-                catch (Exception ex)
+                Thread.ForceBlockingWait((_) => cts = CreateTestCaseTimeoutSource(), null);
+                await executor.Execute(Task () =>
                 {
-                    exception = ex;
-                }
+                    Exception? exception = null;
+                    try
+                    {
+                        method.Call(cts.Token);
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ex;
+                    }
 
-                executor.AssertBlockingWait(exception);
+                    executor.AssertBlockingWait(exception);
 
-                return Task.CompletedTask;
-            }, cts.Token);
+                    return Task.CompletedTask;
+                }, cts.Token);
+            }
+            finally
+            {
+                cts?.Dispose();
+            }
         }
 
         [Theory, MemberData(nameof(GetTargetThreads))]

src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/WebWorkerTestBase.cs

@@ -146,24 +146,48 @@ public class NamedCall
             override public string ToString() => Name;
         }
 
+        static void LocalCtsIgnoringCall(Action<CancellationToken> action)
+        {
+            var cts = new CancellationTokenSource(8);
+            try {
+                    action(cts.Token);
+            } catch (OperationCanceledException exception) {
+                if (exception.CancellationToken != cts.Token)
+                {
+                    throw;
+                }
+                /* ignore the local one */
+            }
+        }
+
         public static IEnumerable<NamedCall> BlockingCalls = new List<NamedCall>
         {
                 new NamedCall { Name = "Task.Wait", Call = delegate (CancellationToken ct) { Task.Delay(10, ct).Wait(ct); }},
                 new NamedCall { Name = "Task.WaitAll", Call = delegate (CancellationToken ct) { Task.WaitAll(Task.Delay(10, ct)); }},
                 new NamedCall { Name = "Task.WaitAny", Call = delegate (CancellationToken ct) { Task.WaitAny(Task.Delay(10, ct)); }},
                 new NamedCall { Name = "ManualResetEventSlim.Wait", Call = delegate (CancellationToken ct) {
                     using var mr = new ManualResetEventSlim(false);
-                    using var cts = new CancellationTokenSource(8);
-                    try {
-                        mr.Wait(cts.Token);
-                    } catch (OperationCanceledException) { /* ignore */ }
+                    LocalCtsIgnoringCall(mr.Wait);
                 }},
                 new NamedCall { Name = "SemaphoreSlim.Wait", Call = delegate (CancellationToken ct) {
                     using var sem = new SemaphoreSlim(2);
-                    var cts = new CancellationTokenSource(8);
-                    try {
-                        sem.Wait(cts.Token);
-                    } catch (OperationCanceledException) { /* ignore */ }
+                    LocalCtsIgnoringCall(sem.Wait);
+                }},
+                new NamedCall { Name = "CancellationTokenSource.ctor", Call = delegate (CancellationToken ct) {
+                    using var cts = new CancellationTokenSource(8);
+                }},
+                new NamedCall { Name = "Mutex.WaitOne", Call = delegate (CancellationToken ct) {
+                    using var mr = new ManualResetEventSlim(false);
+                    var mutex = new Mutex();
+                    var thread = new Thread(() => {
+                        mutex.WaitOne();
+                        mr.Set();
+                        Thread.Sleep(50);
+                        mutex.ReleaseMutex();
+                    });
+                    thread.Start();
+                    Thread.ForceBlockingWait((_) => mr.Wait(), null);
+                    mutex.WaitOne();
                 }},
         };