#include "config.h"
#include "WorkQueue.h"
#include <mach/mach_init.h>
#include <mach/mach_port.h>
#include <wtf/PassOwnPtr.h>
void WorkQueue::executeFunction(void* context)
{
WorkQueue* queue = static_cast<WorkQueue*>(dispatch_get_context(dispatch_get_current_queue()));
OwnPtr<Function<void()> > function = adoptPtr(static_cast<Function<void()>*>(context));
{
MutexLocker locker(queue->m_isValidMutex);
if (!queue->m_isValid)
return;
}
(*function)();
}
void WorkQueue::dispatch(const Function<void()>& function)
{
dispatch_async_f(m_dispatchQueue, new Function<void()>(function), executeFunction);
}
void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay)
{
dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_SEC);
dispatch_after_f(delayTime, m_dispatchQueue, new Function<void()>(function), executeFunction);
}
class WorkQueue::EventSource {
public:
EventSource(MachPortEventType eventType, dispatch_source_t dispatchSource, const Function<void()>& function)
: m_eventType(eventType)
, m_dispatchSource(dispatchSource)
, m_function(function)
{
}
dispatch_source_t dispatchSource() const { return m_dispatchSource; }
static void eventHandler(void* source)
{
EventSource* eventSource = static_cast<EventSource*>(source);
eventSource->m_function();
}
static void cancelHandler(void* source)
{
EventSource* eventSource = static_cast<EventSource*>(source);
mach_port_t machPort = dispatch_source_get_handle(eventSource->m_dispatchSource);
switch (eventSource->m_eventType) {
case MachPortDataAvailable:
mach_port_mod_refs(mach_task_self(), machPort, MACH_PORT_RIGHT_RECEIVE, -1);
break;
case MachPortDeadNameNotification:
mach_port_deallocate(mach_task_self(), machPort);
break;
}
}
static void finalizeHandler(void* source)
{
EventSource* eventSource = static_cast<EventSource*>(source);
delete eventSource;
}
private:
MachPortEventType m_eventType;
dispatch_source_t m_dispatchSource;
Function<void()> m_function;
};
void WorkQueue::registerMachPortEventHandler(mach_port_t machPort, MachPortEventType eventType, const Function<void()>& function)
{
dispatch_source_type_t sourceType = 0;
switch (eventType) {
case MachPortDataAvailable:
sourceType = DISPATCH_SOURCE_TYPE_MACH_RECV;
break;
case MachPortDeadNameNotification:
sourceType = DISPATCH_SOURCE_TYPE_MACH_SEND;
break;
}
dispatch_source_t dispatchSource = dispatch_source_create(sourceType, machPort, 0, m_dispatchQueue);
EventSource* eventSource = new EventSource(eventType, dispatchSource, function);
dispatch_set_context(dispatchSource, eventSource);
dispatch_source_set_event_handler_f(dispatchSource, &EventSource::eventHandler);
dispatch_source_set_cancel_handler_f(dispatchSource, &EventSource::cancelHandler);
dispatch_set_finalizer_f(dispatchSource, &EventSource::finalizeHandler);
{
MutexLocker locker(m_eventSourcesMutex);
ASSERT(!m_eventSources.contains(machPort));
m_eventSources.set(machPort, eventSource);
dispatch_resume(dispatchSource);
}
}
void WorkQueue::unregisterMachPortEventHandler(mach_port_t machPort)
{
ASSERT(machPort);
MutexLocker locker(m_eventSourcesMutex);
HashMap<mach_port_t, EventSource*>::iterator it = m_eventSources.find(machPort);
ASSERT(it != m_eventSources.end());
ASSERT(m_eventSources.contains(machPort));
EventSource* eventSource = it->second;
dispatch_source_cancel(eventSource->dispatchSource());
dispatch_release(eventSource->dispatchSource());
m_eventSources.remove(it);
}
void WorkQueue::platformInitialize(const char* name)
{
m_dispatchQueue = dispatch_queue_create(name, 0);
dispatch_set_context(m_dispatchQueue, this);
}
void WorkQueue::platformInvalidate()
{
#if !ASSERT_DISABLED
MutexLocker locker(m_eventSourcesMutex);
ASSERT(m_eventSources.isEmpty());
#endif
dispatch_release(m_dispatchQueue);
}