Core - Add ExecuteDevToolsMethodAsync extension method

ExecuteDevToolsMethod has to be called exclusively on the CEF UI thread.
This extension method will invoke into the CEF UI thread if required.

Author: amaitland

CefSharp.Core/Cef.h

@@ -55,6 +55,11 @@ namespace CefSharp
             _disposables = gcnew HashSet<IDisposable^>();
         }
 
+        static bool CurrentOnUiThread()
+        {
+            return CefCurrentlyOn(CefThreadId::TID_UI);
+        }
+
     public:
 
         static property TaskFactory^ UIThreadTaskFactory;
@@ -216,6 +221,10 @@ namespace CefSharp
             IOThreadTaskFactory = gcnew TaskFactory(gcnew CefTaskScheduler(TID_IO));
             FileThreadTaskFactory = gcnew TaskFactory(gcnew CefTaskScheduler(TID_FILE));
 
+            //Allows us to execute Tasks on the CEF UI thread in CefSharp.dll
+            CefThread::UiThreadTaskFactory = UIThreadTaskFactory;
+            CefThread::CurrentOnUiThreadDelegate = gcnew Func<bool>(&CurrentOnUiThread); ;
+
             //To allow FolderSchemeHandlerFactory to access GetMimeType we pass in a Func
             CefSharp::SchemeHandler::FolderSchemeHandlerFactory::GetMimeTypeDelegate = gcnew Func<String^, String^>(&GetMimeType);
 
@@ -472,6 +481,8 @@ namespace CefSharp
                     UIThreadTaskFactory = nullptr;
                     IOThreadTaskFactory = nullptr;
                     FileThreadTaskFactory = nullptr;
+                    CefThread::UiThreadTaskFactory = nullptr;
+                    CefThread::CurrentOnUiThreadDelegate = nullptr;
 
                     for each(IDisposable^ diposable in Enumerable::ToList(_disposables))
                     {

CefSharp/CefSharp.csproj

@@ -105,6 +105,8 @@
     <Compile Include="DefaultApp.cs" />
     <Compile Include="DevToolsExtensions.cs" />
     <Compile Include="Enums\SchemeOptions.cs" />
+    <Compile Include="Internals\CefThread.cs" />
+    <Compile Include="Internals\FreezableBase.cs" />
     <Compile Include="Internals\IBrowserRefCounter.cs" />
     <Compile Include="Internals\MimeTypeMapping.cs" />
     <Compile Include="IRegistration.cs" />

CefSharp/DevToolsExtensions.cs

@@ -2,6 +2,9 @@
 //
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CefSharp.Internals;
 using CefSharp.Web;
 
 namespace CefSharp
@@ -33,5 +36,72 @@ public static int ExecuteDevToolsMethod(this IBrowserHost browserHost, int messa
 
             return browserHost.ExecuteDevToolsMethod(messageId, method, json);
         }
+
+        /// <summary>
+        /// Execute a method call over the DevTools protocol. This is a more structured
+        /// version of SendDevToolsMessage. <see cref="ExecuteDevToolsMethod"/> can only be called on the
+        /// CEF UI Thread, this method can be called on any thread.
+        /// See the DevTools protocol documentation at https://chromedevtools.github.io/devtools-protocol/ for details
+        /// of supported methods and the expected <paramref name="parameters"/> dictionary contents.
+        /// See the SendDevToolsMessage documentation for additional usage information.
+        /// </summary>
+        /// <param name="browser">the browser instance</param>
+        /// <param name="messageId">is an incremental number that uniquely identifies the message (pass 0 to have the next number assigned
+        /// automatically based on previous values)</param>
+        /// <param name="method">is the method name</param>
+        /// <param name="parameters">are the method parameters represented as a dictionary,
+        /// which may be empty.</param>
+        /// <returns>return a Task that can be awaited to obtain the assigned message Id. If the message was
+        /// unsuccessfully submitted for validation, this value will be 0.</returns>
+        public static Task<int> ExecuteDevToolsMethodAsync(this IBrowser browser, int messageId, string method, IDictionary<string, object> parameters = null)
+        {
+            WebBrowserExtensions.ThrowExceptionIfBrowserNull(browser);
+
+            var browserHost = browser.GetHost();
+
+            WebBrowserExtensions.ThrowExceptionIfBrowserHostNull(browserHost);
+
+            if (CefThread.CurrentlyOnUiThread)
+            {
+                return Task.FromResult(browserHost.ExecuteDevToolsMethod(messageId, method, parameters));
+            }
+
+            if (CefThread.CanExecuteOnUiThread)
+            {
+                return CefThread.ExecuteOnUiThread(() =>
+                {
+                    return browserHost.ExecuteDevToolsMethod(messageId, method, parameters);
+                });
+            }
+
+            //CEF returns 0 to signify failure, we'll do the same.
+            return Task.FromResult(0);
+        }
+
+        /// <summary>
+        /// Execute a method call over the DevTools protocol. This is a more structured
+        /// version of SendDevToolsMessage. <see cref="ExecuteDevToolsMethod"/> can only be called on the
+        /// CEF UI Thread, this method can be called on any thread.
+        /// See the DevTools protocol documentation at https://chromedevtools.github.io/devtools-protocol/ for details
+        /// of supported methods and the expected <paramref name="parameters"/> dictionary contents.
+        /// See the SendDevToolsMessage documentation for additional usage information.
+        /// </summary>
+        /// <param name="chromiumWebBrowser">the ChromiumWebBrowser instance</param>
+        /// <param name="messageId">is an incremental number that uniquely identifies the message (pass 0 to have the next number assigned
+        /// automatically based on previous values)</param>
+        /// <param name="method">is the method name</param>
+        /// <param name="parameters">are the method parameters represented as a dictionary,
+        /// which may be empty.</param>
+        /// <returns>return a Task that can be awaited to obtain the assigned message Id. If the message was
+        /// unsuccessfully submitted for validation, this value will be 0.</returns>
+        public static Task<int> ExecuteDevToolsMethodAsync(this IWebBrowser chromiumWebBrowser, int messageId, string method, IDictionary<string, object> parameters = null)
+        {
+            chromiumWebBrowser.ThrowExceptionIfDisposed();
+            chromiumWebBrowser.ThrowExceptionIfBrowserNotInitialized();
+
+            var browser = chromiumWebBrowser.GetBrowser();
+
+            return browser.ExecuteDevToolsMethodAsync(messageId, method, parameters);
+        }
     }
 }

CefSharp/Internals/CefThread.cs

@@ -0,0 +1,66 @@
+// Copyright © 2020 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.Tasks;
+
+namespace CefSharp.Internals
+{
+    /// <summary>
+    /// To access the CEF threads we expose a TaskFactory, as this requires managed vc++ this
+    /// exists in CefSharp.Core it cannot be directly accessed in CefSharp.dll. When
+    /// Cef.Initialized is called we pass a reference to the TaskFactory here so we
+    /// can write methods (typically extension methods) in this assembly.
+    /// </summary>
+    public static class CefThread
+    {
+        /// <summary>
+        /// TaskFactory will be null before Cef.Initialize is called
+        /// and null after Cef.Shutdown is called.
+        /// </summary>
+        public static TaskFactory UiThreadTaskFactory { get; set; }
+
+        public static Func<bool> CurrentOnUiThreadDelegate { get; set; }
+
+        /// <summary>
+        /// true if we have a reference to the UiThreadTaskFactory
+        /// TaskFactory, otherwise false
+        /// </summary>
+        /// <remarks>
+        /// The current implementation isn't thread safe, generally speaking this shouldn't be a problem
+        /// </remarks>
+        public static bool CanExecuteOnUiThread
+        {
+            get
+            {
+                return UiThreadTaskFactory != null;
+            }
+        }
+
+        public static bool CurrentlyOnUiThread
+        {
+            get
+            {
+                if (CurrentOnUiThreadDelegate == null)
+                {
+                    return false;
+                }
+
+                return CurrentOnUiThreadDelegate();
+            }
+        }
+
+        public static Task<TResult> ExecuteOnUiThread<TResult>(Func<TResult> function)
+        {
+            var taskFactory = UiThreadTaskFactory;
+
+            if (taskFactory == null)
+            {
+                throw new Exception("CefThread.UiThreadTaskFactory is null, ");
+            }
+
+            return taskFactory.StartNew(function);
+        }
+    }
+}

CefSharp/WebBrowserExtensions.cs

@@ -1208,7 +1208,7 @@ private static void ThrowExceptionIfFrameNull(IFrame frame)
         /// </summary>
         /// <exception cref="Exception">Thrown when an exception error condition occurs.</exception>
         /// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>
-        private static void ThrowExceptionIfBrowserNull(this IBrowser browser)
+        internal static void ThrowExceptionIfBrowserNull(this IBrowser browser)
         {
             if (browser == null)
             {