#pragma once
#include <wtf/Assertions.h>
#include "Connection.h"
namespace IPC {
class MessageSender {
public:
virtual ~MessageSender();
template<typename U> bool send(const U& message, OptionSet<SendOption> sendOptions = { })
{
return send(message, messageSenderDestinationID(), sendOptions);
}
template<typename U> bool send(const U& message, uint64_t destinationID, OptionSet<SendOption> sendOptions = { })
{
static_assert(!U::isSync, "Message is sync!");
auto encoder = makeUnique<Encoder>(U::name(), destinationID);
encoder->encode(message.arguments());
return sendMessage(WTFMove(encoder), sendOptions);
}
template<typename U, typename T>
bool send(const U& message, ObjectIdentifier<T> destinationID, OptionSet<SendOption> sendOptions = { })
{
return send<U>(message, destinationID.toUInt64(), sendOptions);
}
using SendSyncResult = Connection::SendSyncResult;
template<typename T>
SendSyncResult sendSync(T&& message, typename T::Reply&& reply, Seconds timeout = Seconds::infinity(), OptionSet<SendSyncOption> sendSyncOptions = { })
{
static_assert(T::isSync, "Message is not sync!");
return sendSync(std::forward<T>(message), WTFMove(reply), messageSenderDestinationID(), timeout, sendSyncOptions);
}
template<typename T>
SendSyncResult sendSync(T&& message, typename T::Reply&& reply, uint64_t destinationID, Seconds timeout = Seconds::infinity(), OptionSet<SendSyncOption> sendSyncOptions = { })
{
if (auto* connection = messageSenderConnection())
return connection->sendSync(WTFMove(message), WTFMove(reply), destinationID, timeout, sendSyncOptions);
return { };
}
template<typename U, typename T>
SendSyncResult sendSync(U&& message, typename U::Reply&& reply, ObjectIdentifier<T> destinationID, Seconds timeout = Seconds::infinity(), OptionSet<SendSyncOption> sendSyncOptions = { })
{
return sendSync<U>(std::forward<U>(message), WTFMove(reply), destinationID.toUInt64(), timeout, sendSyncOptions);
}
template<typename T, typename C>
void sendWithAsyncReply(T&& message, C&& completionHandler, OptionSet<SendOption> sendOptions = { })
{
sendWithAsyncReply(WTFMove(message), WTFMove(completionHandler), messageSenderDestinationID(), sendOptions);
}
template<typename T, typename C>
void sendWithAsyncReply(T&& message, C&& completionHandler, uint64_t destinationID, OptionSet<SendOption> sendOptions = { })
{
COMPILE_ASSERT(!T::isSync, AsyncMessageExpected);
auto encoder = makeUnique<IPC::Encoder>(T::name(), destinationID);
uint64_t listenerID = IPC::nextAsyncReplyHandlerID();
encoder->encode(listenerID);
encoder->encode(message.arguments());
sendMessage(WTFMove(encoder), sendOptions, {{ [completionHandler = WTFMove(completionHandler)] (IPC::Decoder* decoder) mutable {
if (decoder && decoder->isValid())
T::callReply(*decoder, WTFMove(completionHandler));
else
T::cancelReply(WTFMove(completionHandler));
}, listenerID }});
}
virtual bool sendMessage(std::unique_ptr<Encoder>, OptionSet<SendOption>, Optional<std::pair<CompletionHandler<void(IPC::Decoder*)>, uint64_t>>&& = WTF::nullopt);
private:
virtual Connection* messageSenderConnection() const = 0;
virtual uint64_t messageSenderDestinationID() const = 0;
};
}