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 IPC::Connection::Client, public ThreadSafeRefCounted<ChildProcessProxy> {
WTF_MAKE_NONCOPYABLE(ChildProcessProxy);
public:
ChildProcessProxy();
virtual ~ChildProcessProxy();
static ChildProcessProxy* fromConnection(IPC::Connection*);
void connect();
void terminate();
template<typename T> bool send(T&& message, uint64_t destinationID, unsigned messageSendFlags = 0);
template<typename T> bool sendSync(T&& message, typename T::Reply&&, uint64_t destinationID, std::chrono::milliseconds timeout = std::chrono::seconds(1));
IPC::Connection* connection() const
{
ASSERT(m_connection);
return m_connection.get();
}
void addMessageReceiver(IPC::StringReference messageReceiverName, IPC::MessageReceiver&);
void addMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID, IPC::MessageReceiver&);
void removeMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID);
enum class State {
Launching,
Running,
Terminated,
};
State state() const;
PlatformProcessIdentifier processIdentifier() const { return m_processLauncher->processIdentifier(); }
bool canSendMessage() const { return state() != State::Terminated;}
bool sendMessage(std::unique_ptr<IPC::MessageEncoder>, unsigned messageSendFlags);
protected:
void clearConnection();
void abortProcessLaunchIfNeeded();
virtual void didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier) override;
bool dispatchMessage(IPC::Connection*, IPC::MessageDecoder&);
bool dispatchSyncMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
private:
virtual void getLaunchOptions(ProcessLauncher::LaunchOptions&) = 0;
virtual void connectionWillOpen(IPC::Connection*);
virtual void connectionWillClose(IPC::Connection*);
Vector<std::pair<std::unique_ptr<IPC::MessageEncoder>, unsigned>> m_pendingMessages;
RefPtr<ProcessLauncher> m_processLauncher;
RefPtr<IPC::Connection> m_connection;
IPC::MessageReceiverMap m_messageReceiverMap;
};
template<typename T>
bool ChildProcessProxy::send(T&& message, uint64_t destinationID, unsigned messageSendFlags)
{
COMPILE_ASSERT(!T::isSync, AsyncMessageExpected);
auto encoder = std::make_unique<IPC::MessageEncoder>(T::receiverName(), T::name(), destinationID);
encoder->encode(message.arguments());
return sendMessage(WTF::move(encoder), messageSendFlags);
}
template<typename U>
bool ChildProcessProxy::sendSync(U&& message, typename U::Reply&& reply, uint64_t destinationID, std::chrono::milliseconds timeout)
{
COMPILE_ASSERT(U::isSync, SyncMessageExpected);
if (!m_connection)
return false;
return connection()->sendSync(std::forward<U>(message), WTF::move(reply), destinationID, timeout);
}
}
#endif // ChildProcessProxy_h