WebMessagePortChannelProvider.cpp [plain text]
#include "config.h"
#include "WebMessagePortChannelProvider.h"
#include "WebProcess.h"
#include "WebProcessProxyMessages.h"
#include <WebCore/MessagePort.h>
#include <WebCore/MessagePortIdentifier.h>
#include <WebCore/MessageWithMessagePorts.h>
namespace WebKit {
using namespace WebCore;
WebMessagePortChannelProvider& WebMessagePortChannelProvider::singleton()
{
static WebMessagePortChannelProvider* provider = new WebMessagePortChannelProvider;
return *provider;
}
WebMessagePortChannelProvider::WebMessagePortChannelProvider()
{
}
WebMessagePortChannelProvider::~WebMessagePortChannelProvider()
{
ASSERT_NOT_REACHED();
}
void WebMessagePortChannelProvider::createNewMessagePortChannel(const MessagePortIdentifier& port1, const MessagePortIdentifier& port2)
{
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::CreateNewMessagePortChannel(port1, port2), 0);
}
void WebMessagePortChannelProvider::entangleLocalPortInThisProcessToRemote(const MessagePortIdentifier& local, const MessagePortIdentifier& remote)
{
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::EntangleLocalPortInThisProcessToRemote(local, remote), 0);
}
void WebMessagePortChannelProvider::messagePortDisentangled(const MessagePortIdentifier& port)
{
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::MessagePortDisentangled(port), 0);
}
void WebMessagePortChannelProvider::messagePortClosed(const MessagePortIdentifier& port)
{
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::MessagePortClosed(port), 0);
}
void WebMessagePortChannelProvider::takeAllMessagesForPort(const MessagePortIdentifier& port, Function<void(Vector<MessageWithMessagePorts>&&, Function<void()>&&)>&& completionHandler)
{
static std::atomic<uint64_t> currentHandlerIdentifier;
uint64_t identifier = ++currentHandlerIdentifier;
{
Locker<Lock> locker(m_takeAllMessagesCallbackLock);
auto result = m_takeAllMessagesCallbacks.ensure(identifier, [completionHandler = WTFMove(completionHandler)]() mutable {
return WTFMove(completionHandler);
});
ASSERT_UNUSED(result, result.isNewEntry);
}
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::TakeAllMessagesForPort(port, identifier), 0);
}
void WebMessagePortChannelProvider::didTakeAllMessagesForPort(Vector<MessageWithMessagePorts>&& messages, uint64_t messageCallbackIdentifier, uint64_t messageBatchIdentifier)
{
ASSERT(isMainThread());
Locker<Lock> locker(m_takeAllMessagesCallbackLock);
auto callback = m_takeAllMessagesCallbacks.take(messageCallbackIdentifier);
locker.unlockEarly();
ASSERT(callback);
callback(WTFMove(messages), [messageBatchIdentifier] {
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::DidDeliverMessagePortMessages(messageBatchIdentifier), 0);
});
}
void WebMessagePortChannelProvider::didCheckRemotePortForActivity(uint64_t callbackIdentifier, bool hasActivity)
{
ASSERT(isMainThread());
Locker<Lock> locker(m_remoteActivityCallbackLock);
auto callback = m_remoteActivityCallbacks.take(callbackIdentifier);
locker.unlockEarly();
ASSERT(callback);
callback(hasActivity ? HasActivity::Yes : HasActivity::No);
}
void WebMessagePortChannelProvider::postMessageToRemote(MessageWithMessagePorts&& message, const MessagePortIdentifier& remoteTarget)
{
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::PostMessageToRemote(WTFMove(message), remoteTarget), 0);
}
void WebMessagePortChannelProvider::checkProcessLocalPortForActivity(const MessagePortIdentifier& identifier, uint64_t callbackIdentifier)
{
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::DidCheckProcessLocalPortForActivity { callbackIdentifier, MessagePort::isExistingMessagePortLocallyReachable(identifier) }, 0);
}
void WebMessagePortChannelProvider::checkProcessLocalPortForActivity(const MessagePortIdentifier&, ProcessIdentifier, CompletionHandler<void(HasActivity)>&&)
{
ASSERT_NOT_REACHED();
}
void WebMessagePortChannelProvider::checkRemotePortForActivity(const MessagePortIdentifier& remoteTarget, CompletionHandler<void(HasActivity)>&& completionHandler)
{
static std::atomic<uint64_t> currentHandlerIdentifier;
uint64_t identifier = ++currentHandlerIdentifier;
{
Locker<Lock> locker(m_remoteActivityCallbackLock);
auto result = m_remoteActivityCallbacks.ensure(identifier, [completionHandler = WTFMove(completionHandler)]() mutable {
return WTFMove(completionHandler);
});
ASSERT_UNUSED(result, result.isNewEntry);
}
WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::CheckRemotePortForActivity(remoteTarget, identifier), 0);
}
}