#include "config.h"
#include "MainThread.h"
#include "CurrentTime.h"
#include "Deque.h"
#include "Functional.h"
#include "StdLibExtras.h"
#include <mutex>
#include <wtf/NeverDestroyed.h>
#include <wtf/ThreadSpecific.h>
namespace WTF {
struct FunctionWithContext {
MainThreadFunction* function;
void* context;
FunctionWithContext(MainThreadFunction* function = nullptr, void* context = nullptr)
: function(function)
, context(context)
{
}
bool operator == (const FunctionWithContext& o)
{
return function == o.function && context == o.context;
}
};
class FunctionWithContextFinder {
public:
FunctionWithContextFinder(const FunctionWithContext& m) : m(m) {}
bool operator() (FunctionWithContext& o) { return o == m; }
FunctionWithContext m;
};
typedef Deque<FunctionWithContext> FunctionQueue;
static bool callbacksPaused; #if !OS(DARWIN) || PLATFORM(EFL) || PLATFORM(GTK)
static ThreadIdentifier mainThreadIdentifier;
#endif
static std::mutex& mainThreadFunctionQueueMutex()
{
static NeverDestroyed<std::mutex> mutex;
return mutex;
}
static FunctionQueue& functionQueue()
{
static NeverDestroyed<FunctionQueue> functionQueue;
return functionQueue;
}
#if !OS(DARWIN) || PLATFORM(EFL) || PLATFORM(GTK)
void initializeMainThread()
{
static bool initializedMainThread;
if (initializedMainThread)
return;
initializedMainThread = true;
mainThreadIdentifier = currentThread();
mainThreadFunctionQueueMutex();
initializeMainThreadPlatform();
initializeGCThreads();
}
#else
static pthread_once_t initializeMainThreadKeyOnce = PTHREAD_ONCE_INIT;
static void initializeMainThreadOnce()
{
mainThreadFunctionQueueMutex();
initializeMainThreadPlatform();
}
void initializeMainThread()
{
pthread_once(&initializeMainThreadKeyOnce, initializeMainThreadOnce);
}
#if !USE(WEB_THREAD)
static void initializeMainThreadToProcessMainThreadOnce()
{
mainThreadFunctionQueueMutex();
initializeMainThreadToProcessMainThreadPlatform();
}
void initializeMainThreadToProcessMainThread()
{
pthread_once(&initializeMainThreadKeyOnce, initializeMainThreadToProcessMainThreadOnce);
}
#else
static pthread_once_t initializeWebThreadKeyOnce = PTHREAD_ONCE_INIT;
static void initializeWebThreadOnce()
{
initializeWebThreadPlatform();
}
void initializeWebThread()
{
pthread_once(&initializeWebThreadKeyOnce, initializeWebThreadOnce);
}
#endif // !USE(WEB_THREAD)
#endif
static const auto maxRunLoopSuspensionTime = std::chrono::milliseconds(50);
void dispatchFunctionsFromMainThread()
{
ASSERT(isMainThread());
if (callbacksPaused)
return;
auto startTime = std::chrono::steady_clock::now();
FunctionWithContext invocation;
while (true) {
{
std::lock_guard<std::mutex> lock(mainThreadFunctionQueueMutex());
if (!functionQueue().size())
break;
invocation = functionQueue().takeFirst();
}
invocation.function(invocation.context);
if (std::chrono::steady_clock::now() - startTime > maxRunLoopSuspensionTime) {
scheduleDispatchFunctionsOnMainThread();
break;
}
}
}
void callOnMainThread(MainThreadFunction* function, void* context)
{
ASSERT(function);
bool needToSchedule = false;
{
std::lock_guard<std::mutex> lock(mainThreadFunctionQueueMutex());
needToSchedule = functionQueue().size() == 0;
functionQueue().append(FunctionWithContext(function, context));
}
if (needToSchedule)
scheduleDispatchFunctionsOnMainThread();
}
void cancelCallOnMainThread(MainThreadFunction* function, void* context)
{
ASSERT(function);
std::lock_guard<std::mutex> lock(mainThreadFunctionQueueMutex());
FunctionWithContextFinder pred(FunctionWithContext(function, context));
while (true) {
FunctionQueue::iterator i(functionQueue().findIf(pred));
if (i == functionQueue().end())
break;
functionQueue().remove(i);
}
}
static void callFunctionObject(void* context)
{
auto function = std::unique_ptr<std::function<void ()>>(static_cast<std::function<void ()>*>(context));
(*function)();
}
void callOnMainThread(std::function<void ()> function)
{
callOnMainThread(callFunctionObject, std::make_unique<std::function<void ()>>(WTF::move(function)).release());
}
void setMainThreadCallbacksPaused(bool paused)
{
ASSERT(isMainThread());
if (callbacksPaused == paused)
return;
callbacksPaused = paused;
if (!callbacksPaused)
scheduleDispatchFunctionsOnMainThread();
}
#if !OS(DARWIN) || PLATFORM(EFL) || PLATFORM(GTK)
bool isMainThread()
{
return currentThread() == mainThreadIdentifier;
}
#endif
#if !USE(WEB_THREAD)
bool canAccessThreadLocalDataForThread(ThreadIdentifier threadId)
{
return threadId == currentThread();
}
#endif
#if ENABLE(PARALLEL_GC)
static ThreadSpecific<bool>* isGCThread;
#endif
void initializeGCThreads()
{
#if ENABLE(PARALLEL_GC)
isGCThread = new ThreadSpecific<bool>();
#endif
}
#if ENABLE(PARALLEL_GC)
void registerGCThread()
{
if (!isGCThread) {
return;
}
**isGCThread = true;
}
bool isMainThreadOrGCThread()
{
if (isGCThread->isSet() && **isGCThread)
return true;
return isMainThread();
}
#elif OS(DARWIN) && !PLATFORM(EFL) && !PLATFORM(GTK)
bool isMainThreadOrGCThread()
{
return isMainThread();
}
#endif
}