#ifndef WorkQueue_h
#define WorkQueue_h
#if OS(DARWIN)
#if HAVE(DISPATCH_H)
#include <dispatch/dispatch.h>
#endif
#endif
#include <wtf/Forward.h>
#include <wtf/Functional.h>
#include <wtf/HashMap.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/Threading.h>
#include <wtf/Vector.h>
#if (PLATFORM(QT) && !OS(DARWIN)) || PLATFORM(GTK) || PLATFORM(EFL)
#include "PlatformProcessIdentifier.h"
#endif
#if PLATFORM(QT) && !OS(DARWIN)
#include <QSocketNotifier>
class QObject;
class QThread;
#elif PLATFORM(GTK)
#include <wtf/gobject/GRefPtr.h>
typedef gboolean (*GSourceFunc) (gpointer data);
#elif PLATFORM(EFL)
#include <Ecore.h>
#endif
class WorkQueue {
WTF_MAKE_NONCOPYABLE(WorkQueue);
public:
explicit WorkQueue(const char* name);
~WorkQueue();
void dispatch(const Function<void()>&);
void dispatchAfterDelay(const Function<void()>&, double delay);
void invalidate();
#if OS(DARWIN)
enum MachPortEventType {
MachPortDataAvailable,
MachPortDeadNameNotification
};
void registerMachPortEventHandler(mach_port_t, MachPortEventType, const Function<void()>&);
void unregisterMachPortEventHandler(mach_port_t);
#elif PLATFORM(WIN)
void registerHandle(HANDLE, const Function<void()>&);
void unregisterAndCloseHandle(HANDLE);
#elif PLATFORM(QT)
QSocketNotifier* registerSocketEventHandler(int, QSocketNotifier::Type, const Function<void()>&);
void dispatchOnTermination(WebKit::PlatformProcessIdentifier, const Function<void()>&);
#elif PLATFORM(GTK)
void registerEventSourceHandler(int, int, const Function<void()>&);
void unregisterEventSourceHandler(int);
void dispatchOnTermination(WebKit::PlatformProcessIdentifier, const Function<void()>&);
#elif PLATFORM(EFL)
void registerSocketEventHandler(int, const Function<void()>&);
void unregisterSocketEventHandler(int);
#endif
private:
Mutex m_isValidMutex;
bool m_isValid;
void platformInitialize(const char* name);
void platformInvalidate();
#if OS(DARWIN)
#if HAVE(DISPATCH_H)
static void executeFunction(void*);
Mutex m_eventSourcesMutex;
class EventSource;
HashMap<mach_port_t, EventSource*> m_eventSources;
dispatch_queue_t m_dispatchQueue;
#endif
#elif PLATFORM(WIN)
class WorkItemWin : public ThreadSafeRefCounted<WorkItemWin> {
public:
static PassRefPtr<WorkItemWin> create(const Function<void()>&, WorkQueue*);
virtual ~WorkItemWin();
Function<void()>& function() { return m_function; }
WorkQueue* queue() const { return m_queue; }
protected:
WorkItemWin(const Function<void()>&, WorkQueue*);
private:
Function<void()> m_function;
WorkQueue* m_queue;
};
class HandleWorkItem : public WorkItemWin {
public:
static PassRefPtr<HandleWorkItem> createByAdoptingHandle(HANDLE, const Function<void()>&, WorkQueue*);
virtual ~HandleWorkItem();
void setWaitHandle(HANDLE waitHandle) { m_waitHandle = waitHandle; }
HANDLE waitHandle() const { return m_waitHandle; }
private:
HandleWorkItem(HANDLE, const Function<void()>&, WorkQueue*);
HANDLE m_handle;
HANDLE m_waitHandle;
};
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);
volatile LONG m_isWorkThreadRegistered;
Mutex m_workItemQueueLock;
Vector<RefPtr<WorkItemWin> > m_workItemQueue;
Mutex m_handlesLock;
HashMap<HANDLE, RefPtr<HandleWorkItem> > m_handles;
HANDLE m_timerQueue;
#elif PLATFORM(QT)
class WorkItemQt;
QThread* m_workThread;
friend class WorkItemQt;
#elif PLATFORM(GTK)
static void startWorkQueueThread(WorkQueue*);
void workQueueThreadBody();
void dispatchOnSource(GSource*, const Function<void()>&, GSourceFunc);
ThreadIdentifier m_workQueueThread;
GRefPtr<GMainContext> m_eventContext;
Mutex m_eventLoopLock;
GRefPtr<GMainLoop> m_eventLoop;
Mutex m_eventSourcesLock;
class EventSource;
HashMap<int, Vector<EventSource*> > m_eventSources;
typedef HashMap<int, Vector<EventSource*> >::iterator EventSourceIterator;
#elif PLATFORM(EFL)
fd_set m_fileDescriptorSet;
int m_maxFileDescriptor;
int m_readFromPipeDescriptor;
int m_writeToPipeDescriptor;
bool m_threadLoop;
Vector<Function<void()> > m_workItemQueue;
Mutex m_workItemQueueLock;
int m_socketDescriptor;
Function<void()> m_socketEventHandler;
HashMap<int, OwnPtr<Ecore_Timer> > m_timers;
void sendMessageToThread(const char*);
static void* workQueueThread(WorkQueue*);
void performWork();
void performFileDescriptorWork();
static bool timerFired(void*);
#endif
};
#endif // WorkQueue_h