ChildProcessProxy.h [plain text]
#ifndef ChildProcessProxy_h
#define ChildProcessProxy_h
#include "Connection.h"
#include "MessageReceiverMap.h"
#include "ProcessLauncher.h"
#include <wtf/ThreadSafeRefCounted.h>
namespace WebKit {
class ChildProcessProxy : ProcessLauncher::Client, public CoreIPC::Connection::Client, public ThreadSafeRefCounted<ChildProcessProxy> {
WTF_MAKE_NONCOPYABLE(ChildProcessProxy);
public:
ChildProcessProxy();
virtual ~ChildProcessProxy();
static ChildProcessProxy* fromConnection(CoreIPC::Connection*);
void connect();
void terminate();
template<typename T> bool send(const T& message, uint64_t destinationID, unsigned messageSendFlags = 0);
template<typename U> bool sendSync(const U& message, const typename U::Reply&, uint64_t destinationID, double timeout = 1);
CoreIPC::Connection* connection() const
{
ASSERT(m_connection);
return m_connection.get();
}
void addMessageReceiver(CoreIPC::StringReference messageReceiverName, CoreIPC::MessageReceiver*);
void addMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID, CoreIPC::MessageReceiver*);
void removeMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID);
bool isValid() const { return m_connection; }
bool isLaunching() const;
bool canSendMessage() const { return isValid() || isLaunching(); }
PlatformProcessIdentifier processIdentifier() const { return m_processLauncher->processIdentifier(); }
protected:
void clearConnection();
void abortProcessLaunchIfNeeded();
virtual void didFinishLaunching(ProcessLauncher*, CoreIPC::Connection::Identifier) OVERRIDE;
bool dispatchMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
bool dispatchSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);
private:
virtual void getLaunchOptions(ProcessLauncher::LaunchOptions&) = 0;
virtual void connectionWillOpen(CoreIPC::Connection*);
virtual void connectionWillClose(CoreIPC::Connection*);
bool sendMessage(PassOwnPtr<CoreIPC::MessageEncoder>, unsigned messageSendFlags);
Vector<std::pair<OwnPtr<CoreIPC::MessageEncoder>, unsigned>> m_pendingMessages;
RefPtr<ProcessLauncher> m_processLauncher;
RefPtr<CoreIPC::Connection> m_connection;
CoreIPC::MessageReceiverMap m_messageReceiverMap;
};
template<typename T>
bool ChildProcessProxy::send(const T& message, uint64_t destinationID, unsigned messageSendFlags)
{
COMPILE_ASSERT(!T::isSync, AsyncMessageExpected);
OwnPtr<CoreIPC::MessageEncoder> encoder = CoreIPC::MessageEncoder::create(T::receiverName(), T::name(), destinationID);
encoder->encode(message);
return sendMessage(encoder.release(), messageSendFlags);
}
template<typename U>
bool ChildProcessProxy::sendSync(const U& message, const typename U::Reply& reply, uint64_t destinationID, double timeout)
{
COMPILE_ASSERT(U::isSync, SyncMessageExpected);
if (!m_connection)
return false;
return connection()->sendSync(message, reply, destinationID, timeout);
}
}
#endif // ChildProcessProxy_h