WebSocketChannel.h [plain text]
#pragma once
#include "FileReaderLoaderClient.h"
#include "SocketStreamHandleClient.h"
#include "ThreadableWebSocketChannel.h"
#include "Timer.h"
#include "WebSocketDeflateFramer.h"
#include "WebSocketFrame.h"
#include "WebSocketHandshake.h"
#include <wtf/Deque.h>
#include <wtf/Forward.h>
#include <wtf/RefCounted.h>
#include <wtf/TypeCasts.h>
#include <wtf/Vector.h>
#include <wtf/text/CString.h>
namespace WebCore {
class Blob;
class Document;
class FileReaderLoader;
class ResourceRequest;
class ResourceResponse;
class SocketProvider;
class SocketStreamHandle;
class SocketStreamError;
class WebSocketChannelClient;
class WebSocketChannel : public RefCounted<WebSocketChannel>, public SocketStreamHandleClient, public ThreadableWebSocketChannel, public FileReaderLoaderClient
{
WTF_MAKE_FAST_ALLOCATED;
public:
static Ref<WebSocketChannel> create(Document& document, WebSocketChannelClient& client, SocketProvider& provider) { return adoptRef(*new WebSocketChannel(document, client, provider)); }
virtual ~WebSocketChannel();
bool isWebSocketChannel() const final { return true; }
bool send(const char* data, int length);
void connect(const URL&, const String& protocol) override;
String subprotocol() override;
String extensions() override;
ThreadableWebSocketChannel::SendResult send(const String& message) override;
ThreadableWebSocketChannel::SendResult send(const JSC::ArrayBuffer&, unsigned byteOffset, unsigned byteLength) override;
ThreadableWebSocketChannel::SendResult send(Blob&) override;
unsigned bufferedAmount() const override;
void close(int code, const String& reason) override; void fail(const String& reason) override;
void disconnect() override;
void suspend() override;
void resume() override;
void didOpenSocketStream(SocketStreamHandle&) final;
void didCloseSocketStream(SocketStreamHandle&) final;
void didReceiveSocketStreamData(SocketStreamHandle&, const char*, size_t) final;
void didFailToReceiveSocketStreamData(SocketStreamHandle&) final;
void didUpdateBufferedAmount(SocketStreamHandle&, size_t bufferedAmount) final;
void didFailSocketStream(SocketStreamHandle&, const SocketStreamError&) final;
enum CloseEventCode {
CloseEventCodeNotSpecified = -1,
CloseEventCodeNormalClosure = 1000,
CloseEventCodeGoingAway = 1001,
CloseEventCodeProtocolError = 1002,
CloseEventCodeUnsupportedData = 1003,
CloseEventCodeFrameTooLarge = 1004,
CloseEventCodeNoStatusRcvd = 1005,
CloseEventCodeAbnormalClosure = 1006,
CloseEventCodeInvalidFramePayloadData = 1007,
CloseEventCodePolicyViolation = 1008,
CloseEventCodeMessageTooBig = 1009,
CloseEventCodeMandatoryExt = 1010,
CloseEventCodeInternalError = 1011,
CloseEventCodeTLSHandshake = 1015,
CloseEventCodeMinimumUserDefined = 3000,
CloseEventCodeMaximumUserDefined = 4999
};
void didStartLoading() override;
void didReceiveData() override;
void didFinishLoading() override;
void didFail(int errorCode) override;
unsigned identifier() const { return m_identifier; }
ResourceRequest clientHandshakeRequest();
const ResourceResponse& serverHandshakeResponse() const;
WebSocketHandshake::Mode handshakeMode() const;
using RefCounted<WebSocketChannel>::ref;
using RefCounted<WebSocketChannel>::deref;
protected:
void refThreadableWebSocketChannel() override { ref(); }
void derefThreadableWebSocketChannel() override { deref(); }
private:
WEBCORE_EXPORT WebSocketChannel(Document&, WebSocketChannelClient&, SocketProvider&);
bool appendToBuffer(const char* data, size_t len);
void skipBuffer(size_t len);
bool processBuffer();
void resumeTimerFired();
void startClosingHandshake(int code, const String& reason);
void closingTimerFired();
bool processFrame();
enum QueuedFrameType {
QueuedFrameTypeString,
QueuedFrameTypeVector,
QueuedFrameTypeBlob
};
struct QueuedFrame {
WebSocketFrame::OpCode opCode;
QueuedFrameType frameType;
CString stringData;
Vector<char> vectorData;
RefPtr<Blob> blobData;
};
void enqueueTextFrame(const CString&);
void enqueueRawFrame(WebSocketFrame::OpCode, const char* data, size_t dataLength);
void enqueueBlobFrame(WebSocketFrame::OpCode, Blob&);
void processOutgoingFrameQueue();
void abortOutgoingFrameQueue();
enum OutgoingFrameQueueStatus {
OutgoingFrameQueueOpen,
OutgoingFrameQueueClosing,
OutgoingFrameQueueClosed
};
void sendFrame(WebSocketFrame::OpCode, const char* data, size_t dataLength, WTF::Function<void(bool)> completionHandler);
enum BlobLoaderStatus {
BlobLoaderNotStarted,
BlobLoaderStarted,
BlobLoaderFinished,
BlobLoaderFailed
};
Document* m_document;
WebSocketChannelClient* m_client;
std::unique_ptr<WebSocketHandshake> m_handshake;
RefPtr<SocketStreamHandle> m_handle;
Vector<char> m_buffer;
Timer m_resumeTimer;
bool m_suspended { false };
bool m_closing { false };
bool m_receivedClosingHandshake { false };
Timer m_closingTimer;
bool m_closed { false };
bool m_shouldDiscardReceivedData { false };
unsigned m_unhandledBufferedAmount { 0 };
unsigned m_identifier { 0 };
bool m_hasContinuousFrame { false };
WebSocketFrame::OpCode m_continuousFrameOpCode;
Vector<uint8_t> m_continuousFrameData;
unsigned short m_closeEventCode { CloseEventCodeAbnormalClosure };
String m_closeEventReason;
Deque<std::unique_ptr<QueuedFrame>> m_outgoingFrameQueue;
OutgoingFrameQueueStatus m_outgoingFrameQueueStatus { OutgoingFrameQueueOpen };
std::unique_ptr<FileReaderLoader> m_blobLoader;
BlobLoaderStatus m_blobLoaderStatus { BlobLoaderNotStarted };
WebSocketDeflateFramer m_deflateFramer;
Ref<SocketProvider> m_socketProvider;
};
}
SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::WebSocketChannel)
static bool isType(const WebCore::ThreadableWebSocketChannel& threadableWebSocketChannel) { return threadableWebSocketChannel.isWebSocketChannel(); }
SPECIALIZE_TYPE_TRAITS_END()