Diff
Modified: trunk/Source/WebKit/ChangeLog (272915 => 272916)
--- trunk/Source/WebKit/ChangeLog 2021-02-16 18:08:10 UTC (rev 272915)
+++ trunk/Source/WebKit/ChangeLog 2021-02-16 18:47:56 UTC (rev 272916)
@@ -1,5 +1,54 @@
2021-02-16 Kimmo Kinnunen <kkinnu...@apple.com>
+ Connection clients should be able to obtain the messages as data instead of embedded in function references
+ https://bugs.webkit.org/show_bug.cgi?id=221560
+
+ Reviewed by Chris Dumez.
+
+ Add IPC::MessageReceiveQueue, an interface which obtains messages from
+ the message receive thread and forwards them to caller as data.
+ This is important in order to be able to skip messages that are stale
+ or originating from a sender which is incorrect. Before, the client
+ could only get the messages as Function references, and those cannot
+ be skipped as it would be undefined what not executing a function means.
+
+ IPC::MessageReceiveQueue is a generalization and simplification of current
+ IPC::Connection::ThreadMessageReceiverRefCounted and
+ IPC::Connection::WorkQueueMessageReceiver. It has different ref-count
+ semantics, in the way that client controls the life-time with add and
+ remove.
+
+ IPC::MessageReceiveQueue fixes message reordering bug with
+ WorkQueueMessageReceiver and ThreadMessageReceiver where first few messages
+ that are routed to main thread message queue can come later than some
+ other message that gets handled from message receive thread.
+
+ * Platform/IPC/Connection.cpp:
+ (IPC::Connection::addMessageReceiveQueue):
+ Add plain raw MessageReceiveQueue, to be used in WebGL IPC implementation.
+ Implement ThreadMessageReceiver and WorkQueueMessageReceiver with the
+ above.
+
+ (IPC::Connection::removeMessageReceiveQueue):
+ (IPC::Connection::dispatchMessageReceiverMessage):
+ (IPC::Connection::processIncomingMessage):
+ (IPC::Connection::enqueueIncomingMessage):
+ (IPC::Connection::dispatchMessage):
+ * Platform/IPC/Connection.h:
+ * Platform/IPC/MessageReceiveQueue.h: Copied from Source/WTF/wtf/FunctionDispatcher.h.
+ * Platform/IPC/MessageReceiveQueues.h: Added.
+ * Platform/IPC/MessageReceiveQueueMap.cpp: Added.
+ (IPC::MessageReceiveQueueMap::addImpl):
+ (IPC::MessageReceiveQueueMap::remove):
+ (IPC::MessageReceiveQueueMap::get const):
+ * Platform/IPC/MessageReceiveQueueMap.h: Copied from Source/WTF/wtf/FunctionDispatcher.h.
+ (IPC::MessageReceiveQueueMap::isValidMessage):
+ (IPC::MessageReceiveQueueMap::add):
+ * Sources.txt:
+ * WebKit.xcodeproj/project.pbxproj:
+
+2021-02-16 Kimmo Kinnunen <kkinnu...@apple.com>
+
RemoteAudioSourceProviderManager is accessed in non-thread-safe manner
https://bugs.webkit.org/show_bug.cgi?id=221894
Modified: trunk/Source/WebKit/Platform/IPC/Connection.cpp (272915 => 272916)
--- trunk/Source/WebKit/Platform/IPC/Connection.cpp 2021-02-16 18:08:10 UTC (rev 272915)
+++ trunk/Source/WebKit/Platform/IPC/Connection.cpp 2021-02-16 18:47:56 UTC (rev 272916)
@@ -28,6 +28,7 @@
#include "Logging.h"
#include "MessageFlags.h"
+#include "MessageReceiveQueues.h"
#include <memory>
#include <wtf/HashSet.h>
#include <wtf/Lock.h>
@@ -311,95 +312,72 @@
m_shouldExitOnSyncMessageSendFailure = shouldExitOnSyncMessageSendFailure;
}
-void Connection::addWorkQueueMessageReceiver(ReceiverName messageReceiverName, WorkQueue& workQueue, WorkQueueMessageReceiver* workQueueMessageReceiver, uint64_t destinationID)
+namespace {
+template <typename T>
+Deque<std::unique_ptr<Decoder>> filterWithMessageReceiveQueue(Connection& connection, T& receiveQueue, ReceiverName receiverName, uint64_t destinationID, Deque<std::unique_ptr<Decoder>>&& incomingMessages)
{
- ASSERT(RunLoop::isMain());
-
- auto locker = holdLock(m_workQueueMessageReceiversMutex);
- auto key = std::make_pair(static_cast<uint8_t>(messageReceiverName), destinationID);
- ASSERT(!m_workQueueMessageReceivers.contains(key));
-
- m_workQueueMessageReceivers.add(key, std::make_pair(&workQueue, workQueueMessageReceiver));
+ Deque<std::unique_ptr<Decoder>> rest;
+ for (auto& message : incomingMessages) {
+ if (message->messageReceiverName() == receiverName && (message->destinationID() == destinationID || !destinationID))
+ receiveQueue.enqueueMessage(connection, WTFMove(message));
+ else
+ rest.append(WTFMove(message));
+ }
+ return rest;
}
+}
-void Connection::removeWorkQueueMessageReceiver(ReceiverName messageReceiverName, uint64_t destinationID)
+void Connection::addMessageReceiveQueue(MessageReceiveQueue& receiveQueue, ReceiverName receiverName, uint64_t destinationID)
{
- ASSERT(RunLoop::isMain());
-
- auto locker = holdLock(m_workQueueMessageReceiversMutex);
- auto key = std::make_pair(static_cast<uint8_t>(messageReceiverName), destinationID);
- ASSERT(m_workQueueMessageReceivers.contains(key));
- m_workQueueMessageReceivers.remove(key);
+ auto locker = holdLock(m_incomingMessagesMutex);
+ m_incomingMessages = filterWithMessageReceiveQueue(*this, receiveQueue, receiverName, destinationID, WTFMove(m_incomingMessages));
+ m_receiveQueues.add(receiveQueue, receiverName, destinationID);
}
-void Connection::dispatchWorkQueueMessageReceiverMessage(WorkQueueMessageReceiver& workQueueMessageReceiver, Decoder& decoder)
+void Connection::addWorkQueueMessageReceiver(ReceiverName receiverName, WorkQueue& workQueue, WorkQueueMessageReceiver* receiver, uint64_t destinationID)
{
- if (!decoder.isSyncMessage()) {
- workQueueMessageReceiver.didReceiveMessage(*this, decoder);
- return;
- }
-
- uint64_t syncRequestID = 0;
- if (!decoder.decode(syncRequestID) || !syncRequestID) {
- // We received an invalid sync message.
- // FIXME: Handle this.
- decoder.markInvalid();
- return;
- }
-
- auto replyEncoder = makeUnique<Encoder>(MessageName::SyncMessageReply, syncRequestID);
-
- // Hand off both the decoder and encoder to the work queue message receiver.
- workQueueMessageReceiver.didReceiveSyncMessage(*this, decoder, replyEncoder);
-
- // FIXME: If the message was invalid, we should send back a SyncMessageError.
- ASSERT(decoder.isValid());
-
- if (replyEncoder)
- sendSyncReply(WTFMove(replyEncoder));
+ auto receiveQueue = makeUnique<WorkQueueMessageReceiverQueue>(workQueue, *receiver);
+ auto locker = holdLock(m_incomingMessagesMutex);
+ m_incomingMessages = filterWithMessageReceiveQueue(*this, *receiveQueue, receiverName, destinationID, WTFMove(m_incomingMessages));
+ m_receiveQueues.add(WTFMove(receiveQueue), receiverName, destinationID);
}
-void Connection::addThreadMessageReceiver(ReceiverName messageReceiverName, ThreadMessageReceiver* threadMessageReceiver, uint64_t destinationID)
+void Connection::addThreadMessageReceiver(ReceiverName receiverName, ThreadMessageReceiver* receiver, uint64_t destinationID)
{
- ASSERT(RunLoop::isMain());
-
- auto locker = holdLock(m_threadMessageReceiversLock);
- auto key = std::make_pair(static_cast<uint8_t>(messageReceiverName), destinationID);
- ASSERT(!m_threadMessageReceivers.contains(key));
-
- m_threadMessageReceivers.add(key, threadMessageReceiver);
+ auto receiveQueue = makeUnique<ThreadMessageReceiverQueue>(*receiver);
+ auto locker = holdLock(m_incomingMessagesMutex);
+ m_incomingMessages = filterWithMessageReceiveQueue(*this, *receiveQueue, receiverName, destinationID, WTFMove(m_incomingMessages));
+ m_receiveQueues.add(WTFMove(receiveQueue), receiverName, destinationID);
}
-void Connection::removeThreadMessageReceiver(ReceiverName messageReceiverName, uint64_t destinationID)
+void Connection::removeMessageReceiveQueue(ReceiverName receiverName, uint64_t destinationID)
{
- ASSERT(RunLoop::isMain());
-
- auto locker = holdLock(m_threadMessageReceiversLock);
- auto key = std::make_pair(static_cast<uint8_t>(messageReceiverName), destinationID);
- ASSERT(m_threadMessageReceivers.contains(key));
-
- m_threadMessageReceivers.remove(key);
+ auto locker = holdLock(m_incomingMessagesMutex);
+ m_receiveQueues.remove(receiverName, destinationID);
}
-void Connection::dispatchThreadMessageReceiverMessage(ThreadMessageReceiver& threadMessageReceiver, Decoder& decoder)
+void Connection::dispatchMessageReceiverMessage(MessageReceiver& messageReceiver, std::unique_ptr<Decoder>&& decoder)
{
- if (!decoder.isSyncMessage()) {
- threadMessageReceiver.didReceiveMessage(*this, decoder);
+ if (!decoder->isSyncMessage()) {
+ messageReceiver.didReceiveMessage(*this, *decoder);
return;
}
uint64_t syncRequestID = 0;
- if (!decoder.decode(syncRequestID) || !syncRequestID) {
- // FIXME: Handle invalid sync message.
- decoder.markInvalid();
+ if (!decoder->decode(syncRequestID) || !syncRequestID) {
+ // We received an invalid sync message.
+ // FIXME: Handle this.
+ decoder->markInvalid();
return;
}
auto replyEncoder = makeUnique<Encoder>(MessageName::SyncMessageReply, syncRequestID);
- threadMessageReceiver.didReceiveSyncMessage(*this, decoder, replyEncoder);
+ // Hand off both the decoder and encoder to the work queue message receiver.
+ messageReceiver.didReceiveSyncMessage(*this, *decoder, replyEncoder);
+
// FIXME: If the message was invalid, we should send back a SyncMessageError.
- ASSERT(decoder.isValid());
+ ASSERT(decoder->isValid());
if (replyEncoder)
sendSyncReply(WTFMove(replyEncoder));
@@ -731,8 +709,7 @@
return;
}
- auto threadedReceiverKey = std::make_pair(static_cast<uint8_t>(message->messageReceiverName()), message->destinationID());
- if (!WorkQueueMessageReceiverMap::isValidKey(threadedReceiverKey) || !ThreadMessageReceiverMap::isValidKey(threadedReceiverKey)) {
+ if (!MessageReceiveQueueMap::isValidMessage(*message)) {
RunLoop::main().dispatch([protectedThis = makeRef(*this), messageName = message->messageName()]() mutable {
protectedThis->dispatchDidReceiveInvalidMessage(messageName);
});
@@ -739,11 +716,14 @@
return;
}
- if (dispatchMessageToWorkQueueReceiver(message))
- return;
+ // FIXME: These are practically the same mutex, so maybe they could be merged.
+ auto waitForMessagesLocker = holdLock(m_waitForMessageMutex);
- if (dispatchMessageToThreadReceiver(message))
+ auto incomingMessagesLocker = holdLock(m_incomingMessagesMutex);
+ if (auto* receiveQueue = m_receiveQueues.get(*message)) {
+ receiveQueue->enqueueMessage(*this, WTFMove(message));
return;
+ }
if (message->isSyncMessage()) {
auto locker = holdLock(m_incomingSyncMessageCallbackMutex);
@@ -755,38 +735,34 @@
}
// Check if we're waiting for this message, or if we need to interrupt waiting due to an incoming sync message.
- {
- auto locker = holdLock(m_waitForMessageMutex);
+ if (m_waitingForMessage && !m_waitingForMessage->decoder) {
+ if (m_waitingForMessage->messageName == message->messageName() && m_waitingForMessage->destinationID == message->destinationID()) {
+ m_waitingForMessage->decoder = WTFMove(message);
+ ASSERT(m_waitingForMessage->decoder);
+ m_waitForMessageCondition.notifyOne();
+ return;
+ }
- if (m_waitingForMessage && !m_waitingForMessage->decoder) {
- if (m_waitingForMessage->messageName == message->messageName() && m_waitingForMessage->destinationID == message->destinationID()) {
- m_waitingForMessage->decoder = WTFMove(message);
- ASSERT(m_waitingForMessage->decoder);
- m_waitForMessageCondition.notifyOne();
- return;
- }
-
- if (m_waitingForMessage->waitForOptions.contains(WaitForOption::DispatchIncomingSyncMessagesWhileWaiting) && message->isSyncMessage() && SyncMessageState::singleton().processIncomingMessage(*this, message)) {
- m_waitForMessageCondition.notifyOne();
- return;
- }
-
- if (m_waitingForMessage->waitForOptions.contains(WaitForOption::InterruptWaitingIfSyncMessageArrives) && message->isSyncMessage()) {
- m_waitingForMessage->messageWaitingInterrupted = true;
- m_waitForMessageCondition.notifyOne();
- enqueueIncomingMessage(WTFMove(message));
- return;
- }
+ if (m_waitingForMessage->waitForOptions.contains(WaitForOption::DispatchIncomingSyncMessagesWhileWaiting) && message->isSyncMessage() && SyncMessageState::singleton().processIncomingMessage(*this, message)) {
+ m_waitForMessageCondition.notifyOne();
+ return;
}
- // Check if this is a sync message or if it's a message that should be dispatched even when waiting for
- // a sync reply. 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 (SyncMessageState::singleton().processIncomingMessage(*this, message))
+ if (m_waitingForMessage->waitForOptions.contains(WaitForOption::InterruptWaitingIfSyncMessageArrives) && message->isSyncMessage()) {
+ m_waitingForMessage->messageWaitingInterrupted = true;
+ m_waitForMessageCondition.notifyOne();
+ enqueueIncomingMessage(WTFMove(message));
return;
+ }
+ }
- enqueueIncomingMessage(WTFMove(message));
- }
+ // Check if this is a sync message or if it's a message that should be dispatched even when waiting for
+ // a sync reply. 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 (SyncMessageState::singleton().processIncomingMessage(*this, message))
+ return;
+
+ enqueueIncomingMessage(WTFMove(message));
}
uint64_t Connection::installIncomingSyncMessageCallback(WTF::Function<void ()>&& callback)
@@ -972,9 +948,8 @@
void Connection::enqueueIncomingMessage(std::unique_ptr<Decoder> incomingMessage)
{
+ ASSERT(m_incomingMessagesMutex.isHeld());
{
- auto locker = holdLock(m_incomingMessagesMutex);
-
#if PLATFORM(COCOA)
if (m_wasKilled)
return;
@@ -1032,67 +1007,6 @@
m_client.didReceiveMessage(*this, decoder);
}
-auto Connection::threadMessageReceiver(std::unique_ptr<Decoder>& message) -> RefPtr<ThreadMessageReceiver>
-{
- auto locker = holdLock(m_threadMessageReceiversLock);
-
- // First check if there is a global message receiver and return it if there is one.
- // This matches the behavior of MessageReceiverMap.
- auto key = std::make_pair(static_cast<uint8_t>(message->messageReceiverName()), 0);
- auto it = m_threadMessageReceivers.find(key);
- if (it != m_threadMessageReceivers.end())
- return it->value;
-
- if (auto destinationID = message->destinationID()) {
- key.second = destinationID;
- return m_threadMessageReceivers.get(key);
- }
-
- return nullptr;
-}
-
-auto Connection::workQueueMessageReceiver(std::unique_ptr<Decoder>& message) -> std::pair<RefPtr<WorkQueue>, RefPtr<WorkQueueMessageReceiver>>
-{
- auto locker = holdLock(m_workQueueMessageReceiversMutex);
-
- // First check if there is a global message receiver and return it if there is one.
- // This matches the behavior of MessageReceiverMap.
- auto key = std::make_pair(static_cast<uint8_t>(message->messageReceiverName()), 0);
- auto it = m_workQueueMessageReceivers.find(key);
- if (it != m_workQueueMessageReceivers.end())
- return it->value;
-
- if (auto destinationID = message->destinationID()) {
- key.second = destinationID;
- return m_workQueueMessageReceivers.get(key);
- }
-
- return { };
-}
-
-bool Connection::dispatchMessageToWorkQueueReceiver(std::unique_ptr<Decoder>& message)
-{
- auto receiver = workQueueMessageReceiver(message);
- if (!receiver.first)
- return false;
-
- receiver.first->dispatch([protectedThis = makeRef(*this), workQueueMessageReceiver = receiver.second, decoder = WTFMove(message)]() mutable {
- protectedThis->dispatchWorkQueueMessageReceiverMessage(*workQueueMessageReceiver, *decoder);
- });
- return true;
-}
-
-bool Connection::dispatchMessageToThreadReceiver(std::unique_ptr<Decoder>& message)
-{
- if (auto receiver = threadMessageReceiver(message)) {
- receiver->dispatchToThread([protectedThis = makeRef(*this), receiver, decoder = WTFMove(message)]() mutable {
- protectedThis->dispatchThreadMessageReceiverMessage(*receiver, *decoder);
- });
- return true;
- }
- return false;
-}
-
void Connection::dispatchMessage(std::unique_ptr<Decoder> message)
{
ASSERT(RunLoop::isMain());
@@ -1099,13 +1013,19 @@
if (!isValid())
return;
- // Messages to WorkQueueMessageReceivers are normally dispatched from the IPC WorkQueue. However, there is a race if
- // a client adds itself as a WorkQueueMessageReceiver as a result of receiving an IPC message on the main thread.
- // The message might have already been dispatched from the IPC WorkQueue to the main thread by the time the
- // client registers itself as a WorkQueueMessageReceiver. To address this, we check again for messages receivers
- // once the message arrives on the main thread.
- if (dispatchMessageToWorkQueueReceiver(message))
- return;
+ {
+ // FIXME: The matches here come from
+ // m_messagesToDispatchWhileWaitingForSyncReply. This causes message
+ // reordering, because some of the messages go to
+ // SyncState::m_messagesToDispatchWhileWaitingForSyncReply while others
+ // go to Connection::m_incomingMessages. Should be fixed by adding all
+ // messages to one list.
+ auto incomingMessagesLocker = holdLock(m_incomingMessagesMutex);
+ if (auto* receiveQueue = m_receiveQueues.get(*message)) {
+ receiveQueue->enqueueMessage(*this, WTFMove(message));
+ return;
+ }
+ }
if (message->shouldUseFullySynchronousModeForTesting()) {
if (!m_fullySynchronousModeIsAllowedForTesting) {
Modified: trunk/Source/WebKit/Platform/IPC/Connection.h (272915 => 272916)
--- trunk/Source/WebKit/Platform/IPC/Connection.h 2021-02-16 18:08:10 UTC (rev 272915)
+++ trunk/Source/WebKit/Platform/IPC/Connection.h 2021-02-16 18:47:56 UTC (rev 272916)
@@ -31,6 +31,7 @@
#include "Decoder.h"
#include "Encoder.h"
#include "HandleMessage.h"
+#include "MessageReceiveQueueMap.h"
#include "MessageReceiver.h"
#include <atomic>
#include <wtf/Condition.h>
@@ -214,11 +215,21 @@
typedef void (*DidCloseOnConnectionWorkQueueCallback)(Connection*);
void setDidCloseOnConnectionWorkQueueCallback(DidCloseOnConnectionWorkQueueCallback);
+ // Adds a message receive queue. The client should make sure the instance is removed before it goes
+ // out of scope.
+ void addMessageReceiveQueue(MessageReceiveQueue&, ReceiverName, uint64_t destinationID = 0);
+
+ void removeMessageReceiveQueue(ReceiverName, uint64_t destinationID = 0);
+
+ // Adds a message receieve queue that dispatches through WorkQueue to WorkQueueMessageReceiver.
+ // Keeps the WorkQueue and the WorkQueueMessageReceiver alive. Dispatched tasks keep WorkQueueMessageReceiver alive.
void addWorkQueueMessageReceiver(ReceiverName, WorkQueue&, WorkQueueMessageReceiver*, uint64_t destinationID = 0);
- void removeWorkQueueMessageReceiver(ReceiverName, uint64_t destinationID = 0);
+ void removeWorkQueueMessageReceiver(ReceiverName receiverName, uint64_t destinationID = 0) { removeMessageReceiveQueue(receiverName, destinationID); }
+ // Adds a message receieve queue that dispatches through ThreadMessageReceiver.
+ // Keeps the ThreadMessageReceiver alive. Dispatched tasks keep the ThreadMessageReceiver alive.
void addThreadMessageReceiver(ReceiverName, ThreadMessageReceiver*, uint64_t destinationID = 0);
- void removeThreadMessageReceiver(ReceiverName, uint64_t destinationID = 0);
+ void removeThreadMessageReceiver(ReceiverName receiverName, uint64_t destinationID = 0) { removeMessageReceiveQueue(receiverName, destinationID); }
bool open();
void invalidate();
@@ -300,6 +311,7 @@
bool ignoreInvalidMessageForTesting() const { return m_ignoreInvalidMessageForTesting; }
#endif
+ void dispatchMessageReceiverMessage(MessageReceiver&, std::unique_ptr<Decoder>&&);
private:
Connection(Identifier, bool isServer, Client&);
void platformInitialize(Identifier);
@@ -311,16 +323,10 @@
std::unique_ptr<Decoder> waitForSyncReply(uint64_t syncRequestID, MessageName, Seconds timeout, OptionSet<SendSyncOption>);
- bool dispatchMessageToWorkQueueReceiver(std::unique_ptr<Decoder>&);
- bool dispatchMessageToThreadReceiver(std::unique_ptr<Decoder>&);
-
// Called on the connection work queue.
void processIncomingMessage(std::unique_ptr<Decoder>);
void processIncomingSyncReply(std::unique_ptr<Decoder>);
- void dispatchWorkQueueMessageReceiverMessage(WorkQueueMessageReceiver&, Decoder&);
- void dispatchThreadMessageReceiverMessage(ThreadMessageReceiver&, Decoder&);
-
bool canSendOutgoingMessages() const;
bool platformCanSendOutgoingMessages() const;
void sendOutgoingMessages();
@@ -365,9 +371,6 @@
unsigned m_throttlingLevel { 0 };
};
- RefPtr<ThreadMessageReceiver> threadMessageReceiver(std::unique_ptr<Decoder>&);
- std::pair<RefPtr<WorkQueue>, RefPtr<WorkQueueMessageReceiver>> workQueueMessageReceiver(std::unique_ptr<Decoder>&);
-
Client& m_client;
UniqueID m_uniqueID;
bool m_isServer;
@@ -381,14 +384,6 @@
bool m_isConnected;
Ref<WorkQueue> m_connectionQueue;
- Lock m_workQueueMessageReceiversMutex;
- using WorkQueueMessageReceiverMap = HashMap<std::pair<uint8_t, uint64_t>, std::pair<RefPtr<WorkQueue>, RefPtr<WorkQueueMessageReceiver>>>;
- WorkQueueMessageReceiverMap m_workQueueMessageReceivers;
-
- Lock m_threadMessageReceiversLock;
- using ThreadMessageReceiverMap = HashMap<std::pair<uint8_t, uint64_t>, RefPtr<ThreadMessageReceiver>>;
- ThreadMessageReceiverMap m_threadMessageReceivers;
-
unsigned m_inSendSyncCount;
unsigned m_inDispatchMessageCount;
unsigned m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount;
@@ -401,6 +396,7 @@
Lock m_incomingMessagesMutex;
Deque<std::unique_ptr<Decoder>> m_incomingMessages;
std::unique_ptr<MessagesThrottler> m_incomingMessagesThrottler;
+ MessageReceiveQueueMap m_receiveQueues;
// Outgoing messages.
Lock m_outgoingMessagesMutex;
Added: trunk/Source/WebKit/Platform/IPC/MessageReceiveQueue.h (0 => 272916)
--- trunk/Source/WebKit/Platform/IPC/MessageReceiveQueue.h (rev 0)
+++ trunk/Source/WebKit/Platform/IPC/MessageReceiveQueue.h 2021-02-16 18:47:56 UTC (rev 272916)
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2012 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <memory>
+
+namespace IPC {
+
+class Connection;
+class Decoder;
+
+class MessageReceiveQueue {
+public:
+ virtual ~MessageReceiveQueue() = default;
+ // Called with Connection incoming message lock held.
+ // May be called from multiple threads.
+ virtual void enqueueMessage(Connection&, std::unique_ptr<Decoder>&&) = 0;
+};
+
+} // namespace IPC
Added: trunk/Source/WebKit/Platform/IPC/MessageReceiveQueueMap.cpp (0 => 272916)
--- trunk/Source/WebKit/Platform/IPC/MessageReceiveQueueMap.cpp (rev 0)
+++ trunk/Source/WebKit/Platform/IPC/MessageReceiveQueueMap.cpp 2021-02-16 18:47:56 UTC (rev 272916)
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "MessageReceiveQueueMap.h"
+
+namespace IPC {
+
+void MessageReceiveQueueMap::addImpl(StoreType&& queue, ReceiverName receiverName, uint64_t destinationID)
+{
+ auto key = std::make_pair(static_cast<uint8_t>(receiverName), destinationID);
+ ASSERT(!m_queues.contains(key));
+ m_queues.add(key, WTFMove(queue));
+}
+
+void MessageReceiveQueueMap::remove(ReceiverName receiverName, uint64_t destinationID)
+{
+ auto key = std::make_pair(static_cast<uint8_t>(receiverName), destinationID);
+ ASSERT(m_queues.contains(key));
+ m_queues.remove(key);
+}
+
+MessageReceiveQueue* MessageReceiveQueueMap::get(const Decoder& message) const
+{
+ if (m_queues.isEmpty())
+ return nullptr;
+ auto key = std::make_pair(static_cast<uint8_t>(message.messageReceiverName()), 0);
+ auto it = m_queues.find(key);
+ if (it == m_queues.end()) {
+ key.second = message.destinationID();
+ if (key.second)
+ it = m_queues.find(key);
+ }
+ if (it == m_queues.end())
+ return nullptr;
+ return WTF::visit(
+ WTF::makeVisitor(
+ [](const std::unique_ptr<MessageReceiveQueue>& queue) { return queue.get(); },
+ [](MessageReceiveQueue* queue) { return queue; }
+ ), it->value);
+}
+
+}
Added: trunk/Source/WebKit/Platform/IPC/MessageReceiveQueueMap.h (0 => 272916)
--- trunk/Source/WebKit/Platform/IPC/MessageReceiveQueueMap.h (rev 0)
+++ trunk/Source/WebKit/Platform/IPC/MessageReceiveQueueMap.h 2021-02-16 18:47:56 UTC (rev 272916)
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "Decoder.h"
+#include "MessageReceiveQueue.h"
+#include <wtf/HashMap.h>
+#include <wtf/Variant.h>
+
+namespace IPC {
+
+enum class ReceiverName : uint8_t;
+
+class MessageReceiveQueueMap {
+public:
+ MessageReceiveQueueMap() = default;
+ ~MessageReceiveQueueMap() = default;
+
+ static bool isValidMessage(const Decoder& message)
+ {
+ return QueueMap::isValidKey(std::make_pair(static_cast<uint8_t>(message.messageReceiverName()), message.destinationID()));
+ }
+
+ // Adds a wildcard filter if destinationID == 0.
+ void add(MessageReceiveQueue& queue, ReceiverName receiverName, uint64_t destinationID) { addImpl(StoreType(&queue), receiverName, destinationID); }
+ void add(std::unique_ptr<MessageReceiveQueue>&& queue, ReceiverName receiverName, uint64_t destinationID) { addImpl(StoreType(WTFMove(queue)), receiverName, destinationID); }
+ void remove(ReceiverName, uint64_t destinationID);
+
+ MessageReceiveQueue* get(const Decoder&) const;
+private:
+ using StoreType = Variant<MessageReceiveQueue*, std::unique_ptr<MessageReceiveQueue>>;
+ void addImpl(StoreType&&, ReceiverName, uint64_t destinationID);
+ using QueueMap = HashMap<std::pair<uint8_t, uint64_t>, StoreType>;
+ QueueMap m_queues;
+};
+
+} // namespace IPC
Added: trunk/Source/WebKit/Platform/IPC/MessageReceiveQueues.h (0 => 272916)
--- trunk/Source/WebKit/Platform/IPC/MessageReceiveQueues.h (rev 0)
+++ trunk/Source/WebKit/Platform/IPC/MessageReceiveQueues.h 2021-02-16 18:47:56 UTC (rev 272916)
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2012 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "Connection.h"
+#include "MessageReceiveQueue.h"
+
+namespace IPC {
+
+class FunctionDispatcherQueue final : public MessageReceiveQueue {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
+ FunctionDispatcherQueue(FunctionDispatcher& dispatcher, MessageReceiver& receiver)
+ : m_dispatcher(dispatcher)
+ , m_receiver(receiver)
+ {
+ }
+ ~FunctionDispatcherQueue() final = default;
+
+ void enqueueMessage(Connection& connection, std::unique_ptr<Decoder>&& message) final
+ {
+ m_dispatcher.dispatch([connection = makeRef(connection), message = WTFMove(message), &receiver = m_receiver]() mutable {
+ connection->dispatchMessageReceiverMessage(receiver, WTFMove(message));
+ });
+ }
+private:
+ FunctionDispatcher& m_dispatcher;
+ MessageReceiver& m_receiver;
+};
+
+class ThreadMessageReceiverQueue final : public MessageReceiveQueue {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
+ ThreadMessageReceiverQueue(Connection::ThreadMessageReceiver& receiver)
+ : m_receiver(makeRef(receiver))
+ {
+ }
+ ~ThreadMessageReceiverQueue() final = default;
+
+ void enqueueMessage(Connection& connection, std::unique_ptr<Decoder>&& message) final
+ {
+ m_receiver->dispatchToThread([connection = makeRef(connection), message = WTFMove(message), receiver = m_receiver]() mutable {
+ connection->dispatchMessageReceiverMessage(receiver.get(), WTFMove(message));
+ });
+ }
+private:
+ Ref<Connection::ThreadMessageReceiver> m_receiver;
+};
+
+class WorkQueueMessageReceiverQueue final : public MessageReceiveQueue {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
+ WorkQueueMessageReceiverQueue(WorkQueue& queue, Connection::WorkQueueMessageReceiver& receiver)
+ : m_queue(makeRef(queue))
+ , m_receiver(makeRef(receiver))
+ {
+ }
+ ~WorkQueueMessageReceiverQueue() final = default;
+
+ void enqueueMessage(Connection& connection, std::unique_ptr<Decoder>&& message) final
+ {
+ m_queue->dispatch([connection = makeRef(connection), message = WTFMove(message), receiver = m_receiver]() mutable {
+ connection->dispatchMessageReceiverMessage(receiver.get(), WTFMove(message));
+ });
+ }
+private:
+ Ref<WorkQueue> m_queue;
+ Ref<Connection::WorkQueueMessageReceiver> m_receiver;
+};
+
+} // namespace IPC
Modified: trunk/Source/WebKit/Sources.txt (272915 => 272916)
--- trunk/Source/WebKit/Sources.txt 2021-02-16 18:08:10 UTC (rev 272915)
+++ trunk/Source/WebKit/Sources.txt 2021-02-16 18:47:56 UTC (rev 272916)
@@ -145,6 +145,7 @@
Platform/IPC/Encoder.cpp @no-unify
Platform/IPC/IPCSemaphore.cpp @no-unify
Platform/IPC/JSIPCBinding.cpp @no-unify
+Platform/IPC/MessageReceiveQueueMap.cpp @no-unify
Platform/IPC/MessageReceiverMap.cpp @no-unify
Platform/IPC/MessageSender.cpp @no-unify
Platform/IPC/SharedBufferCopy.cpp @no-unify
Modified: trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj (272915 => 272916)
--- trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj 2021-02-16 18:08:10 UTC (rev 272915)
+++ trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj 2021-02-16 18:47:56 UTC (rev 272916)
@@ -1325,6 +1325,10 @@
7AFBD36721E51BAB005DBACB /* ResourceLoadStatisticsMemoryStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 7AFBD36521E51BAB005DBACB /* ResourceLoadStatisticsMemoryStore.h */; };
7AFBD36F21E546F8005DBACB /* PersistencyUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 7AFBD36D21E546E3005DBACB /* PersistencyUtils.h */; };
7B1DB26625668CE1000E26BC /* ArrayReference.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B1DB26525668CE0000E26BC /* ArrayReference.h */; };
+ 7B483F1F25CDDA9C00120486 /* MessageReceiveQueueMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B483F1B25CDDA9B00120486 /* MessageReceiveQueueMap.h */; };
+ 7B483F2025CDDA9C00120486 /* MessageReceiveQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B483F1C25CDDA9B00120486 /* MessageReceiveQueue.h */; };
+ 7B483F2125CDDA9C00120486 /* MessageReceiveQueueMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B483F1D25CDDA9B00120486 /* MessageReceiveQueueMap.cpp */; };
+ 7B483F2225CDDA9C00120486 /* MessageReceiveQueues.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B483F1E25CDDA9B00120486 /* MessageReceiveQueues.h */; };
7C065F2C1C8CD95F00C2D950 /* WebUserContentControllerDataTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C065F2A1C8CD95F00C2D950 /* WebUserContentControllerDataTypes.h */; };
7C135AA9173B0BCA00586AE2 /* WKPluginInformation.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C135AA7173B0BCA00586AE2 /* WKPluginInformation.h */; settings = {ATTRIBUTES = (Private, ); }; };
7C1BA33E1A4A0E600043E249 /* APIDictionary.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C1BA33C1A4A0E600043E249 /* APIDictionary.h */; };
@@ -4532,6 +4536,10 @@
7AFBD36D21E546E3005DBACB /* PersistencyUtils.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PersistencyUtils.h; sourceTree = "<group>"; };
7AFBD36E21E546E3005DBACB /* PersistencyUtils.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = PersistencyUtils.cpp; sourceTree = "<group>"; };
7B1DB26525668CE0000E26BC /* ArrayReference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArrayReference.h; sourceTree = "<group>"; };
+ 7B483F1B25CDDA9B00120486 /* MessageReceiveQueueMap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MessageReceiveQueueMap.h; sourceTree = "<group>"; };
+ 7B483F1C25CDDA9B00120486 /* MessageReceiveQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MessageReceiveQueue.h; sourceTree = "<group>"; };
+ 7B483F1D25CDDA9B00120486 /* MessageReceiveQueueMap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MessageReceiveQueueMap.cpp; sourceTree = "<group>"; };
+ 7B483F1E25CDDA9B00120486 /* MessageReceiveQueues.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MessageReceiveQueues.h; sourceTree = "<group>"; };
7B64C0B6254C5C250006B4AF /* GraphicsContextGLIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GraphicsContextGLIdentifier.h; sourceTree = "<group>"; };
7B904165254AFDEA006EEB8C /* RemoteGraphicsContextGLProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteGraphicsContextGLProxy.cpp; sourceTree = "<group>"; };
7B904166254AFDEB006EEB8C /* RemoteGraphicsContextGLProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteGraphicsContextGLProxy.h; sourceTree = "<group>"; };
@@ -6052,8 +6060,8 @@
1D32F89D23A84C5B00B1EA6A /* RemoteMediaResourceProxy.cpp */,
1D32F89B23A84BA600B1EA6A /* RemoteMediaResourceProxy.h */,
1DD2A646255F32B100FF7B6F /* RemoteMediaSourceIdentifier.h */,
+ CD8252D225D464AB00862FD8 /* RemoteRemoteCommandListener.cpp */,
CD8252D125D464AB00862FD8 /* RemoteRemoteCommandListener.h */,
- CD8252D225D464AB00862FD8 /* RemoteRemoteCommandListener.cpp */,
CD8252D325D464BF00862FD8 /* RemoteRemoteCommandListener.messages.in */,
CD8252D425D4651000862FD8 /* RemoteRemoteCommandListenerIdentifier.h */,
1DD2A63A255DE6D100FF7B6F /* SourceBufferPrivateRemote.cpp */,
@@ -6136,8 +6144,8 @@
1DD2A63F255E3F1F00FF7B6F /* RemoteMediaSourceProxy.cpp */,
1DD2A63E255E3F1F00FF7B6F /* RemoteMediaSourceProxy.h */,
1DD2A64A2560F54C00FF7B6F /* RemoteMediaSourceProxy.messages.in */,
+ CD8252D625D4763100862FD8 /* RemoteRemoteCommandListenerProxy.cpp */,
CD8252D525D4763100862FD8 /* RemoteRemoteCommandListenerProxy.h */,
- CD8252D625D4763100862FD8 /* RemoteRemoteCommandListenerProxy.cpp */,
CD8252D725D4765900862FD8 /* RemoteRemoteCommandListenerProxy.messages.in */,
1DD2A6682561F68400FF7B6F /* RemoteSourceBufferIdentifier.h */,
1DD2A643255E3F3D00FF7B6F /* RemoteSourceBufferProxy.cpp */,
@@ -6969,6 +6977,10 @@
9B47908E253151CC00EC11AB /* JSIPCBinding.h */,
9B47908C25314D8300EC11AB /* MessageArgumentDescriptions.h */,
1AC4C82816B876A90069DCCD /* MessageFlags.h */,
+ 7B483F1C25CDDA9B00120486 /* MessageReceiveQueue.h */,
+ 7B483F1D25CDDA9B00120486 /* MessageReceiveQueueMap.cpp */,
+ 7B483F1B25CDDA9B00120486 /* MessageReceiveQueueMap.h */,
+ 7B483F1E25CDDA9B00120486 /* MessageReceiveQueues.h */,
1A3EED11161A53D600AEB4F5 /* MessageReceiver.h */,
1A3EED0C161A535300AEB4F5 /* MessageReceiverMap.cpp */,
1A3EED0D161A535300AEB4F5 /* MessageReceiverMap.h */,
@@ -11795,6 +11807,9 @@
51933DEF1965EB31008AC3EA /* MenuUtilities.h in Headers */,
9B47908D25314D8300EC11AB /* MessageArgumentDescriptions.h in Headers */,
1AC4C82916B876A90069DCCD /* MessageFlags.h in Headers */,
+ 7B483F2025CDDA9C00120486 /* MessageReceiveQueue.h in Headers */,
+ 7B483F1F25CDDA9C00120486 /* MessageReceiveQueueMap.h in Headers */,
+ 7B483F2225CDDA9C00120486 /* MessageReceiveQueues.h in Headers */,
1A3EED12161A53D600AEB4F5 /* MessageReceiver.h in Headers */,
1A3EED0F161A535400AEB4F5 /* MessageReceiverMap.h in Headers */,
1AAB037A185A7C6A00EDF501 /* MessageSender.h in Headers */,
@@ -13789,6 +13804,7 @@
07E19EFB23D401F10094FFB4 /* MediaPlayerPrivateRemoteMessageReceiver.cpp in Sources */,
1DF29E64257F37A3003C28AF /* MediaSourcePrivateRemoteMessageReceiver.cpp in Sources */,
9B4790912531563200EC11AB /* MessageArgumentDescriptions.cpp in Sources */,
+ 7B483F2125CDDA9C00120486 /* MessageReceiveQueueMap.cpp in Sources */,
2D92A781212B6A7100F493FD /* MessageReceiverMap.cpp in Sources */,
2D92A782212B6A7100F493FD /* MessageSender.cpp in Sources */,
2D92A77A212B6A6100F493FD /* Module.cpp in Sources */,
@@ -13808,7 +13824,6 @@
51F060E11654318500F3281E /* NetworkRTCMonitorMessageReceiver.cpp in Sources */,
4176901422FDD41B00B1576D /* NetworkRTCProvider.mm in Sources */,
51F060E11654318500F3282E /* NetworkRTCProviderMessageReceiver.cpp in Sources */,
- CD8252DE25D4916C00862FD8 /* RemoteRemoteCommandListenerProxyMessageReceiver.cpp in Sources */,
31F060E11654318500F3281C /* NetworkSocketChannelMessageReceiver.cpp in Sources */,
5C0B17781E7C880E00E9123C /* NetworkSocketStreamMessageReceiver.cpp in Sources */,
2D92A790212B6AD400F493FD /* NPIdentifierData.cpp in Sources */,
@@ -13867,6 +13882,8 @@
1D4D737023A9E54700717A25 /* RemoteMediaResourceManagerMessageReceiver.cpp in Sources */,
1DD2A6632561246F00FF7B6F /* RemoteMediaSourceProxyMessageReceiver.cpp in Sources */,
1AC1338518590C4600F3EC05 /* RemoteObjectRegistryMessageReceiver.cpp in Sources */,
+ CD8252E225D4919100862FD8 /* RemoteRemoteCommandListenerMessageReceiver.cpp in Sources */,
+ CD8252DE25D4916C00862FD8 /* RemoteRemoteCommandListenerProxyMessageReceiver.cpp in Sources */,
0F5947A7187B517600437857 /* RemoteScrollingCoordinatorMessageReceiver.cpp in Sources */,
1DD2A66E2562021E00FF7B6F /* RemoteSourceBufferProxyMessageReceiver.cpp in Sources */,
A55BA8261BA25CFD007CD33D /* RemoteWebInspectorProxyMessageReceiver.cpp in Sources */,
@@ -13950,7 +13967,6 @@
2D11B78D2126A283006F8878 /* UnifiedSource31-mm.mm in Sources */,
2D11B78F2126A283006F8878 /* UnifiedSource32-mm.mm in Sources */,
2D11B7902126A283006F8878 /* UnifiedSource32.cpp in Sources */,
- CD8252E225D4919100862FD8 /* RemoteRemoteCommandListenerMessageReceiver.cpp in Sources */,
2D11B7912126A283006F8878 /* UnifiedSource33-mm.mm in Sources */,
2D11B7922126A283006F8878 /* UnifiedSource33.cpp in Sources */,
2D11B7942126A283006F8878 /* UnifiedSource34.cpp in Sources */,
