#ifndef WorkQueue_h
#define WorkQueue_h
#include <chrono>
#include <functional>
#include <wtf/Forward.h>
#include <wtf/FunctionDispatcher.h>
#include <wtf/RefCounted.h>
#include <wtf/Threading.h>
#if OS(DARWIN)
#include <dispatch/dispatch.h>
#endif
#if PLATFORM(GTK)
#include <wtf/glib/GMainLoopSource.h>
#include <wtf/glib/GRefPtr.h>
#elif PLATFORM(EFL)
#include <DispatchQueueEfl.h>
#elif OS(WINDOWS)
#include <wtf/HashMap.h>
#include <wtf/Vector.h>
#include <wtf/win/WorkItemWin.h>
#endif
namespace WTF {
class WorkQueue final : public FunctionDispatcher {
public:
enum class Type {
Serial,
Concurrent
};
enum class QOS {
UserInteractive,
UserInitiated,
Default,
Utility,
Background
};
WTF_EXPORT_PRIVATE static Ref<WorkQueue> create(const char* name, Type = Type::Serial, QOS = QOS::Default);
virtual ~WorkQueue();
WTF_EXPORT_PRIVATE virtual void dispatch(std::function<void ()>) override;
WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, std::function<void ()>);
#if OS(DARWIN)
dispatch_queue_t dispatchQueue() const { return m_dispatchQueue; }
#elif PLATFORM(GTK)
void registerSocketEventHandler(int, std::function<void ()>, std::function<void ()>);
void unregisterSocketEventHandler(int);
#elif PLATFORM(EFL)
void registerSocketEventHandler(int, std::function<void ()>);
void unregisterSocketEventHandler(int);
#endif
private:
explicit WorkQueue(const char* name, Type, QOS);
void platformInitialize(const char* name, Type, QOS);
void platformInvalidate();
#if OS(WINDOWS)
static void CALLBACK handleCallback(void* context, BOOLEAN timerOrWaitFired);
static void CALLBACK timerCallback(void* context, BOOLEAN timerOrWaitFired);
static DWORD WINAPI workThreadCallback(void* context);
bool tryRegisterAsWorkThread();
void unregisterAsWorkThread();
void performWorkOnRegisteredWorkThread();
static void unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem>);
static DWORD WINAPI unregisterWaitAndDestroyItemCallback(void* context);
#endif
#if OS(DARWIN)
static void executeFunction(void*);
dispatch_queue_t m_dispatchQueue;
#elif PLATFORM(GTK)
ThreadIdentifier m_workQueueThread;
GRefPtr<GMainContext> m_eventContext;
GRefPtr<GMainLoop> m_eventLoop;
GMainLoopSource m_socketEventSource;
#elif PLATFORM(EFL)
RefPtr<DispatchQueue> m_dispatchQueue;
#elif OS(WINDOWS)
volatile LONG m_isWorkThreadRegistered;
Mutex m_workItemQueueLock;
Vector<RefPtr<WorkItemWin>> m_workItemQueue;
Mutex m_handlesLock;
HashMap<HANDLE, RefPtr<HandleWorkItem>> m_handles;
HANDLE m_timerQueue;
#endif
};
}
using WTF::WorkQueue;
#endif