Task Callbacks - only call TrySetResultAsync if the callback was never called

amaitland · amaitland · commit b034d1c552f5 · 2018-04-30T14:21:21.000+10:00
Add IsDisposed property to ICompletionCallback, IPrintToPdfCallback, IRegisterCdmCallback, IResolveCallback Should resolve #2349 until the code review can be finished
diff --git a/CefSharp/Callback/ICompletionCallback.cs b/CefSharp/Callback/ICompletionCallback.cs
@@ -15,5 +15,10 @@ public interface ICompletionCallback : IDisposable
         /// Method that will be called once the task is complete. 
         /// </summary>
         void OnComplete();
+
+        /// <summary>
+        /// Gets a value indicating whether the callback has been disposed of.
+        /// </summary>
+        bool IsDisposed { get; }
     }
 }
diff --git a/CefSharp/Callback/IPrintToPdfCallback.cs b/CefSharp/Callback/IPrintToPdfCallback.cs
@@ -19,5 +19,10 @@ public interface IPrintToPdfCallback : IDisposable
         /// <param name="ok">Will be true if the printing completed
         /// successfully or false otherwise.</param>
         void OnPdfPrintFinished(string path, bool ok);
+
+        /// <summary>
+        /// Gets a value indicating whether the callback has been disposed of.
+        /// </summary>
+        bool IsDisposed { get; }
     }
 }
diff --git a/CefSharp/Callback/IRegisterCdmCallback.cs b/CefSharp/Callback/IRegisterCdmCallback.cs
@@ -16,5 +16,10 @@ public interface IRegisterCdmCallback : IDisposable
         /// </summary>
         /// <param name="registration">The result of the CDM registration process</param>
         void OnRegistrationComplete(CdmRegistration registration);
+
+        /// <summary>
+        /// Gets a value indicating whether the callback has been disposed of.
+        /// </summary>
+        bool IsDisposed { get; }
     }
 }
diff --git a/CefSharp/Callback/IResolveCallback.cs b/CefSharp/Callback/IResolveCallback.cs
@@ -2,11 +2,12 @@
 //
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
+using System;
 using System.Collections.Generic;
 
 namespace CefSharp
 {
-    public interface IResolveCallback
+    public interface IResolveCallback : IDisposable
     {
         /// <summary>
         /// Called after the ResolveHost request has completed.
@@ -15,5 +16,10 @@ public interface IResolveCallback
         /// <param name="resolvedIpAddresses">will be the list of resolved IP addresses or
         /// empty if the resolution failed.</param>
         void OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses);
+
+        /// <summary>
+        /// Gets a value indicating whether the callback has been disposed of.
+        /// </summary>
+        bool IsDisposed { get; }
     }
 }
diff --git a/CefSharp/Callback/TaskCompletionCallback.cs b/CefSharp/Callback/TaskCompletionCallback.cs
@@ -10,15 +10,14 @@ namespace CefSharp
 {
     public class TaskCompletionCallback : ICompletionCallback
     {
-        private readonly TaskCompletionSource<bool> taskCompletionSource;
-
-        public TaskCompletionCallback()
-        {
-            taskCompletionSource = new TaskCompletionSource<bool>();
-        }
+        private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
+        private volatile bool isDisposed;
+        private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety
 
         void ICompletionCallback.OnComplete()
         {
+            complete = true;
+
             taskCompletionSource.TrySetResultAsync(true);
         }
 
@@ -27,16 +26,23 @@ public Task<bool> Task
             get { return taskCompletionSource.Task; }
         }
 
+        bool ICompletionCallback.IsDisposed
+        {
+            get { return isDisposed; }
+        }
+
         void IDisposable.Dispose()
         {
             var task = taskCompletionSource.Task;
 
             //If the Task hasn't completed and this is being disposed then
             //set the TCS to false
-            if(task.IsCompleted == false)
+            if(complete == false && task.IsCompleted == false)
             {
                 taskCompletionSource.TrySetResultAsync(false);
             }
+
+            isDisposed = true;
         }
     }
 }
diff --git a/CefSharp/Callback/TaskDeleteCookiesCallback.cs b/CefSharp/Callback/TaskDeleteCookiesCallback.cs
@@ -15,16 +15,14 @@ public class TaskDeleteCookiesCallback : IDeleteCookiesCallback
     {
         public const int InvalidNoOfCookiesDeleted = -1;
 
-        private readonly TaskCompletionSource<int> taskCompletionSource;
+        private readonly TaskCompletionSource<int> taskCompletionSource = new TaskCompletionSource<int>();
         private volatile bool isDisposed;
-
-        public TaskDeleteCookiesCallback()
-        {
-            taskCompletionSource = new TaskCompletionSource<int>();
-        }
+        private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety
 
         void IDeleteCookiesCallback.OnComplete(int numDeleted)
         {
+            complete = true;
+
             taskCompletionSource.TrySetResultAsync(numDeleted);
         }
 
@@ -38,14 +36,13 @@ bool IDeleteCookiesCallback.IsDisposed
             get { return isDisposed; }
         }
 
-
         void IDisposable.Dispose()
         {
             var task = taskCompletionSource.Task;
 
             //If the Task hasn't completed and this is being disposed then
             //set the TCS to InvalidNoOfCookiesDeleted
-            if (task.IsCompleted == false)
+            if (complete == false && task.IsCompleted == false)
             {
                 taskCompletionSource.TrySetResultAsync(InvalidNoOfCookiesDeleted);
             }
diff --git a/CefSharp/Callback/TaskPrintToPdfCallback.cs b/CefSharp/Callback/TaskPrintToPdfCallback.cs
@@ -11,6 +11,8 @@ namespace CefSharp
     public sealed class TaskPrintToPdfCallback : IPrintToPdfCallback
     {
         private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
+        private volatile bool isDisposed;
+        private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety
 
         public Task<bool> Task
         {
@@ -19,12 +21,28 @@ public Task<bool> Task
 
         void IPrintToPdfCallback.OnPdfPrintFinished(string path, bool ok)
         {
+            complete = true;
+
             taskCompletionSource.TrySetResultAsync(ok);
         }
 
+        bool IPrintToPdfCallback.IsDisposed
+        {
+            get { return isDisposed; }
+        }
+
         void IDisposable.Dispose()
         {
-            //TODO: Check if this is ever called
+            var task = taskCompletionSource.Task;
+
+            //If the Task hasn't completed and this is being disposed then
+            //set the TCS to false
+            if (complete == false && task.IsCompleted == false)
+            {
+                taskCompletionSource.TrySetResultAsync(false);
+            }
+
+            isDisposed = true;
         }
     }
 }
diff --git a/CefSharp/Callback/TaskRegisterCdmCallback.cs b/CefSharp/Callback/TaskRegisterCdmCallback.cs
@@ -11,17 +11,16 @@ namespace CefSharp
     /// <summary>
     /// Provides a callback implementation of <see cref="IRegisterCdmCallback"/> for use with asynchronous Widevine CDM registration.
     /// </summary>
-    public class TaskRegisterCdmCallback: IRegisterCdmCallback
+    public class TaskRegisterCdmCallback : IRegisterCdmCallback
     {
-        private readonly TaskCompletionSource<CdmRegistration> taskCompletionSource;
-
-        public TaskRegisterCdmCallback()
-        {
-            taskCompletionSource = new TaskCompletionSource<CdmRegistration>();
-        }
+        private readonly TaskCompletionSource<CdmRegistration> taskCompletionSource = new TaskCompletionSource<CdmRegistration>();
+        private volatile bool isDisposed;
+        private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety
 
         void IRegisterCdmCallback.OnRegistrationComplete(CdmRegistration registration)
         {
+            complete = true;
+
             taskCompletionSource.TrySetResultAsync(registration);
         }
 
@@ -30,16 +29,23 @@ public Task<CdmRegistration> Task
             get { return taskCompletionSource.Task; }
         }
 
+        bool IRegisterCdmCallback.IsDisposed
+        {
+            get { return isDisposed; }
+        }
+
         void IDisposable.Dispose()
         {
             var task = taskCompletionSource.Task;
 
             //If the Task hasn't completed and this is being disposed then
-            //set the TCS to false
-            if (task.IsCompleted == false)
+            //set the TCS to null
+            if (complete == false && task.IsCompleted == false)
             {
                 taskCompletionSource.TrySetResultAsync(null);
             }
+
+            isDisposed = true;
         }
     }
 }
diff --git a/CefSharp/Callback/TaskResolveCallback.cs b/CefSharp/Callback/TaskResolveCallback.cs
@@ -2,6 +2,7 @@
 //
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using CefSharp.Internals;
@@ -10,21 +11,39 @@ namespace CefSharp
 {
     public class TaskResolveCallback : IResolveCallback
     {
-        private readonly TaskCompletionSource<ResolveCallbackResult> taskCompletionSource;
+        private readonly TaskCompletionSource<ResolveCallbackResult> taskCompletionSource = new TaskCompletionSource<ResolveCallbackResult>();
+        private volatile bool isDisposed;
+        private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety
 
-        public TaskResolveCallback()
+        void IResolveCallback.OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses)
         {
-            taskCompletionSource = new TaskCompletionSource<ResolveCallbackResult>();
+            complete = true;
+
+            taskCompletionSource.TrySetResultAsync(new ResolveCallbackResult(result, resolvedIpAddresses));
         }
 
-        public void OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses)
+        void IDisposable.Dispose()
         {
-            taskCompletionSource.TrySetResultAsync(new ResolveCallbackResult(result, resolvedIpAddresses));
+            var task = taskCompletionSource.Task;
+
+            //If the Task hasn't completed and this is being disposed then
+            //set the TCS to null
+            if (complete == false && task.IsCompleted == false)
+            {
+                taskCompletionSource.TrySetResultAsync(new ResolveCallbackResult(CefErrorCode.Unexpected, null));
+            }
+
+            isDisposed = true;
         }
 
         public Task<ResolveCallbackResult> Task
         {
             get { return taskCompletionSource.Task; }
         }
+
+        bool IResolveCallback.IsDisposed
+        {
+            get { return isDisposed; }
+        }
     }
 }
diff --git a/CefSharp/Callback/TaskSetCookieCallback.cs b/CefSharp/Callback/TaskSetCookieCallback.cs
@@ -13,16 +13,14 @@ namespace CefSharp
     /// </summary>
     public class TaskSetCookieCallback : ISetCookieCallback
     {
-        private readonly TaskCompletionSource<bool> taskCompletionSource;
+        private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
         private volatile bool isDisposed;
-
-        public TaskSetCookieCallback()
-        {
-            taskCompletionSource = new TaskCompletionSource<bool>();
-        }
+        private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety
 
         void ISetCookieCallback.OnComplete(bool success)
         {
+            complete = true;
+
             taskCompletionSource.TrySetResultAsync(success);
         }
 
@@ -42,13 +40,12 @@ void IDisposable.Dispose()
 
             //If the Task hasn't completed and this is being disposed then
             //set the TCS to false
-            if (task.IsCompleted == false)
+            if (complete == false && task.IsCompleted == false)
             {
                 taskCompletionSource.TrySetResultAsync(false);
             }
 
             isDisposed = true;
-
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,5 +15,10 @@ public interface ICompletionCallback : IDisposable`
`15`	`15`	`/// Method that will be called once the task is complete.`
`16`	`16`	`/// </summary>`
`17`	`17`	`void OnComplete();`
	`18`	`+`
	`19`	`+ /// <summary>`
	`20`	`+ /// Gets a value indicating whether the callback has been disposed of.`
	`21`	`+ /// </summary>`
	`22`	`+ bool IsDisposed { get; }`
`18`	`23`	`}`
`19`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,5 +19,10 @@ public interface IPrintToPdfCallback : IDisposable`
`19`	`19`	`/// <param name="ok">Will be true if the printing completed`
`20`	`20`	`/// successfully or false otherwise.</param>`
`21`	`21`	`void OnPdfPrintFinished(string path, bool ok);`
	`22`	`+`
	`23`	`+ /// <summary>`
	`24`	`+ /// Gets a value indicating whether the callback has been disposed of.`
	`25`	`+ /// </summary>`
	`26`	`+ bool IsDisposed { get; }`
`22`	`27`	`}`
`23`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,5 +16,10 @@ public interface IRegisterCdmCallback : IDisposable`
`16`	`16`	`/// </summary>`
`17`	`17`	`/// <param name="registration">The result of the CDM registration process</param>`
`18`	`18`	`void OnRegistrationComplete(CdmRegistration registration);`
	`19`	`+`
	`20`	`+ /// <summary>`
	`21`	`+ /// Gets a value indicating whether the callback has been disposed of.`
	`22`	`+ /// </summary>`
	`23`	`+ bool IsDisposed { get; }`
`19`	`24`	`}`
`20`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,12 @@`
`2`	`2`	`//`
`3`	`3`	`// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.`
`4`	`4`
	`5`	`+using System;`
`5`	`6`	`using System.Collections.Generic;`
`6`	`7`
`7`	`8`	`namespace CefSharp`
`8`	`9`	`{`
`9`		`- public interface IResolveCallback`
	`10`	`+ public interface IResolveCallback : IDisposable`
`10`	`11`	`{`
`11`	`12`	`/// <summary>`
`12`	`13`	`/// Called after the ResolveHost request has completed.`
`@@ -15,5 +16,10 @@ public interface IResolveCallback`
`15`	`16`	`/// <param name="resolvedIpAddresses">will be the list of resolved IP addresses or`
`16`	`17`	`/// empty if the resolution failed.</param>`
`17`	`18`	`void OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses);`
	`19`	`+`
	`20`	`+ /// <summary>`
	`21`	`+ /// Gets a value indicating whether the callback has been disposed of.`
	`22`	`+ /// </summary>`
	`23`	`+ bool IsDisposed { get; }`
`18`	`24`	`}`
`19`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,15 +10,14 @@ namespace CefSharp`
`10`	`10`	`{`
`11`	`11`	`public class TaskCompletionCallback : ICompletionCallback`
`12`	`12`	`{`
`13`		`- private readonly TaskCompletionSource<bool> taskCompletionSource;`
`14`		`-`
`15`		`- public TaskCompletionCallback()`
`16`		`- {`
`17`		`- taskCompletionSource = new TaskCompletionSource<bool>();`
`18`		`- }`
	`13`	`+ private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();`
	`14`	`+ private volatile bool isDisposed;`
	`15`	`+ private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety`
`19`	`16`
`20`	`17`	`void ICompletionCallback.OnComplete()`
`21`	`18`	`{`
	`19`	`+ complete = true;`
	`20`	`+`
`22`	`21`	`taskCompletionSource.TrySetResultAsync(true);`
`23`	`22`	`}`
`24`	`23`
`@@ -27,16 +26,23 @@ public Task<bool> Task`
`27`	`26`	`get { return taskCompletionSource.Task; }`
`28`	`27`	`}`
`29`	`28`
	`29`	`+ bool ICompletionCallback.IsDisposed`
	`30`	`+ {`
	`31`	`+ get { return isDisposed; }`
	`32`	`+ }`
	`33`	`+`
`30`	`34`	`void IDisposable.Dispose()`
`31`	`35`	`{`
`32`	`36`	`var task = taskCompletionSource.Task;`
`33`	`37`
`34`	`38`	`//If the Task hasn't completed and this is being disposed then`
`35`	`39`	`//set the TCS to false`
`36`		`- if(task.IsCompleted == false)`
	`40`	`+ if(complete == false && task.IsCompleted == false)`
`37`	`41`	`{`
`38`	`42`	`taskCompletionSource.TrySetResultAsync(false);`
`39`	`43`	`}`
	`44`	`+`
	`45`	`+ isDisposed = true;`
`40`	`46`	`}`
`41`	`47`	`}`
`42`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,16 +15,14 @@ public class TaskDeleteCookiesCallback : IDeleteCookiesCallback`
`15`	`15`	`{`
`16`	`16`	`public const int InvalidNoOfCookiesDeleted = -1;`
`17`	`17`
`18`		`- private readonly TaskCompletionSource<int> taskCompletionSource;`
	`18`	`+ private readonly TaskCompletionSource<int> taskCompletionSource = new TaskCompletionSource<int>();`
`19`	`19`	`private volatile bool isDisposed;`
`20`		`-`
`21`		`- public TaskDeleteCookiesCallback()`
`22`		`- {`
`23`		`- taskCompletionSource = new TaskCompletionSource<int>();`
`24`		`- }`
	`20`	`+ private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety`
`25`	`21`
`26`	`22`	`void IDeleteCookiesCallback.OnComplete(int numDeleted)`
`27`	`23`	`{`
	`24`	`+ complete = true;`
	`25`	`+`
`28`	`26`	`taskCompletionSource.TrySetResultAsync(numDeleted);`
`29`	`27`	`}`
`30`	`28`
`@@ -38,14 +36,13 @@ bool IDeleteCookiesCallback.IsDisposed`
`38`	`36`	`get { return isDisposed; }`
`39`	`37`	`}`
`40`	`38`
`41`		`-`
`42`	`39`	`void IDisposable.Dispose()`
`43`	`40`	`{`
`44`	`41`	`var task = taskCompletionSource.Task;`
`45`	`42`
`46`	`43`	`//If the Task hasn't completed and this is being disposed then`
`47`	`44`	`//set the TCS to InvalidNoOfCookiesDeleted`
`48`		`- if (task.IsCompleted == false)`
	`45`	`+ if (complete == false && task.IsCompleted == false)`
`49`	`46`	`{`
`50`	`47`	`taskCompletionSource.TrySetResultAsync(InvalidNoOfCookiesDeleted);`
`51`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,8 @@ namespace CefSharp`
`11`	`11`	`public sealed class TaskPrintToPdfCallback : IPrintToPdfCallback`
`12`	`12`	`{`
`13`	`13`	`private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();`
	`14`	`+ private volatile bool isDisposed;`
	`15`	`+ private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety`
`14`	`16`
`15`	`17`	`public Task<bool> Task`
`16`	`18`	`{`
`@@ -19,12 +21,28 @@ public Task<bool> Task`
`19`	`21`
`20`	`22`	`void IPrintToPdfCallback.OnPdfPrintFinished(string path, bool ok)`
`21`	`23`	`{`
	`24`	`+ complete = true;`
	`25`	`+`
`22`	`26`	`taskCompletionSource.TrySetResultAsync(ok);`
`23`	`27`	`}`
`24`	`28`
	`29`	`+ bool IPrintToPdfCallback.IsDisposed`
	`30`	`+ {`
	`31`	`+ get { return isDisposed; }`
	`32`	`+ }`
	`33`	`+`
`25`	`34`	`void IDisposable.Dispose()`
`26`	`35`	`{`
`27`		`- //TODO: Check if this is ever called`
	`36`	`+ var task = taskCompletionSource.Task;`
	`37`	`+`
	`38`	`+ //If the Task hasn't completed and this is being disposed then`
	`39`	`+ //set the TCS to false`
	`40`	`+ if (complete == false && task.IsCompleted == false)`
	`41`	`+ {`
	`42`	`+ taskCompletionSource.TrySetResultAsync(false);`
	`43`	`+ }`
	`44`	`+`
	`45`	`+ isDisposed = true;`
`28`	`46`	`}`
`29`	`47`	`}`
`30`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,17 +11,16 @@ namespace CefSharp`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// Provides a callback implementation of <see cref="IRegisterCdmCallback"/> for use with asynchronous Widevine CDM registration.`
`13`	`13`	`/// </summary>`
`14`		`- public class TaskRegisterCdmCallback: IRegisterCdmCallback`
	`14`	`+ public class TaskRegisterCdmCallback : IRegisterCdmCallback`
`15`	`15`	`{`
`16`		`- private readonly TaskCompletionSource<CdmRegistration> taskCompletionSource;`
`17`		`-`
`18`		`- public TaskRegisterCdmCallback()`
`19`		`- {`
`20`		`- taskCompletionSource = new TaskCompletionSource<CdmRegistration>();`
`21`		`- }`
	`16`	`+ private readonly TaskCompletionSource<CdmRegistration> taskCompletionSource = new TaskCompletionSource<CdmRegistration>();`
	`17`	`+ private volatile bool isDisposed;`
	`18`	`+ private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety`
`22`	`19`
`23`	`20`	`void IRegisterCdmCallback.OnRegistrationComplete(CdmRegistration registration)`
`24`	`21`	`{`
	`22`	`+ complete = true;`
	`23`	`+`
`25`	`24`	`taskCompletionSource.TrySetResultAsync(registration);`
`26`	`25`	`}`
`27`	`26`
`@@ -30,16 +29,23 @@ public Task<CdmRegistration> Task`
`30`	`29`	`get { return taskCompletionSource.Task; }`
`31`	`30`	`}`
`32`	`31`
	`32`	`+ bool IRegisterCdmCallback.IsDisposed`
	`33`	`+ {`
	`34`	`+ get { return isDisposed; }`
	`35`	`+ }`
	`36`	`+`
`33`	`37`	`void IDisposable.Dispose()`
`34`	`38`	`{`
`35`	`39`	`var task = taskCompletionSource.Task;`
`36`	`40`
`37`	`41`	`//If the Task hasn't completed and this is being disposed then`
`38`		`- //set the TCS to false`
`39`		`- if (task.IsCompleted == false)`
	`42`	`+ //set the TCS to null`
	`43`	`+ if (complete == false && task.IsCompleted == false)`
`40`	`44`	`{`
`41`	`45`	`taskCompletionSource.TrySetResultAsync(null);`
`42`	`46`	`}`
	`47`	`+`
	`48`	`+ isDisposed = true;`
`43`	`49`	`}`
`44`	`50`	`}`
`45`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`//`
`3`	`3`	`// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.`
`4`	`4`
	`5`	`+using System;`
`5`	`6`	`using System.Collections.Generic;`
`6`	`7`	`using System.Threading.Tasks;`
`7`	`8`	`using CefSharp.Internals;`
`@@ -10,21 +11,39 @@ namespace CefSharp`
`10`	`11`	`{`
`11`	`12`	`public class TaskResolveCallback : IResolveCallback`
`12`	`13`	`{`
`13`		`- private readonly TaskCompletionSource<ResolveCallbackResult> taskCompletionSource;`
	`14`	`+ private readonly TaskCompletionSource<ResolveCallbackResult> taskCompletionSource = new TaskCompletionSource<ResolveCallbackResult>();`
	`15`	`+ private volatile bool isDisposed;`
	`16`	`+ private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety`
`14`	`17`
`15`		`- public TaskResolveCallback()`
	`18`	`+ void IResolveCallback.OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses)`
`16`	`19`	`{`
`17`		`- taskCompletionSource = new TaskCompletionSource<ResolveCallbackResult>();`
	`20`	`+ complete = true;`
	`21`	`+`
	`22`	`+ taskCompletionSource.TrySetResultAsync(new ResolveCallbackResult(result, resolvedIpAddresses));`
`18`	`23`	`}`
`19`	`24`
`20`		`- public void OnResolveCompleted(CefErrorCode result, IList<string> resolvedIpAddresses)`
	`25`	`+ void IDisposable.Dispose()`
`21`	`26`	`{`
`22`		`- taskCompletionSource.TrySetResultAsync(new ResolveCallbackResult(result, resolvedIpAddresses));`
	`27`	`+ var task = taskCompletionSource.Task;`
	`28`	`+`
	`29`	`+ //If the Task hasn't completed and this is being disposed then`
	`30`	`+ //set the TCS to null`
	`31`	`+ if (complete == false && task.IsCompleted == false)`
	`32`	`+ {`
	`33`	`+ taskCompletionSource.TrySetResultAsync(new ResolveCallbackResult(CefErrorCode.Unexpected, null));`
	`34`	`+ }`
	`35`	`+`
	`36`	`+ isDisposed = true;`
`23`	`37`	`}`
`24`	`38`
`25`	`39`	`public Task<ResolveCallbackResult> Task`
`26`	`40`	`{`
`27`	`41`	`get { return taskCompletionSource.Task; }`
`28`	`42`	`}`
	`43`	`+`
	`44`	`+ bool IResolveCallback.IsDisposed`
	`45`	`+ {`
	`46`	`+ get { return isDisposed; }`
	`47`	`+ }`
`29`	`48`	`}`
`30`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,16 +13,14 @@ namespace CefSharp`
`13`	`13`	`/// </summary>`
`14`	`14`	`public class TaskSetCookieCallback : ISetCookieCallback`
`15`	`15`	`{`
`16`		`- private readonly TaskCompletionSource<bool> taskCompletionSource;`
	`16`	`+ private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();`
`17`	`17`	`private volatile bool isDisposed;`
`18`		`-`
`19`		`- public TaskSetCookieCallback()`
`20`		`- {`
`21`		`- taskCompletionSource = new TaskCompletionSource<bool>();`
`22`		`- }`
	`18`	`+ private bool complete; //Only ever accessed on the same CEF thread, so no need for thread safety`
`23`	`19`
`24`	`20`	`void ISetCookieCallback.OnComplete(bool success)`
`25`	`21`	`{`
	`22`	`+ complete = true;`
	`23`	`+`
`26`	`24`	`taskCompletionSource.TrySetResultAsync(success);`
`27`	`25`	`}`
`28`	`26`
`@@ -42,13 +40,12 @@ void IDisposable.Dispose()`
`42`	`40`
`43`	`41`	`//If the Task hasn't completed and this is being disposed then`
`44`	`42`	`//set the TCS to false`
`45`		`- if (task.IsCompleted == false)`
	`43`	`+ if (complete == false && task.IsCompleted == false)`
`46`	`44`	`{`
`47`	`45`	`taskCompletionSource.TrySetResultAsync(false);`
`48`	`46`	`}`
`49`	`47`
`50`	`48`	`isDisposed = true;`
`51`		`-`
`52`	`49`	`}`
`53`	`50`	`}`
`54`	`51`	`}`