#include "config.h"
#include <wtf/MainThread.h>
#include <mutex>
#include <wtf/Condition.h>
#include <wtf/Deque.h>
#include <wtf/Lock.h>
#include <wtf/MonotonicTime.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/RunLoop.h>
#include <wtf/StdLibExtras.h>
#include <wtf/Threading.h>
namespace WTF {
void initializeMainThread()
{
static std::once_flag initializeKey;
std::call_once(initializeKey, [] {
initialize();
initializeMainThreadPlatform();
RunLoop::initializeMain();
});
}
#if !USE(WEB_THREAD)
bool canCurrentThreadAccessThreadLocalData(Thread& thread)
{
return &thread == &Thread::current();
}
#endif
bool isMainRunLoop()
{
return RunLoop::isMain();
}
void callOnMainRunLoop(Function<void()>&& function)
{
RunLoop::main().dispatch(WTFMove(function));
}
void callOnMainThread(Function<void()>&& function)
{
#if USE(WEB_THREAD)
if (auto* webRunLoop = RunLoop::webIfExists()) {
webRunLoop->dispatch(WTFMove(function));
return;
}
#endif
RunLoop::main().dispatch(WTFMove(function));
}
bool isMainThreadOrGCThread()
{
if (Thread::mayBeGCThread())
return true;
return isMainThread();
}
enum class MainStyle : bool {
Thread,
RunLoop
};
static void callOnMainAndWait(WTF::Function<void()>&& function, MainStyle mainStyle)
{
if (mainStyle == MainStyle::Thread ? isMainThread() : isMainRunLoop()) {
function();
return;
}
Lock mutex;
Condition conditionVariable;
bool isFinished = false;
auto functionImpl = [&, function = WTFMove(function)] {
function();
auto locker = holdLock(mutex);
isFinished = true;
conditionVariable.notifyOne();
};
switch (mainStyle) {
case MainStyle::Thread:
callOnMainThread(WTFMove(functionImpl));
break;
case MainStyle::RunLoop:
callOnMainRunLoop(WTFMove(functionImpl));
};
std::unique_lock<Lock> lock(mutex);
conditionVariable.wait(lock, [&] {
return isFinished;
});
}
void callOnMainRunLoopAndWait(WTF::Function<void()>&& function)
{
callOnMainAndWait(WTFMove(function), MainStyle::RunLoop);
}
void callOnMainThreadAndWait(WTF::Function<void()>&& function)
{
callOnMainAndWait(WTFMove(function), MainStyle::Thread);
}
}