Fix non-thread-safety of TrySetResultAsync

CefSharp.OffScreen/ChromiumWebBrowser.cs

@@ -507,7 +507,7 @@ public Task<Bitmap> ScreenshotAsync(bool ignoreExistingScreenshot = false, Popup
             // Try our luck and see if there is already a screenshot, to save us creating a new thread for nothing.
             var screenshot = ScreenshotOrNull(blend);
 
-            var completionSource = new TaskCompletionSource<Bitmap>();
+            var completionSource = new AsyncTaskCompletionSource<Bitmap>();
 
             if (screenshot == null || ignoreExistingScreenshot)
             {

CefSharp.Test/Framework/AsyncExtensionFacts.cs

@@ -36,22 +36,25 @@ public async Task DeleteCookiesReturnsTaskWhenReturnsFalse()
         [Fact]
         public async Task TaskDeleteCookiesCallbackOnComplete()
         {
-            const int numberOfCookiesDeleted = 10;
+            for (var i = 0; i < 100; i++)
+            {
+                const int numberOfCookiesDeleted = 10;
 
-            var callback = new TaskDeleteCookiesCallback();
+                var callback = new TaskDeleteCookiesCallback();
 
-            //Execute OnComplete on seperate Thread as in practice will be called on the CEF IO Thread.
-            Task.Delay(100).ContinueWith(x =>
-            {
-                var c = (IDeleteCookiesCallback)callback;
+                //Execute OnComplete on seperate Thread as in practice will be called on the CEF IO Thread.
+                Task.Delay(100).ContinueWith(x =>
+                {
+                    var c = (IDeleteCookiesCallback)callback;
 
-                c.OnComplete(numberOfCookiesDeleted);
-                c.Dispose();
-            }, TaskScheduler.Default);
+                    c.OnComplete(numberOfCookiesDeleted);
+                    c.Dispose();
+                }, TaskScheduler.Default);
 
-            var result = await callback.Task;
+                var result = await callback.Task;
 
-            Assert.Equal(numberOfCookiesDeleted, result);
+                Assert.Equal(numberOfCookiesDeleted, result);
+            }
         }
 
         [Fact]

CefSharp/Callback/TaskCompletionCallback.cs

@@ -10,11 +10,11 @@ namespace CefSharp
 {
     public class TaskCompletionCallback : ICompletionCallback
     {
-        private readonly TaskCompletionSource<bool> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<bool> taskCompletionSource;
 
         public TaskCompletionCallback()
         {
-            taskCompletionSource = new TaskCompletionSource<bool>();
+            taskCompletionSource = new AsyncTaskCompletionSource<bool>();
         }
 
         void ICompletionCallback.OnComplete()

CefSharp/Callback/TaskDeleteCookiesCallback.cs

@@ -15,12 +15,12 @@ public class TaskDeleteCookiesCallback : IDeleteCookiesCallback
     {
         public const int InvalidNoOfCookiesDeleted = -1;
 
-        private readonly TaskCompletionSource<int> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<int> taskCompletionSource;
         private volatile bool isDisposed;
 
         public TaskDeleteCookiesCallback()
         {
-            taskCompletionSource = new TaskCompletionSource<int>();
+            taskCompletionSource = new AsyncTaskCompletionSource<int>();
         }
 
         void IDeleteCookiesCallback.OnComplete(int numDeleted)

CefSharp/Callback/TaskPrintToPdfCallback.cs

@@ -10,7 +10,7 @@ namespace CefSharp
 {
     public sealed class TaskPrintToPdfCallback : IPrintToPdfCallback
     {
-        private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
+        private readonly AsyncTaskCompletionSource<bool> taskCompletionSource = new AsyncTaskCompletionSource<bool>();
 
         public Task<bool> Task
         {

CefSharp/Callback/TaskRegisterCdmCallback.cs

@@ -13,11 +13,11 @@ namespace CefSharp
     /// </summary>
     public class TaskRegisterCdmCallback: IRegisterCdmCallback
     {
-        private readonly TaskCompletionSource<CdmRegistration> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<CdmRegistration> taskCompletionSource;
 
         public TaskRegisterCdmCallback()
         {
-            taskCompletionSource = new TaskCompletionSource<CdmRegistration>();
+            taskCompletionSource = new AsyncTaskCompletionSource<CdmRegistration>();
         }
 
         void IRegisterCdmCallback.OnRegistrationComplete(CdmRegistration registration)

CefSharp/Callback/TaskResolveCallback.cs

@@ -10,11 +10,11 @@ namespace CefSharp
 {
     public class TaskResolveCallback : IResolveCallback
     {
-        private readonly TaskCompletionSource<ResolveCallbackResult> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<ResolveCallbackResult> taskCompletionSource;
 
         public TaskResolveCallback()
         {
-            taskCompletionSource = new TaskCompletionSource<ResolveCallbackResult>();
+            taskCompletionSource = new AsyncTaskCompletionSource<ResolveCallbackResult>();
         }
 
         public void OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses)

CefSharp/Callback/TaskSetCookieCallback.cs

@@ -13,12 +13,12 @@ namespace CefSharp
     /// </summary>
     public class TaskSetCookieCallback : ISetCookieCallback
     {
-        private readonly TaskCompletionSource<bool> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<bool> taskCompletionSource;
         private volatile bool isDisposed;
 
         public TaskSetCookieCallback()
         {
-            taskCompletionSource = new TaskCompletionSource<bool>();
+            taskCompletionSource = new AsyncTaskCompletionSource<bool>();
         }
 
         void ISetCookieCallback.OnComplete(bool success)

CefSharp/CefSharp.csproj

@@ -72,6 +72,7 @@
   <ItemGroup>
     <Compile Include="AsyncExtensions.cs" />
     <Compile Include="BindingOptions.cs" />
+    <Compile Include="Internals\AsyncTaskCompletionSource.cs" />
     <Compile Include="Callback\IAuthCallback.cs" />
     <Compile Include="Callback\IBeforeDownloadCallback.cs" />
     <Compile Include="Callback\ICallback.cs" />

CefSharp/Internals/AsyncTaskCompletionSource.cs

@@ -0,0 +1,43 @@
+// Copyright © 2010-2017 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
+{
+    /// <summary>
+    /// Wraps <see cref="TaskCompletionSource{T}"/> by providing a way to set its result in an asynchronous
+    /// fashion. This prevents the resulting Task continuations from being executed synchronously on the same
+    /// thread as the one completing the Task, which may be better when that thread is a CEF UI thread.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class AsyncTaskCompletionSource<T>
+    {
+        private readonly TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
+        private int resultSet = 0;
+
+        /// <summary>
+        /// Gets the <see cref="Task{TResult}"/> created by the wrapped <see cref="AsyncTaskCompletionSource{T}"/> instance.
+        /// </summary>
+        /// <seealso cref="TaskCompletionSource{TResult}.Task"/>
+        public Task<T> Task => tcs.Task;
+
+        /// <summary>
+        /// Sets the wrapped <see cref="TaskCompletionSource{T}"/> instance result in an asynchronous fashion.
+        /// This prevents the Task continuations from being executed synchronously on the same thread as the
+        /// one calling this method, which is required when this thread is a CEF UI thread.
+        /// </summary>
+        /// <param name="result">result</param>
+        public void TrySetResultAsync(T result)
+        {
+            if (Interlocked.Exchange(ref resultSet, 1) == 0)
+            {
+                System.Threading.Tasks.Task.Factory.StartNew(() => tcs.TrySetResult(result),
+                    CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
+            }
+        }
+    }
+}

CefSharp/Internals/TaskExtensions.cs

@@ -89,8 +89,14 @@ public static TaskCompletionSource<TResult> WithTimeout<TResult>(this TaskComple
         }
 
         /// <summary>
+        /// <para>
         /// Set the TaskCompletionSource in an async fashion. This prevents the Task Continuation being executed sync on the same thread
-        /// This is required otherwise contintinuations will happen on CEF UI threads
+        /// This is required otherwise contintinuations will happen on CEF UI threads.
+        /// </para>
+        /// <para>
+        /// USAGE WARNING: if this method is called twice on the same task completion source, the result it not deterministic.
+        /// Use it with care, or use <see cref="AsyncTaskCompletionSource{T}"/>.
+        /// </para>
         /// </summary>
         /// <typeparam name="TResult">Generic param</typeparam>
         /// <param name="taskCompletionSource">tcs</param>

CefSharp/Visitor/TaskCookieVisitor.cs

@@ -15,15 +15,15 @@ namespace CefSharp
     /// </summary>
     public class TaskCookieVisitor : ICookieVisitor
     {
-        private readonly TaskCompletionSource<List<Cookie>> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<List<Cookie>> taskCompletionSource;
         private List<Cookie> list;
 
         /// <summary>
         /// Default constructor
         /// </summary>
         public TaskCookieVisitor()
         {
-            taskCompletionSource = new TaskCompletionSource<List<Cookie>>();
+            taskCompletionSource = new AsyncTaskCompletionSource<List<Cookie>>();
             list = new List<Cookie>();
         }
 

CefSharp/Visitor/TaskNavigationEntryVisitor.cs

@@ -15,15 +15,15 @@ namespace CefSharp
     /// </summary>
     public class TaskNavigationEntryVisitor : INavigationEntryVisitor
     {
-        private TaskCompletionSource<List<NavigationEntry>> taskCompletionSource;
+        private AsyncTaskCompletionSource<List<NavigationEntry>> taskCompletionSource;
         private List<NavigationEntry> list;
 
         /// <summary>
         /// Default constructor
         /// </summary>
         public TaskNavigationEntryVisitor()
         {
-            taskCompletionSource = new TaskCompletionSource<List<NavigationEntry>>();
+            taskCompletionSource = new AsyncTaskCompletionSource<List<NavigationEntry>>();
             list = new List<NavigationEntry>();
         }
 

CefSharp/Visitor/TaskStringVisitor.cs

@@ -14,14 +14,14 @@ namespace CefSharp
     /// </summary>
     public class TaskStringVisitor : IStringVisitor
     {
-        private readonly TaskCompletionSource<string> taskCompletionSource;
+        private readonly AsyncTaskCompletionSource<string> taskCompletionSource;
 
         /// <summary>
         /// Default constructor
         /// </summary>
         public TaskStringVisitor()
         {
-            taskCompletionSource = new TaskCompletionSource<string>();
+            taskCompletionSource = new AsyncTaskCompletionSource<string>();
         }
 
         /// <summary>

CefSharp/Visitor/TaskWebPluginInfoVisitor.cs

@@ -11,12 +11,12 @@ namespace CefSharp
 {
     public class TaskWebPluginInfoVisitor : IWebPluginInfoVisitor
     {
-        private TaskCompletionSource<List<WebPluginInfo>> taskCompletionSource;
+        private AsyncTaskCompletionSource<List<WebPluginInfo>> taskCompletionSource;
         private List<WebPluginInfo> list;
 
         public TaskWebPluginInfoVisitor()
         {
-            taskCompletionSource = new TaskCompletionSource<List<WebPluginInfo>>();
+            taskCompletionSource = new AsyncTaskCompletionSource<List<WebPluginInfo>>();
             list = new List<WebPluginInfo>();
         }