// 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>
|
/// TODO: This can likely be removed and code that depends on this can be moved
|
/// to CefSharp.Core and interact directly with the C++ api
|
public static class CefThread
|
{
|
private static readonly object LockObj = new object();
|
|
/// <summary>
|
/// TaskFactory will be null before Cef.Initialize is called
|
/// and null after Cef.Shutdown is called.
|
/// </summary>
|
public static TaskFactory UiThreadTaskFactory { get; private set; }
|
|
/// <summary>
|
/// Event fired after Cef.Initialze has been called, we can now start
|
/// posting Tasks to the CEF UI Thread.
|
/// </summary>
|
public static event EventHandler Initialized;
|
|
/// <summary>
|
/// Delegate used to wrap the native call to CefCurrentlyOn(CefThreadId::TID_UI).
|
/// </summary>
|
public static Func<bool> CurrentOnUiThreadDelegate { get; private 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;
|
}
|
}
|
|
/// <summary>
|
/// Currently on the CEF UI Thread
|
/// </summary>
|
public static bool CurrentlyOnUiThread
|
{
|
get
|
{
|
var d = CurrentOnUiThreadDelegate;
|
if (d == null)
|
{
|
return false;
|
}
|
|
return d();
|
}
|
}
|
|
/// <summary>
|
/// returns true if Cef.Shutdown been called, otherwise false.
|
/// </summary>
|
public static bool HasShutdown { get; private set; }
|
|
/// <summary>
|
/// Execute the provided function on the CEF UI Thread
|
/// </summary>
|
/// <typeparam name="TResult">result</typeparam>
|
/// <param name="function">function</param>
|
/// <returns>Task{Result}</returns>
|
public static Task<TResult> ExecuteOnUiThread<TResult>(Func<TResult> function)
|
{
|
lock (LockObj)
|
{
|
if (HasShutdown)
|
{
|
throw new Exception("Cef.Shutdown has already been called, it's no longer possible to execute on the CEF UI Thread. Check CefThread.HasShutdown to guard against this execption");
|
}
|
|
var taskFactory = UiThreadTaskFactory;
|
|
if (taskFactory == null)
|
{
|
//We don't have a task factory yet, so we'll queue for execution.
|
return QueueForExcutionWhenUiThreadCreated(function);
|
}
|
|
return taskFactory.StartNew(function);
|
}
|
}
|
|
/// <summary>
|
/// Execute the provided action on the CEF UI Thread
|
/// </summary>
|
/// <param name="action">action</param>
|
/// <returns>Task</returns>
|
public static Task ExecuteOnUiThread(Action action)
|
{
|
lock (LockObj)
|
{
|
if (HasShutdown)
|
{
|
throw new Exception("Cef.Shutdown has already been called, it's no longer possible to execute on the CEF UI Thread. Check CefThread.HasShutdown to guard against this execption");
|
}
|
|
var taskFactory = UiThreadTaskFactory;
|
|
if (taskFactory == null)
|
{
|
//We don't have a task factory yet, so we'll queue for execution.
|
return QueueForExcutionWhenUiThreadCreated(action);
|
}
|
|
return taskFactory.StartNew(action);
|
}
|
}
|
|
/// <summary>
|
/// Wait for CEF to Initialize, continuation happens on
|
/// the CEF UI Thraed.
|
/// </summary>
|
/// <returns>Task that can be awaited</returns>
|
private static Task QueueForExcutionWhenUiThreadCreated(Action action)
|
{
|
var tcs = new TaskCompletionSource<bool>();
|
|
EventHandler handler = null;
|
|
handler = (s, args) =>
|
{
|
Initialized -= handler;
|
|
try
|
{
|
//TODO: Should this call UiThreadTaskFactory.StartNew?
|
action();
|
|
tcs.TrySetResult(true);
|
}
|
catch(Exception ex)
|
{
|
tcs.TrySetException(ex);
|
}
|
};
|
|
Initialized += handler;
|
|
return tcs.Task;
|
}
|
|
/// <summary>
|
/// Wait for CEF to Initialize, continuation happens on
|
/// the CEF UI Thraed.
|
/// </summary>
|
/// <returns>Task that can be awaited</returns>
|
private static Task<T> QueueForExcutionWhenUiThreadCreated<T>(Func<T> func)
|
{
|
var tcs = new TaskCompletionSource<T>();
|
|
EventHandler handler = null;
|
|
handler = (s, args) =>
|
{
|
Initialized -= handler;
|
|
try
|
{
|
//TODO: Should this call UiThreadTaskFactory.StartNew?
|
var result = func();
|
|
tcs.TrySetResult(result);
|
}
|
catch(Exception ex)
|
{
|
tcs.TrySetException(ex);
|
}
|
};
|
|
Initialized += handler;
|
|
return tcs.Task;
|
}
|
|
/// <summary>
|
/// Called when the CEF UI Thread is a
|
/// </summary>
|
public static void Initialize(TaskFactory uiThreadTaskFactory, Func<bool> currentOnUiThreadDelegate)
|
{
|
lock (LockObj)
|
{
|
Initialized?.Invoke(null, EventArgs.Empty);
|
|
UiThreadTaskFactory = uiThreadTaskFactory;
|
CurrentOnUiThreadDelegate = currentOnUiThreadDelegate;
|
}
|
}
|
|
/// <summary>
|
/// !!WARNING!! DO NOT CALL THIS YOURSELF, THIS WILL BE CALLED INTERNALLY.
|
/// Called when Cef.Shutdown is called to cleanup our references
|
/// and release any event handlers.
|
/// </summary>
|
public static void Shutdown()
|
{
|
lock (LockObj)
|
{
|
CurrentOnUiThreadDelegate = null;
|
Initialized = null;
|
UiThreadTaskFactory = null;
|
HasShutdown = true;
|
}
|
}
|
}
|
}
|
