void Connection::dispatchSyncMessage(MessageID messageID, ArgumentDecoder* arguments)
{
ASSERT(messageID.isSync());
// Decode the sync request ID.
uint64_t syncRequestID = 0;
if (!arguments->decodeUInt64(syncRequestID) || !syncRequestID) {
// We received an invalid sync message.
arguments->markInvalid();
return;
}
// Create our reply encoder.
ArgumentEncoder* replyEncoder = ArgumentEncoder::create(syncRequestID).leakPtr();
// Hand off both the decoder and encoder to the client..
SyncReplyMode syncReplyMode = m_client->didReceiveSyncMessage(this, messageID, arguments, replyEncoder);
// FIXME: If the message was invalid, we should send back a SyncMessageError.
ASSERT(!arguments->isInvalid());
if (syncReplyMode == ManualReply) {
// The client will take ownership of the reply encoder and send it at some point in the future.
// We won't do anything here.
return;
}
// Send the reply.
sendSyncReply(replyEncoder);
}
void Connection::processIncomingMessage(MessageID messageID, PassOwnPtr<ArgumentDecoder> arguments)
{
// Check if this is a sync reply.
if (messageID == MessageID(CoreIPCMessage::SyncMessageReply)) {
MutexLocker locker(m_syncReplyStateMutex);
ASSERT(!m_pendingSyncReplies.isEmpty());
PendingSyncReply& pendingSyncReply = m_pendingSyncReplies.last();
ASSERT(pendingSyncReply.syncRequestID == arguments->destinationID());
pendingSyncReply.replyDecoder = arguments.leakPtr();
pendingSyncReply.didReceiveReply = true;
m_waitForSyncReplySemaphore.signal();
return;
}
// Check if this is a sync message. If it is, and we're waiting for a sync reply this message
// needs to be dispatched. If we don't we'll end up with a deadlock where both sync message senders are
// stuck waiting for a reply.
if (messageID.isSync()) {
MutexLocker locker(m_syncReplyStateMutex);
if (!m_pendingSyncReplies.isEmpty()) {
m_syncMessagesReceivedWhileWaitingForSyncReply.append(IncomingMessage(messageID, arguments));
// The message has been added, now wake up the client thread.
m_waitForSyncReplySemaphore.signal();
return;
}
}
// Check if we're waiting for this message.
{
MutexLocker locker(m_waitForMessageMutex);
HashMap<std::pair<unsigned, uint64_t>, ArgumentDecoder*>::iterator it = m_waitForMessageMap.find(std::make_pair(messageID.toInt(), arguments->destinationID()));
if (it != m_waitForMessageMap.end()) {
it->second = arguments.leakPtr();
m_waitForMessageCondition.signal();
return;
}
}
MutexLocker locker(m_incomingMessagesLock);
m_incomingMessages.append(IncomingMessage(messageID, arguments));
m_clientRunLoop->scheduleWork(WorkItem::create(this, &Connection::dispatchMessages));
}