#ifndef Connection_h
#define Connection_h
#include "ArgumentDecoder.h"
#include "ArgumentEncoder.h"
#include "Arguments.h"
#include "MessageID.h"
#include "WorkQueue.h"
#include <wtf/HashMap.h>
#include <wtf/PassRefPtr.h>
#include <wtf/OwnPtr.h>
#include <wtf/Threading.h>
#if OS(DARWIN)
#include <mach/mach_port.h>
#elif PLATFORM(WIN)
#include <string>
#elif PLATFORM(QT)
class QSocketNotifier;
#endif
#if PLATFORM(QT) || PLATFORM(GTK) || PLATFORM(EFL)
#include "PlatformProcessIdentifier.h"
#endif
namespace WebCore {
class RunLoop;
}
namespace CoreIPC {
class BinarySemaphore;
class MessageID;
enum MessageSendFlags {
DispatchMessageEvenWhenWaitingForSyncReply = 1 << 0,
};
enum SyncMessageSendFlags {
SpinRunLoopWhileWaitingForReply = 1 << 0,
};
#define MESSAGE_CHECK_BASE(assertion, connection) do \
if (!(assertion)) { \
ASSERT(assertion); \
(connection)->markCurrentlyDispatchedMessageAsInvalid(); \
return; \
} \
while (0)
class Connection : public ThreadSafeRefCounted<Connection> {
public:
class MessageReceiver {
public:
virtual void didReceiveMessage(Connection*, MessageID, ArgumentDecoder*) = 0;
virtual void didReceiveSyncMessage(Connection*, MessageID, ArgumentDecoder*, OwnPtr<ArgumentEncoder>&) { ASSERT_NOT_REACHED(); }
protected:
virtual ~MessageReceiver() { }
};
class Client : public MessageReceiver {
public:
virtual void didClose(Connection*) = 0;
virtual void didReceiveInvalidMessage(Connection*, MessageID) = 0;
#if PLATFORM(WIN)
virtual Vector<HWND> windowsToReceiveSentMessagesWhileWaitingForSyncReply() = 0;
#endif
protected:
virtual ~Client() { }
};
class QueueClient {
public:
virtual void didReceiveMessageOnConnectionWorkQueue(Connection*, MessageID, ArgumentDecoder*, bool& didHandleMessage) = 0;
protected:
virtual ~QueueClient() { }
};
#if OS(DARWIN)
typedef mach_port_t Identifier;
#elif PLATFORM(WIN)
typedef HANDLE Identifier;
static bool createServerAndClientIdentifiers(Identifier& serverIdentifier, Identifier& clientIdentifier);
#elif USE(UNIX_DOMAIN_SOCKETS)
typedef int Identifier;
#endif
static PassRefPtr<Connection> createServerConnection(Identifier, Client*, WebCore::RunLoop* clientRunLoop);
static PassRefPtr<Connection> createClientConnection(Identifier, Client*, WebCore::RunLoop* clientRunLoop);
~Connection();
#if OS(DARWIN)
void setShouldCloseConnectionOnMachExceptions();
#elif PLATFORM(QT)
void setShouldCloseConnectionOnProcessTermination(WebKit::PlatformProcessIdentifier);
#endif
void setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(bool);
void setShouldExitOnSyncMessageSendFailure(bool shouldExitOnSyncMessageSendFailure);
typedef void (*DidCloseOnConnectionWorkQueueCallback)(WorkQueue&, Connection*);
void setDidCloseOnConnectionWorkQueueCallback(DidCloseOnConnectionWorkQueueCallback callback);
void addQueueClient(QueueClient*);
void removeQueueClient(QueueClient*);
bool open();
void invalidate();
void markCurrentlyDispatchedMessageAsInvalid();
void postConnectionDidCloseOnConnectionWorkQueue();
static const int NoTimeout = -1;
template<typename T> bool send(const T& message, uint64_t destinationID, unsigned messageSendFlags = 0);
template<typename T> bool sendSync(const T& message, const typename T::Reply& reply, uint64_t destinationID, double timeout = NoTimeout, unsigned syncSendFlags = 0);
template<typename T> bool waitForAndDispatchImmediately(uint64_t destinationID, double timeout);
PassOwnPtr<ArgumentEncoder> createSyncMessageArgumentEncoder(uint64_t destinationID, uint64_t& syncRequestID);
bool sendMessage(MessageID, PassOwnPtr<ArgumentEncoder>, unsigned messageSendFlags = 0);
bool sendSyncReply(PassOwnPtr<ArgumentEncoder>);
template<typename E, typename T> bool deprecatedSend(E messageID, uint64_t destinationID, const T& arguments);
template<typename E, typename T, typename U> bool deprecatedSendSync(E messageID, uint64_t destinationID, const T& arguments, const U& reply, double timeout = NoTimeout);
void wakeUpRunLoop();
unsigned lastSentSyncMessageID() const { return m_lastSentSyncMessageID; }
private:
template<typename T> class Message {
public:
Message()
: m_arguments(0)
{
}
Message(MessageID messageID, PassOwnPtr<T> arguments)
: m_messageID(messageID)
, m_arguments(arguments.leakPtr())
{
}
MessageID messageID() const { return m_messageID; }
uint64_t destinationID() const { return m_arguments->destinationID(); }
T* arguments() const { return m_arguments; }
PassOwnPtr<T> releaseArguments()
{
OwnPtr<T> arguments = adoptPtr(m_arguments);
m_arguments = 0;
return arguments.release();
}
private:
MessageID m_messageID;
T* m_arguments;
};
public:
typedef Message<ArgumentEncoder> OutgoingMessage;
private:
Connection(Identifier, bool isServer, Client*, WebCore::RunLoop* clientRunLoop);
void platformInitialize(Identifier);
void platformInvalidate();
bool isValid() const { return m_client; }
PassOwnPtr<ArgumentDecoder> waitForMessage(MessageID, uint64_t destinationID, double timeout);
PassOwnPtr<ArgumentDecoder> sendSyncMessage(MessageID, uint64_t syncRequestID, PassOwnPtr<ArgumentEncoder>, double timeout, unsigned syncSendFlags = 0);
PassOwnPtr<ArgumentDecoder> waitForSyncReply(uint64_t syncRequestID, double timeout, unsigned syncSendFlags);
void processIncomingMessage(MessageID, PassOwnPtr<ArgumentDecoder>);
void processIncomingSyncReply(PassOwnPtr<ArgumentDecoder>);
void addQueueClientOnWorkQueue(QueueClient*);
void removeQueueClientOnWorkQueue(QueueClient*);
bool canSendOutgoingMessages() const;
bool platformCanSendOutgoingMessages() const;
void sendOutgoingMessages();
bool sendOutgoingMessage(MessageID, PassOwnPtr<ArgumentEncoder>);
void connectionDidClose();
typedef Message<ArgumentDecoder> IncomingMessage;
void dispatchConnectionDidClose();
void dispatchMessage(IncomingMessage&);
void dispatchOneMessage();
void dispatchSyncMessage(MessageID, ArgumentDecoder*);
void didFailToSendSyncMessage();
void enqueueIncomingMessage(IncomingMessage&);
Client* m_client;
bool m_isServer;
uint64_t m_syncRequestID;
unsigned m_lastSentSyncMessageID;
bool m_onlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage;
bool m_shouldExitOnSyncMessageSendFailure;
DidCloseOnConnectionWorkQueueCallback m_didCloseOnConnectionWorkQueueCallback;
bool m_isConnected;
WorkQueue m_connectionQueue;
WebCore::RunLoop* m_clientRunLoop;
Vector<QueueClient*> m_connectionQueueClients;
unsigned m_inDispatchMessageCount;
unsigned m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount;
bool m_didReceiveInvalidMessage;
Mutex m_incomingMessagesLock;
Deque<IncomingMessage> m_incomingMessages;
Mutex m_outgoingMessagesLock;
Deque<OutgoingMessage> m_outgoingMessages;
ThreadCondition m_waitForMessageCondition;
Mutex m_waitForMessageMutex;
HashMap<std::pair<unsigned, uint64_t>, ArgumentDecoder*> m_waitForMessageMap;
struct PendingSyncReply {
uint64_t syncRequestID;
ArgumentDecoder* replyDecoder;
bool didReceiveReply;
PendingSyncReply()
: syncRequestID(0)
, replyDecoder(0)
, didReceiveReply(false)
{
}
explicit PendingSyncReply(uint64_t syncRequestID)
: syncRequestID(syncRequestID)
, replyDecoder(0)
, didReceiveReply(0)
{
}
PassOwnPtr<ArgumentDecoder> releaseReplyDecoder()
{
OwnPtr<ArgumentDecoder> reply = adoptPtr(replyDecoder);
replyDecoder = 0;
return reply.release();
}
};
class SyncMessageState;
friend class SyncMessageState;
RefPtr<SyncMessageState> m_syncMessageState;
Mutex m_syncReplyStateMutex;
bool m_shouldWaitForSyncReplies;
Vector<PendingSyncReply> m_pendingSyncReplies;
#if OS(DARWIN)
void receiveSourceEventHandler();
void initializeDeadNameSource();
void exceptionSourceEventHandler();
mach_port_t m_sendPort;
mach_port_t m_receivePort;
mach_port_t m_exceptionPort;
#elif PLATFORM(WIN)
void readEventHandler();
void writeEventHandler();
static bool dispatchSentMessagesUntil(const Vector<HWND>& windows, CoreIPC::BinarySemaphore& semaphore, double absoluteTime);
Vector<uint8_t> m_readBuffer;
OVERLAPPED m_readState;
OwnPtr<ArgumentEncoder> m_pendingWriteArguments;
OVERLAPPED m_writeState;
HANDLE m_connectionPipe;
#elif USE(UNIX_DOMAIN_SOCKETS)
void readyReadHandler();
bool processMessage();
Vector<uint8_t> m_readBuffer;
size_t m_readBufferSize;
Vector<int> m_fileDescriptors;
size_t m_fileDescriptorsSize;
int m_socketDescriptor;
#if PLATFORM(QT)
QSocketNotifier* m_socketNotifier;
#endif
#endif
};
template<typename T> bool Connection::send(const T& message, uint64_t destinationID, unsigned messageSendFlags)
{
OwnPtr<ArgumentEncoder> argumentEncoder = ArgumentEncoder::create(destinationID);
argumentEncoder->encode(message);
return sendMessage(MessageID(T::messageID), argumentEncoder.release(), messageSendFlags);
}
template<typename T> bool Connection::sendSync(const T& message, const typename T::Reply& reply, uint64_t destinationID, double timeout, unsigned syncSendFlags)
{
uint64_t syncRequestID = 0;
OwnPtr<ArgumentEncoder> argumentEncoder = createSyncMessageArgumentEncoder(destinationID, syncRequestID);
argumentEncoder->encode(message);
OwnPtr<ArgumentDecoder> replyDecoder = sendSyncMessage(MessageID(T::messageID), syncRequestID, argumentEncoder.release(), timeout, syncSendFlags);
if (!replyDecoder)
return false;
return replyDecoder->decode(const_cast<typename T::Reply&>(reply));
}
template<typename T> bool Connection::waitForAndDispatchImmediately(uint64_t destinationID, double timeout)
{
OwnPtr<ArgumentDecoder> decoder = waitForMessage(MessageID(T::messageID), destinationID, timeout);
if (!decoder)
return false;
ASSERT(decoder->destinationID() == destinationID);
m_client->didReceiveMessage(this, MessageID(T::messageID), decoder.get());
return true;
}
template<typename E, typename T, typename U>
inline bool Connection::deprecatedSendSync(E messageID, uint64_t destinationID, const T& arguments, const U& reply, double timeout)
{
uint64_t syncRequestID = 0;
OwnPtr<ArgumentEncoder> argumentEncoder = createSyncMessageArgumentEncoder(destinationID, syncRequestID);
argumentEncoder->encode(arguments);
OwnPtr<ArgumentDecoder> replyDecoder = sendSyncMessage(MessageID(messageID), syncRequestID, argumentEncoder.release(), timeout);
if (!replyDecoder)
return false;
return replyDecoder->decode(const_cast<U&>(reply));
}
template<typename E, typename T>
bool Connection::deprecatedSend(E messageID, uint64_t destinationID, const T& arguments)
{
OwnPtr<ArgumentEncoder> argumentEncoder = ArgumentEncoder::create(destinationID);
argumentEncoder->encode(arguments);
return sendMessage(MessageID(messageID), argumentEncoder.release());
}
}
#endif // Connection_h