WebSocketChannel.h [plain text]
#ifndef WebSocketChannel_h
#define WebSocketChannel_h
#if ENABLE(WEB_SOCKETS)
#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/Vector.h>
#include <wtf/text/CString.h>
namespace WebCore {
class Blob;
class Document;
class FileReaderLoader;
class SocketStreamHandle;
class SocketStreamError;
class WebSocketChannelClient;
class WebSocketChannel : public RefCounted<WebSocketChannel>, public SocketStreamHandleClient, public ThreadableWebSocketChannel, public FileReaderLoaderClient
{
WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<WebSocketChannel> create(Document* document, WebSocketChannelClient* client) { return adoptRef(new WebSocketChannel(document, client)); }
virtual ~WebSocketChannel();
bool send(const char* data, int length);
virtual void connect(const URL&, const String& protocol) override;
virtual String subprotocol() override;
virtual String extensions() override;
virtual ThreadableWebSocketChannel::SendResult send(const String& message) override;
virtual ThreadableWebSocketChannel::SendResult send(const JSC::ArrayBuffer&, unsigned byteOffset, unsigned byteLength) override;
virtual ThreadableWebSocketChannel::SendResult send(Blob&) override;
virtual unsigned long bufferedAmount() const override;
virtual void close(int code, const String& reason) override; virtual void fail(const String& reason) override;
virtual void disconnect() override;
virtual void suspend() override;
virtual void resume() override;
virtual void willOpenSocketStream(SocketStreamHandle*) override;
virtual void didOpenSocketStream(SocketStreamHandle*) override;
virtual void didCloseSocketStream(SocketStreamHandle*) override;
virtual void didReceiveSocketStreamData(SocketStreamHandle*, const char*, int) override;
virtual void didUpdateBufferedAmount(SocketStreamHandle*, size_t bufferedAmount) override;
virtual void didFailSocketStream(SocketStreamHandle*, const SocketStreamError&) override;
virtual void didReceiveAuthenticationChallenge(SocketStreamHandle*, const AuthenticationChallenge&) override;
virtual void didCancelAuthenticationChallenge(SocketStreamHandle*, const AuthenticationChallenge&) override;
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
};
virtual void didStartLoading();
virtual void didReceiveData();
virtual void didFinishLoading();
virtual void didFail(int errorCode);
using RefCounted<WebSocketChannel>::ref;
using RefCounted<WebSocketChannel>::deref;
protected:
virtual void refThreadableWebSocketChannel() { ref(); }
virtual void derefThreadableWebSocketChannel() { deref(); }
private:
WebSocketChannel(Document*, WebSocketChannelClient*);
bool appendToBuffer(const char* data, size_t len);
void skipBuffer(size_t len);
bool processBuffer();
void resumeTimerFired(Timer*);
void startClosingHandshake(int code, const String& reason);
void closingTimerFired(Timer*);
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
};
bool sendFrame(WebSocketFrame::OpCode, const char* data, size_t dataLength);
enum BlobLoaderStatus {
BlobLoaderNotStarted,
BlobLoaderStarted,
BlobLoaderFinished,
BlobLoaderFailed
};
Document* m_document;
WebSocketChannelClient* m_client;
OwnPtr<WebSocketHandshake> m_handshake;
RefPtr<SocketStreamHandle> m_handle;
Vector<char> m_buffer;
Timer m_resumeTimer;
bool m_suspended;
bool m_closing;
bool m_receivedClosingHandshake;
Timer m_closingTimer;
bool m_closed;
bool m_shouldDiscardReceivedData;
unsigned long m_unhandledBufferedAmount;
unsigned long m_identifier;
bool m_hasContinuousFrame;
WebSocketFrame::OpCode m_continuousFrameOpCode;
Vector<char> m_continuousFrameData;
unsigned short m_closeEventCode;
String m_closeEventReason;
Deque<OwnPtr<QueuedFrame>> m_outgoingFrameQueue;
OutgoingFrameQueueStatus m_outgoingFrameQueueStatus;
OwnPtr<FileReaderLoader> m_blobLoader;
BlobLoaderStatus m_blobLoaderStatus;
WebSocketDeflateFramer m_deflateFramer;
};
}
#endif // ENABLE(WEB_SOCKETS)
#endif // WebSocketChannel_h