Diff
Modified: trunk/Source/WebKit/ChangeLog (273877 => 273878)
--- trunk/Source/WebKit/ChangeLog 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/ChangeLog 2021-03-04 09:09:40 UTC (rev 273878)
@@ -1,5 +1,46 @@
2021-03-04 Kimmo Kinnunen <kkinnu...@apple.com>
+ IPC stream feature should use client/server naming instead of sender/receiver
+ https://bugs.webkit.org/show_bug.cgi?id=222592
+
+ Reviewed by Antti Koivisto.
+
+ Attempt to simplify already complicated implementation of the stream
+ implementation. Uses of "sender" and "receiver" were a leftover from
+ early phase of the implementation.
+
+ Rename all remaining instances of "sender" with "client".
+ Rename all remaining instances of "receiver" with "server".
+
+ No new tests, a refactor.
+
+ * Platform/IPC/StreamClientConnection.cpp:
+ (IPC::StreamClientConnection::StreamClientConnection):
+ (IPC::StreamClientConnection::setWakeUpSemaphore):
+ (IPC::StreamClientConnection::wakeUpServer):
+ * Platform/IPC/StreamClientConnection.h:
+ (IPC::StreamClientConnection::send):
+ (IPC::StreamClientConnection::trySendDestinationIDIfNeeded):
+ (IPC::StreamClientConnection::tryAcquire):
+ (IPC::StreamClientConnection::release):
+ * Platform/IPC/StreamConnectionBuffer.cpp:
+ (IPC::StreamConnectionBuffer::StreamConnectionBuffer):
+ (IPC::StreamConnectionBuffer::operator=):
+ (IPC::StreamConnectionBuffer::encode const):
+ * Platform/IPC/StreamConnectionBuffer.h:
+ (IPC::StreamConnectionBuffer::clientOffset):
+ (IPC::StreamConnectionBuffer::serverOffset):
+ (IPC::StreamConnectionBuffer::clientWaitSemaphore):
+ (IPC::StreamConnectionBuffer::maximumSize):
+ * Platform/IPC/StreamServerConnection.cpp:
+ (IPC::StreamServerConnectionBase::tryAquire):
+ (IPC::StreamServerConnectionBase::release):
+ * Platform/IPC/StreamServerConnection.h:
+ (IPC::StreamServerConnectionBase::sharedClientOffset):
+ (IPC::StreamServerConnectionBase::sharedServerOffset):
+
+2021-03-04 Kimmo Kinnunen <kkinnu...@apple.com>
+
Adding new test conditions for WebGL should be simpler
https://bugs.webkit.org/show_bug.cgi?id=222593
Modified: trunk/Source/WebKit/Platform/IPC/StreamClientConnection.cpp (273877 => 273878)
--- trunk/Source/WebKit/Platform/IPC/StreamClientConnection.cpp 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/Platform/IPC/StreamClientConnection.cpp 2021-03-04 09:09:40 UTC (rev 273878)
@@ -33,9 +33,9 @@
, m_buffer(size)
{
// Read starts from 0 with limit of 0 and reader sleeping.
- sharedSenderOffset().store(StreamConnectionBuffer::senderOffsetReceiverIsSleepingTag, std::memory_order_relaxed);
+ sharedClientOffset().store(StreamConnectionBuffer::clientOffsetServerIsSleepingTag, std::memory_order_relaxed);
// Write starts from 0 with a limit of the whole buffer.
- sharedReceiverOffset().store(0, std::memory_order_relaxed);
+ sharedServerOffset().store(0, std::memory_order_relaxed);
}
void StreamClientConnection::setWakeUpSemaphore(IPC::Semaphore&& semaphore)
@@ -43,10 +43,10 @@
#if PLATFORM(COCOA)
m_wakeUpSemaphore = WTFMove(semaphore);
#endif
- wakeUpReceiver();
+ wakeUpServer();
}
-void StreamClientConnection::wakeUpReceiver()
+void StreamClientConnection::wakeUpServer()
{
#if PLATFORM(COCOA)
if (m_wakeUpSemaphore)
Modified: trunk/Source/WebKit/Platform/IPC/StreamClientConnection.h (273877 => 273878)
--- trunk/Source/WebKit/Platform/IPC/StreamClientConnection.h 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/Platform/IPC/StreamClientConnection.h 2021-03-04 09:09:40 UTC (rev 273878)
@@ -36,13 +36,13 @@
#include <wtf/Threading.h>
namespace IPC {
-// A message stream is a half-duplex two-way stream of messages to a between a sender and the
-// destination receiver.
+// A message stream is a half-duplex two-way stream of messages to a between the client and the
+// server.
//
// StreamClientConnection can send messages and receive synchronous replies
// through this message stream or through IPC::Connection.
//
-// The destination receiver will receive messages in order _for the destination messages_.
+// The server will receive messages in order _for the destination messages_.
// The whole IPC::Connection message order is not preserved.
//
// The StreamClientConnection trusts the StreamServerConnection.
@@ -71,12 +71,12 @@
void sendProcessOutOfStreamMessage(Span&&);
Optional<Span> tryAcquire(Timeout);
- enum class WakeUpReceiver : bool {
+ enum class WakeUpServer : bool {
No,
Yes
};
- WakeUpReceiver release(size_t writeSize);
- void wakeUpReceiver();
+ WakeUpServer release(size_t writeSize);
+ void wakeUpServer();
Span alignedSpan(size_t offset, size_t limit);
size_t size(size_t offset, size_t limit);
@@ -84,8 +84,8 @@
size_t wrapOffset(size_t offset) const { return m_buffer.wrapOffset(offset); }
size_t alignOffset(size_t offset) const { return m_buffer.alignOffset<messageAlignment>(offset, minimumMessageSize); }
- Atomic<size_t>& sharedSenderOffset() { return m_buffer.senderOffset(); }
- Atomic<size_t>& sharedReceiverOffset() { return m_buffer.receiverOffset(); }
+ Atomic<size_t>& sharedClientOffset() { return m_buffer.clientOffset(); }
+ Atomic<size_t>& sharedServerOffset() { return m_buffer.serverOffset(); }
uint8_t* data() const { return m_buffer.data(); }
size_t dataSize() const { return m_buffer.dataSize(); }
@@ -92,7 +92,7 @@
Connection& m_connection;
uint64_t m_currentDestinationID { 0 };
- size_t m_senderOffset { 0 };
+ size_t m_clientOffset { 0 };
StreamConnectionBuffer m_buffer;
#if PLATFORM(COCOA)
Optional<Semaphore> m_wakeUpSemaphore;
@@ -112,8 +112,8 @@
StreamConnectionEncoder messageEncoder { T::name(), span->data, span->size };
if (messageEncoder << message.arguments()) {
auto wakeupResult = release(messageEncoder.size());
- if (wakeupResult == StreamClientConnection::WakeUpReceiver::Yes)
- wakeUpReceiver();
+ if (wakeupResult == StreamClientConnection::WakeUpServer::Yes)
+ wakeUpServer();
return true;
}
}
@@ -153,8 +153,8 @@
return false;
}
auto wakeupResult = release(encoder.size());
- if (wakeupResult == StreamClientConnection::WakeUpReceiver::Yes)
- wakeUpReceiver();
+ if (wakeupResult == StreamClientConnection::WakeUpServer::Yes)
+ wakeUpServer();
m_currentDestinationID = destinationID;
return true;
}
@@ -169,18 +169,18 @@
inline Optional<StreamClientConnection::Span> StreamClientConnection::tryAcquire(Timeout timeout)
{
for (;;) {
- size_t senderLimit = clampedLimit(sharedReceiverOffset().load(std::memory_order_acquire));
- auto result = alignedSpan(m_senderOffset, senderLimit);
+ size_t clientLimit = clampedLimit(sharedServerOffset().load(std::memory_order_acquire));
+ auto result = alignedSpan(m_clientOffset, clientLimit);
if (result.size < minimumMessageSize) {
if (timeout.didTimeOut())
break;
#if PLATFORM(COCOA)
- size_t oldSenderLimit = sharedReceiverOffset().compareExchangeStrong(senderLimit, StreamConnectionBuffer::receiverOffsetSenderIsWaitingTag, std::memory_order_acq_rel, std::memory_order_acq_rel);
- if (senderLimit == oldSenderLimit)
- m_buffer.senderWaitSemaphore().waitFor(timeout);
+ size_t oldClientLimit = sharedServerOffset().compareExchangeStrong(clientLimit, StreamConnectionBuffer::serverOffsetClientIsWaitingTag, std::memory_order_acq_rel, std::memory_order_acq_rel);
+ if (clientLimit == oldClientLimit)
+ m_buffer.clientWaitSemaphore().waitFor(timeout);
else {
- senderLimit = clampedLimit(oldSenderLimit);
- result = alignedSpan(m_senderOffset, senderLimit);
+ clientLimit = clampedLimit(oldClientLimit);
+ result = alignedSpan(m_clientOffset, clientLimit);
}
#else
Thread::yield();
@@ -191,23 +191,23 @@
// The alignedSpan uses the minimumMessageSize to calculate the next beginning position in the buffer,
// and not the size. The size might be more or less what is needed, depending on where the reader is.
// If there is no capacity for minimum message size, wait until more is available.
- // In the case where senderOffset < receiverOffset we can arrive to a situation where
+ // In the case where clientOffset < serverOffset we can arrive to a situation where
// 0 < result.size < minimumMessageSize.
}
return WTF::nullopt;
}
-inline StreamClientConnection::WakeUpReceiver StreamClientConnection::release(size_t size)
+inline StreamClientConnection::WakeUpServer StreamClientConnection::release(size_t size)
{
size = std::max(size, minimumMessageSize);
- m_senderOffset = wrapOffset(alignOffset(m_senderOffset) + size);
- ASSERT(m_senderOffset < dataSize());
- // If the receiver wrote over the senderOffset with senderOffsetReceiverIsSleepingTag, we know it is sleeping.
- size_t receiverLimit = sharedSenderOffset().exchange(m_senderOffset, std::memory_order_acq_rel);
- if (receiverLimit == StreamConnectionBuffer::senderOffsetReceiverIsSleepingTag)
- return WakeUpReceiver::Yes;
- ASSERT(!(receiverLimit & StreamConnectionBuffer::senderOffsetReceiverIsSleepingTag));
- return WakeUpReceiver::No;
+ m_clientOffset = wrapOffset(alignOffset(m_clientOffset) + size);
+ ASSERT(m_clientOffset < dataSize());
+ // If the server wrote over the clientOffset with clientOffsetServerIsSleepingTag, we know it is sleeping.
+ size_t serverLimit = sharedClientOffset().exchange(m_clientOffset, std::memory_order_acq_rel);
+ if (serverLimit == StreamConnectionBuffer::clientOffsetServerIsSleepingTag)
+ return WakeUpServer::Yes;
+ ASSERT(!(serverLimit & StreamConnectionBuffer::clientOffsetServerIsSleepingTag));
+ return WakeUpServer::No;
}
inline StreamClientConnection::Span StreamClientConnection::alignedSpan(size_t offset, size_t limit)
Modified: trunk/Source/WebKit/Platform/IPC/StreamConnectionBuffer.cpp (273877 => 273878)
--- trunk/Source/WebKit/Platform/IPC/StreamConnectionBuffer.cpp 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/Platform/IPC/StreamConnectionBuffer.cpp 2021-03-04 09:09:40 UTC (rev 273878)
@@ -45,10 +45,10 @@
ASSERT(m_dataSize <= maximumSize());
}
-StreamConnectionBuffer::StreamConnectionBuffer(Ref<WebKit::SharedMemory>&& memory, size_t memorySize, Semaphore&& senderWaitSemaphore)
+StreamConnectionBuffer::StreamConnectionBuffer(Ref<WebKit::SharedMemory>&& memory, size_t memorySize, Semaphore&& clientWaitSemaphore)
: m_dataSize(memorySize - headerSize())
, m_sharedMemory(WTFMove(memory))
- , m_senderWaitSemaphore(WTFMove(senderWaitSemaphore))
+ , m_clientWaitSemaphore(WTFMove(clientWaitSemaphore))
{
ASSERT(m_dataSize <= maximumSize());
}
@@ -62,7 +62,7 @@
if (this != &other) {
m_dataSize = other.m_dataSize;
m_sharedMemory = WTFMove(other.m_sharedMemory);
- m_senderWaitSemaphore = WTFMove(other.m_senderWaitSemaphore);
+ m_clientWaitSemaphore = WTFMove(other.m_clientWaitSemaphore);
}
return *this;
}
@@ -74,7 +74,7 @@
CRASH();
WebKit::SharedMemory::IPCHandle ipcHandle { WTFMove(handle), m_sharedMemory->size() };
encoder << ipcHandle;
- encoder << m_senderWaitSemaphore;
+ encoder << m_clientWaitSemaphore;
}
Optional<StreamConnectionBuffer> StreamConnectionBuffer::decode(Decoder& decoder)
Modified: trunk/Source/WebKit/Platform/IPC/StreamConnectionBuffer.h (273877 => 273878)
--- trunk/Source/WebKit/Platform/IPC/StreamConnectionBuffer.h 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/Platform/IPC/StreamConnectionBuffer.h 2021-03-04 09:09:40 UTC (rev 273878)
@@ -33,36 +33,30 @@
namespace IPC {
-// StreamConnectionBuffer is a shared "bi-partite" circular buffer supporting
-// variable length messages, specific data alignment with mandated minimum size.
-// StreamClientConnection and StreamServerConnection use StreamConnectionBuffer to communicate.
+// StreamConnectionBuffer is a shared "bi-partite" circular buffer supporting variable length messages, specific data
+// alignment with mandated minimum size. StreamClientConnection and StreamServerConnection use StreamConnectionBuffer to
+// communicate.
//
-// The "bi-partite" is here to mean that writes and reads to the buffer must be
-// continuous.
+// The "bi-partite" is here to mean that writes and reads to the buffer must be continuous.
//
-// The client (sender or receiver) "acquires" some amount of buffer data. The data pointer
-// location depends on the amount of data being acquired. The buffer returns all the available
-// capacity -- this may be less than acquired.
+// The caller (client or server) "acquires" some amount of buffer data. The data pointer location depends on the amount
+// of data being acquired. The buffer returns all the available capacity -- this may be less than acquired.
//
-// The client "releases" the some amount of data, at least the amount acquired but potentially
-// more.
+// The caller "releases" the some amount of data, at least the amount acquired but potentially more.
//
-// Both sender and receiver must release the same amount of data at the same step of the acquire/release sequence.
-// Suppose sender releases first 8 and then 166 bytes. Upon the first acquire, receiver
-// must also release 8 bytes and then upon the second acquire 166 bytes.
-// Due to how alignment and minimum length affect the position at which the memory can
-// be referred to, the receiver cannot "read two times simultaneously" and release 174 bytes.
+// Both the client and the server must release the same amount of data at the same step of the acquire/release sequence.
+// Suppose the client releases first 8 and then 166 bytes. Upon the first acquire, the server must also release 8 bytes
+// and then upon the second acquire 166 bytes. Due to how alignment and minimum length affect the position at which the
+// memory can be referred to, the server cannot "read two times simultaneously" and release 174 bytes.
//
// The circular buffer has following implementation:
-// * Sender owns the data between [senderOffset, receiverOffset[. When senderOffset ==
-// receiverOffset, sender owns all the data.
-// * Receiver owns the data between [receiverOffset, senderOffset[.
-// * The buffer can hold maximum of size - 1 values. The last value is reserved for
-// indicating that the buffer is full. FIXME: Maybe would be simpler implementation if
-// it would use the "wrap" flag instead of the hole as the indicator. This would move
-// the alignedSpan implementation to the StreamConnectionBuffer.
-// * All atomic variable loads are untrusted, so they're clamped. Violations are not reported,
-// though.
+// * The client owns the data between [clientOffset, serverOffset[. When clientOffset == serverOffset, the client owns
+// all the data.
+// * The server owns the data between [serverOffset, clientOffset[.
+// * The buffer can hold maximum of size - 1 values. The last value is reserved for indicating that the buffer is full.
+// FIXME: Maybe would be simpler implementation if it would use the "wrap" flag instead of the hole as the indicator.
+// This would move the alignedSpan implementation to the StreamConnectionBuffer.
+// * All atomic variable loads are untrusted, so they're clamped. Violations are not reported, though.
// See SharedDisplayListHandle.
class StreamConnectionBuffer {
public:
@@ -88,30 +82,30 @@
return offset;
}
- Atomic<size_t>& senderOffset() { return header().senderOffset; }
- Atomic<size_t>& receiverOffset() { return header().receiverOffset; }
+ Atomic<size_t>& clientOffset() { return header().clientOffset; }
+ Atomic<size_t>& serverOffset() { return header().serverOffset; }
uint8_t* data() const { return static_cast<uint8_t*>(m_sharedMemory->data()) + headerSize(); }
size_t dataSize() const { return m_dataSize; }
- Semaphore& senderWaitSemaphore() { return m_senderWaitSemaphore; }
+ Semaphore& clientWaitSemaphore() { return m_clientWaitSemaphore; }
- // Tag value stored in Header::senderOffset when receiver is sleeping, e.g. not running.
- static constexpr size_t senderOffsetReceiverIsSleepingTag = 1 << 31;
- // Tag value stored in Header::receiverOffset when sender is waiting, e.g. waiting on
+ // Tag value stored in Header::clientOffset when the server is sleeping, e.g. not running.
+ static constexpr size_t clientOffsetServerIsSleepingTag = 1 << 31;
+ // Tag value stored in Header::serverOffset when the client is waiting, e.g. waiting on
// a semaphore.
- static constexpr size_t receiverOffsetSenderIsWaitingTag = 1 << 31;
+ static constexpr size_t serverOffsetClientIsWaitingTag = 1 << 31;
- static constexpr size_t maximumSize() { return std::min(senderOffsetReceiverIsSleepingTag, senderOffsetReceiverIsSleepingTag) - 1; }
+ static constexpr size_t maximumSize() { return std::min(clientOffsetServerIsSleepingTag, clientOffsetServerIsSleepingTag) - 1; }
void encode(Encoder&) const;
static Optional<StreamConnectionBuffer> decode(Decoder&);
private:
- StreamConnectionBuffer(Ref<WebKit::SharedMemory>&&, size_t memorySize, Semaphore&& senderWaitSemaphore);
+ StreamConnectionBuffer(Ref<WebKit::SharedMemory>&&, size_t memorySize, Semaphore&& clientWaitSemaphore);
struct Header {
- Atomic<size_t> receiverOffset;
+ Atomic<size_t> serverOffset;
// Padding so that the variables mostly accessed by different processes do not share a cache line.
// This is an attempt to avoid cache-line induced reduction of parallel access.
- alignas(sizeof(uint64_t[2])) Atomic<size_t> senderOffset;
+ alignas(sizeof(uint64_t[2])) Atomic<size_t> clientOffset;
};
Header& header() const { return *reinterpret_cast<Header*>(m_sharedMemory->data()); }
static constexpr size_t headerSize() { return roundUpToMultipleOf<alignof(std::max_align_t)>(sizeof(Header)); }
@@ -118,7 +112,7 @@
size_t m_dataSize { 0 };
Ref<WebKit::SharedMemory> m_sharedMemory;
- Semaphore m_senderWaitSemaphore;
+ Semaphore m_clientWaitSemaphore;
};
}
Modified: trunk/Source/WebKit/Platform/IPC/StreamServerConnection.cpp (273877 => 273878)
--- trunk/Source/WebKit/Platform/IPC/StreamServerConnection.cpp 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/Platform/IPC/StreamServerConnection.cpp 2021-03-04 09:09:40 UTC (rev 273878)
@@ -61,15 +61,15 @@
Optional<StreamServerConnectionBase::Span> StreamServerConnectionBase::tryAquire()
{
- size_t receiverLimit = sharedSenderOffset().load(std::memory_order_acquire);
- if (receiverLimit == StreamConnectionBuffer::senderOffsetReceiverIsSleepingTag)
+ size_t serverLimit = sharedClientOffset().load(std::memory_order_acquire);
+ if (serverLimit == StreamConnectionBuffer::clientOffsetServerIsSleepingTag)
return WTF::nullopt;
- auto result = alignedSpan(m_receiverOffset, receiverLimit);
+ auto result = alignedSpan(m_serverOffset, serverLimit);
if (result.size < minimumMessageSize) {
- receiverLimit = sharedSenderOffset().compareExchangeStrong(receiverLimit, StreamConnectionBuffer::senderOffsetReceiverIsSleepingTag, std::memory_order_acq_rel, std::memory_order_acq_rel);
- ASSERT(!(receiverLimit & StreamConnectionBuffer::senderOffsetReceiverIsSleepingTag));
- receiverLimit = clampedLimit(receiverLimit);
- result = alignedSpan(m_receiverOffset, receiverLimit);
+ serverLimit = sharedClientOffset().compareExchangeStrong(serverLimit, StreamConnectionBuffer::clientOffsetServerIsSleepingTag, std::memory_order_acq_rel, std::memory_order_acq_rel);
+ ASSERT(!(serverLimit & StreamConnectionBuffer::clientOffsetServerIsSleepingTag));
+ serverLimit = clampedLimit(serverLimit);
+ result = alignedSpan(m_serverOffset, serverLimit);
}
if (result.size >= minimumMessageSize)
@@ -81,21 +81,21 @@
{
ASSERT(readSize);
readSize = std::max(readSize, minimumMessageSize);
- size_t receiverOffset = wrapOffset(alignOffset(m_receiverOffset) + readSize);
+ size_t serverOffset = wrapOffset(alignOffset(m_serverOffset) + readSize);
#if PLATFORM(COCOA)
- size_t oldReceiverOffset = sharedReceiverOffset().exchange(receiverOffset, std::memory_order_acq_rel);
- // If the sender wrote over receiverOffset, it means the sender is waiting.
- if (oldReceiverOffset == StreamConnectionBuffer::receiverOffsetSenderIsWaitingTag)
- m_buffer.senderWaitSemaphore().signal();
+ size_t oldServerOffset = sharedServerOffset().exchange(serverOffset, std::memory_order_acq_rel);
+ // If the client wrote over serverOffset, it means the client is waiting.
+ if (oldServerOffset == StreamConnectionBuffer::serverOffsetClientIsWaitingTag)
+ m_buffer.clientWaitSemaphore().signal();
else
- ASSERT(!(oldReceiverOffset & StreamConnectionBuffer::receiverOffsetSenderIsWaitingTag));
+ ASSERT(!(oldServerOffset & StreamConnectionBuffer::serverOffsetClientIsWaitingTag));
#else
- sharedReceiverOffset().store(receiverOffset, std::memory_order_release);
+ sharedServerOffset().store(serverOffset, std::memory_order_release);
// IPC::Semaphore not implemented for the platform. Client will poll and yield.
#endif
- m_receiverOffset = receiverOffset;
+ m_serverOffset = serverOffset;
}
StreamServerConnectionBase::Span StreamServerConnectionBase::alignedSpan(size_t offset, size_t limit)
Modified: trunk/Source/WebKit/Platform/IPC/StreamServerConnection.h (273877 => 273878)
--- trunk/Source/WebKit/Platform/IPC/StreamServerConnection.h 2021-03-04 09:00:18 UTC (rev 273877)
+++ trunk/Source/WebKit/Platform/IPC/StreamServerConnection.h 2021-03-04 09:09:40 UTC (rev 273878)
@@ -77,8 +77,8 @@
size_t clampedLimit(size_t untrustedLimit) const;
size_t wrapOffset(size_t offset) const { return m_buffer.wrapOffset(offset); }
size_t alignOffset(size_t offset) const { return m_buffer.alignOffset<messageAlignment>(offset, minimumMessageSize); }
- Atomic<size_t>& sharedSenderOffset() { return m_buffer.senderOffset(); }
- Atomic<size_t>& sharedReceiverOffset() { return m_buffer.receiverOffset(); }
+ Atomic<size_t>& sharedClientOffset() { return m_buffer.clientOffset(); }
+ Atomic<size_t>& sharedServerOffset() { return m_buffer.serverOffset(); }
uint8_t* data() const { return m_buffer.data(); }
size_t dataSize() const { return m_buffer.dataSize(); }
@@ -85,7 +85,7 @@
Ref<IPC::Connection> m_connection;
StreamConnectionWorkQueue& m_workQueue;
- size_t m_receiverOffset { 0 };
+ size_t m_serverOffset { 0 };
StreamConnectionBuffer m_buffer;
Lock m_outOfStreamMessagesLock;
@@ -103,10 +103,11 @@
m_connection->sendSyncReply(WTFMove(encoder));
}
-// StreamServerConnection represents the connection between stream sender and receiver, as used by the receiver.
+// StreamServerConnection represents the connection between stream client and server, as used by the server.
+//
// StreamServerConnection:
-// * Holds the messages towards the receiver.
-// * Sends the replies back to the sender via the stream or normal Connection fallback.
+// * Holds the messages towards the server.
+// * Sends the replies back to the client via the stream or normal Connection fallback.
//
// Receiver template contract:
// void didReceiveStreamMessage(StreamServerConnectionBase&, Decoder&);
