Attachment #241413 for bug #138649

View Details Raw Unified Return to Bug 138649

| Differences between



2014-11-11  Gyuyoung Kim  <gyuyoung.kim@samsung.com>

        Move Modules/websockets to std::unique_ptr
        https://bugs.webkit.org/show_bug.cgi?id=138649

        Reviewed by Chris Dumez.

        Remove create() factory function and use std::make_unique<>, std::unique_ptr<>
        instead of OwnPtr, PassOwnPtr.
        However didReceiveBinaryData() is still using PassOwnPtr. It should be replaced
        with std::unique_ptr<>

        No new tests, no behavior.

        * Modules/websockets/ThreadableWebSocketChannelClientWrapper.h:
        * Modules/websockets/WebSocket.cpp:
        * Modules/websockets/WebSocketChannel.cpp:
        (WebCore::WebSocketChannel::connect):
        (WebCore::WebSocketChannel::didFail):
        (WebCore::WebSocketChannel::processFrame):
        (WebCore::WebSocketChannel::enqueueTextFrame):
        (WebCore::WebSocketChannel::enqueueRawFrame):
        (WebCore::WebSocketChannel::enqueueBlobFrame):
        (WebCore::WebSocketChannel::processOutgoingFrameQueue):
        (WebCore::WebSocketChannel::sendFrame):
        * Modules/websockets/WebSocketChannel.h:
        * Modules/websockets/WebSocketDeflateFramer.cpp:
        (WebCore::WebSocketDeflateFramer::createExtensionProcessor):
        (WebCore::WebSocketDeflateFramer::enableDeflate):
        (WebCore::WebSocketDeflateFramer::deflate):
        (WebCore::WebSocketDeflateFramer::inflate):
        (WebCore::WebSocketExtensionDeflateFrame::create): Deleted.
        * Modules/websockets/WebSocketDeflateFramer.h:
        (WebCore::DeflateResultHolder::create): Deleted.
        (WebCore::InflateResultHolder::create): Deleted.
        * Modules/websockets/WebSocketDeflater.cpp:
        (WebCore::WebSocketDeflater::WebSocketDeflater):
        (WebCore::WebSocketInflater::WebSocketInflater):
        (WebCore::WebSocketDeflater::create): Deleted.
        (WebCore::WebSocketInflater::create): Deleted.
        * Modules/websockets/WebSocketDeflater.h:
        * Modules/websockets/WebSocketExtensionDispatcher.cpp:
        (WebCore::WebSocketExtensionDispatcher::addProcessor):
        * Modules/websockets/WebSocketExtensionDispatcher.h:
        * Modules/websockets/WebSocketHandshake.cpp:
        (WebCore::WebSocketHandshake::addExtensionProcessor):
        * Modules/websockets/WebSocketHandshake.h:

2014-11-11  Jer Noble  <jer.noble@apple.com>

        [Mac] Add diagnostic logging for per-media-engine load failures

Lines 39-45 a/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.h_sec1
- a/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.h -1 lines
39	#include "WorkerThreadableWebSocketChannel.h"	39	#include "WorkerThreadableWebSocketChannel.h"
40	#include <memory>	40	#include <memory>
41	#include <wtf/Forward.h>	41	#include <wtf/Forward.h>
42	#include <wtf/PassOwnPtr.h>
43	#include <wtf/Threading.h>	42	#include <wtf/Threading.h>
44	#include <wtf/Vector.h>	43	#include <wtf/Vector.h>
45	#include <wtf/text/WTFString.h>	44	#include <wtf/text/WTFString.h>

Lines 56-62 a/Source/WebCore/Modules/websockets/WebSocket.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocket.cpp -1 lines
56	#include <runtime/ArrayBuffer.h>	56	#include <runtime/ArrayBuffer.h>
57	#include <runtime/ArrayBufferView.h>	57	#include <runtime/ArrayBufferView.h>
58	#include <wtf/HashSet.h>	58	#include <wtf/HashSet.h>
59	#include <wtf/PassOwnPtr.h>
60	#include <wtf/StdLibExtras.h>	59	#include <wtf/StdLibExtras.h>
61	#include <wtf/text/CString.h>	60	#include <wtf/text/CString.h>
62	#include <wtf/text/StringBuilder.h>	61	#include <wtf/text/StringBuilder.h>



#include <wtf/Deque.h>
#include <wtf/FastMalloc.h>
#include <wtf/HashMap.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/text/CString.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>

    LOG(Network, "WebSocketChannel %p connect()", this);
    ASSERT(!m_handle);
    ASSERT(!m_suspended);
    m_handshake = std::make_unique<WebSocketHandshake>(url, protocol, m_document);
    m_handshake->reset();
    if (m_deflateFramer.canDeflate())
        m_handshake->addExtensionProcessor(m_deflateFramer.createExtensionProcessor());

    LOG(Network, "WebSocketChannel %p didFail() errorCode=%d", this, errorCode);
    ASSERT(m_blobLoader);
    ASSERT(m_blobLoaderStatus == BlobLoaderStarted);
    m_blobLoader = nullptr;
    m_blobLoaderStatus = BlobLoaderFailed;
    fail("Failed to load Blob: error code = " + String::number(errorCode)); // FIXME: Generate human-friendly reason message.
    deref();

    ASSERT(m_buffer.data() < frameEnd);
    ASSERT(frameEnd <= m_buffer.data() + m_buffer.size());

    auto inflateResult = m_deflateFramer.inflate(frame);
    if (!inflateResult->succeeded()) {
        fail(inflateResult->failureReason());
        return false;

void WebSocketChannel::enqueueTextFrame(const CString& string)
{
    ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);
    auto frame = std::make_unique<QueuedFrame>();
    frame->opCode = WebSocketFrame::OpCodeText;
    frame->frameType = QueuedFrameTypeString;
    frame->stringData = string;

void WebSocketChannel::enqueueRawFrame(WebSocketFrame::OpCode opCode, const char* data, size_t dataLength)
{
    ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);
    auto frame = std::make_unique<QueuedFrame>();
    frame->opCode = opCode;
    frame->frameType = QueuedFrameTypeVector;
    frame->vectorData.resize(dataLength);

void WebSocketChannel::enqueueBlobFrame(WebSocketFrame::OpCode opCode, Blob& blob)
{
    ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);
    auto frame = std::make_unique<QueuedFrame>();
    frame->opCode = opCode;
    frame->frameType = QueuedFrameTypeBlob;
    frame->blobData = &blob;

    Ref<WebSocketChannel> protect(*this); // Any call to fail() will get the channel closed and dereferenced.

    while (!m_outgoingFrameQueue.isEmpty()) {
        auto frame = m_outgoingFrameQueue.takeFirst();
        switch (frame->frameType) {
        case QueuedFrameTypeString: {
            if (!sendFrame(frame->opCode, frame->stringData.data(), frame->stringData.length()))

            case BlobLoaderNotStarted:
                ref(); // Will be derefed after didFinishLoading() or didFail().
                ASSERT(!m_blobLoader);
                m_blobLoader = std::make_unique<FileReaderLoader>(FileReaderLoader::ReadAsArrayBuffer, this);
                m_blobLoaderStatus = BlobLoaderStarted;
                m_blobLoader->start(m_document, frame->blobData.get());
                m_outgoingFrameQueue.prepend(frame.release());


            case BlobLoaderFinished: {
                RefPtr<ArrayBuffer> result = m_blobLoader->arrayBufferResult();
                m_blobLoader = nullptr;
                m_blobLoaderStatus = BlobLoaderNotStarted;
                if (!sendFrame(frame->opCode, static_cast<const char*>(result->data()), result->byteLength()))
                    fail("Failed to send WebSocket frame.");

    WebSocketFrame frame(opCode, true, false, true, data, dataLength);
    InspectorInstrumentation::didSendWebSocketFrame(m_document, m_identifier, frame);

    auto deflateResult = m_deflateFramer.deflate(frame);
    if (!deflateResult->succeeded()) {
        fail(deflateResult->failureReason());
        return false;




    Document* m_document;
    WebSocketChannelClient* m_client;
    std::unique_ptr<WebSocketHandshake> m_handshake;
    RefPtr<SocketStreamHandle> m_handle;
    Vector<char> m_buffer;


    unsigned short m_closeEventCode;
    String m_closeEventReason;

    Deque<std::unique_ptr<QueuedFrame>> m_outgoingFrameQueue;
    OutgoingFrameQueueStatus m_outgoingFrameQueueStatus;

    // FIXME: Load two or more Blobs simultaneously for better performance.
    std::unique_ptr<FileReaderLoader> m_blobLoader;
    BlobLoaderStatus m_blobLoaderStatus;

    WebSocketDeflateFramer m_deflateFramer;



class WebSocketExtensionDeflateFrame : public WebSocketExtensionProcessor {
    WTF_MAKE_FAST_ALLOCATED;
public:
    explicit WebSocketExtensionDeflateFrame(WebSocketDeflateFramer*);
    {
        return adoptPtr(new WebSocketExtensionDeflateFrame(framer));
    }
    virtual ~WebSocketExtensionDeflateFrame() { }

    virtual String handshakeString() override;

    virtual String failureReason() override { return m_failureReason; }

private:
    WebSocketExtensionDeflateFrame(WebSocketDeflateFramer*);

    WebSocketDeflateFramer* m_framer;
    bool m_responseProcessed;
    String m_failureReason;

{
}

std::unique_ptr<WebSocketExtensionProcessor> WebSocketDeflateFramer::createExtensionProcessor()
{
    return std::make_unique<WebSocketExtensionDeflateFrame>(this);
}

bool WebSocketDeflateFramer::canDeflate() const

#if USE(ZLIB)
void WebSocketDeflateFramer::enableDeflate(int windowBits, WebSocketDeflater::ContextTakeOverMode mode)
{
    m_deflater = std::make_unique<WebSocketDeflater>(windowBits, mode);
    m_inflater = std::make_unique<WebSocketInflater>();
    if (!m_deflater->initialize() || !m_inflater->initialize()) {
        m_deflater = nullptr;
        m_inflater = nullptr;
        return;
    }
    m_enabled = true;
}
#endif

std::unique_ptr<DeflateResultHolder> WebSocketDeflateFramer::deflate(WebSocketFrame& frame)
{
#if USE(ZLIB)
    auto result = std::make_unique<DeflateResultHolder>(this);
    if (!enabled() || !WebSocketFrame::isNonControlOpCode(frame.opCode) || !frame.payloadLength)
        return result;
    if (!m_deflater->addBytes(frame.payload, frame.payloadLength) || !m_deflater->finish()) {
        result->fail("Failed to compress frame");
        return result;
    }
    frame.compress = true;
    frame.payload = m_deflater->data();
    frame.payloadLength = m_deflater->size();
    return result;
#else
    return std::make_unique<DeflateResultHolder>(this);
#endif
}


#endif
}

std::unique_ptr<InflateResultHolder> WebSocketDeflateFramer::inflate(WebSocketFrame& frame)
{
    auto result = std::make_unique<InflateResultHolder>(this);
    if (!enabled() && frame.compress) {
        result->fail("Compressed bit must be 0 if no negotiated deflate-frame extension");
        return result;
    }
#if USE(ZLIB)
    if (!frame.compress)
        return result;
    if (!WebSocketFrame::isNonControlOpCode(frame.opCode)) {
        result->fail("Received unexpected compressed frame");
        return result;
    }
    if (!m_inflater->addBytes(frame.payload, frame.payloadLength) || !m_inflater->finish()) {
        result->fail("Failed to decompress frame");
        return result;
    }
    frame.compress = false;
    frame.payload = m_inflater->data();
    frame.payloadLength = m_inflater->size();
    return result;
#else
    return result;
#endif
}




#endif
#include "WebSocketExtensionProcessor.h"
#include "WebSocketFrame.h"
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>

namespace WebCore {


class DeflateResultHolder {
    WTF_MAKE_FAST_ALLOCATED;
public:
    explicit DeflateResultHolder(WebSocketDeflateFramer*);
    {
        return adoptPtr(new DeflateResultHolder(framer));
    }

    ~DeflateResultHolder();

    bool succeeded() const { return m_succeeded; }

    void fail(const String& failureReason);

private:
    explicit DeflateResultHolder(WebSocketDeflateFramer*);

    WebSocketDeflateFramer* m_framer;
    bool m_succeeded;
    String m_failureReason;

class InflateResultHolder {
    WTF_MAKE_FAST_ALLOCATED;
public:
    explicit InflateResultHolder(WebSocketDeflateFramer*);
    {
        return adoptPtr(new InflateResultHolder(framer));
    }

    ~InflateResultHolder();

    bool succeeded() const { return m_succeeded; }

    void fail(const String& failureReason);

private:
    explicit InflateResultHolder(WebSocketDeflateFramer*);

    WebSocketDeflateFramer* m_framer;
    bool m_succeeded;
    String m_failureReason;

public:
    WebSocketDeflateFramer();

    std::unique_ptr<WebSocketExtensionProcessor> createExtensionProcessor();

    bool canDeflate() const;
    bool enabled() const { return m_enabled; }

    std::unique_ptr<DeflateResultHolder> deflate(WebSocketFrame&);
    void resetDeflateContext();
    std::unique_ptr<InflateResultHolder> inflate(WebSocketFrame&);
    void resetInflateContext();

    void didFail();

private:
    bool m_enabled;
#if USE(ZLIB)
    std::unique_ptr<WebSocketDeflater> m_deflater;
    std::unique_ptr<WebSocketInflater> m_inflater;
#endif
};




static const int defaultMemLevel = 1;
static const size_t bufferIncrementUnit = 4096;

PassOwnPtr<WebSocketDeflater> WebSocketDeflater::create(int windowBits, ContextTakeOverMode contextTakeOverMode)
{
    return adoptPtr(new WebSocketDeflater(windowBits, contextTakeOverMode));
}

WebSocketDeflater::WebSocketDeflater(int windowBits, ContextTakeOverMode contextTakeOverMode)
    : m_windowBits(windowBits)
    , m_contextTakeOverMode(contextTakeOverMode)
{
    ASSERT(m_windowBits >= 8);
    ASSERT(m_windowBits <= 15);
    m_stream = std::make_unique<z_stream>();
    memset(m_stream.get(), 0, sizeof(z_stream));
}


        deflateReset(m_stream.get());
}

PassOwnPtr<WebSocketInflater> WebSocketInflater::create(int windowBits)
{
    return adoptPtr(new WebSocketInflater(windowBits));
}

WebSocketInflater::WebSocketInflater(int windowBits)
    : m_windowBits(windowBits)
{
    m_stream = std::make_unique<z_stream>();
    memset(m_stream.get(), 0, sizeof(z_stream));
}




#if ENABLE(WEB_SOCKETS)

#include <wtf/Noncopyable.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/Vector.h>

struct z_stream_s;

        DoNotTakeOverContext,
        TakeOverContext
    };
    static PassOwnPtr<WebSocketDeflater> create(int windowBits, ContextTakeOverMode = TakeOverContext);

    explicit WebSocketDeflater(int windowBits, ContextTakeOverMode = TakeOverContext);
    ~WebSocketDeflater();

    bool initialize();

    void reset();

private:
    WebSocketDeflater(int windowBits, ContextTakeOverMode);

    int m_windowBits;
    ContextTakeOverMode m_contextTakeOverMode;
    Vector<char> m_buffer;
    std::unique_ptr<z_stream> m_stream;
};

class WebSocketInflater {
    WTF_MAKE_FAST_ALLOCATED;
public:
    explicit WebSocketInflater(int windowBits = 15);

    ~WebSocketInflater();

    bool initialize();

    void reset();

private:
    explicit WebSocketInflater(int windowBits);

    int m_windowBits;
    Vector<char> m_buffer;
    std::unique_ptr<z_stream> m_stream;
};

}



    m_processors.clear();
}

void WebSocketExtensionDispatcher::addProcessor(std::unique_ptr<WebSocketExtensionProcessor> processor)
{
    for (size_t i = 0; i < m_processors.size(); ++i) {
        if (m_processors[i]->extensionToken() == processor->extensionToken())

    ASSERT(processor->handshakeString().length());
    ASSERT(!processor->handshakeString().contains('\n'));
    ASSERT(!processor->handshakeString().contains(static_cast<UChar>('\0')));
    m_processors.append(WTF::move(processor));
}

const String WebSocketExtensionDispatcher::createHeaderValue() const



#if ENABLE(WEB_SOCKETS)

#include "WebSocketExtensionProcessor.h"
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/Vector.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/WTFString.h>

    WebSocketExtensionDispatcher() { }

    void reset();
    void addProcessor(std::unique_ptr<WebSocketExtensionProcessor>);
    const String createHeaderValue() const;

    bool processHeaderValue(const String&);

    void appendAcceptedExtension(const String& extensionToken, HashMap<String, String>& extensionParameters);
    void fail(const String& reason);

    Vector<std::unique_ptr<WebSocketExtensionProcessor>> m_processors;
    StringBuilder m_acceptedExtensionsBuilder;
    String m_failureReason;
};



    return m_serverHandshakeResponse;
}

void WebSocketHandshake::addExtensionProcessor(std::unique_ptr<WebSocketExtensionProcessor> processor)
{
    m_extensionDispatcher.addProcessor(WTF::move(processor));
}

URL WebSocketHandshake::httpURLForAuthenticationAndCookies() const



#include "ResourceResponse.h"
#include "WebSocketExtensionDispatcher.h"
#include "WebSocketExtensionProcessor.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/text/WTFString.h>

namespace WebCore {


    const ResourceResponse& serverHandshakeResponse() const;

    void addExtensionProcessor(std::unique_ptr<WebSocketExtensionProcessor>);

    static String getExpectedWebSocketAccept(const String& secWebSocketKey);


Return to Bug 138649

Lines 56-63 a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp -12 / +10 lines
56	#include <wtf/Deque.h>	56	#include <wtf/Deque.h>
57	#include <wtf/FastMalloc.h>	57	#include <wtf/FastMalloc.h>
58	#include <wtf/HashMap.h>	58	#include <wtf/HashMap.h>
59	#include <wtf/OwnPtr.h>
60	#include <wtf/PassOwnPtr.h>
61	#include <wtf/text/CString.h>	59	#include <wtf/text/CString.h>
62	#include <wtf/text/StringHash.h>	60	#include <wtf/text/StringHash.h>
63	#include <wtf/text/WTFString.h>	61	#include <wtf/text/WTFString.h>
Lines 99-105 void WebSocketChannel::connect(const URL& url, const String& protocol) a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec2
99	LOG(Network, "WebSocketChannel %p connect()", this);	97	LOG(Network, "WebSocketChannel %p connect()", this);
100	ASSERT(!m_handle);	98	ASSERT(!m_handle);
101	ASSERT(!m_suspended);	99	ASSERT(!m_suspended);
102	m_handshake = adoptPtr(new WebSocketHandshake(url, protocol, m_document));	100	m_handshake = std::make_unique<WebSocketHandshake>(url, protocol, m_document);
103	m_handshake->reset();	101	m_handshake->reset();
104	if (m_deflateFramer.canDeflate())	102	if (m_deflateFramer.canDeflate())
105	m_handshake->addExtensionProcessor(m_deflateFramer.createExtensionProcessor());	103	m_handshake->addExtensionProcessor(m_deflateFramer.createExtensionProcessor());
Lines 375-381 void WebSocketChannel::didFail(int errorCode) a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec3
375	LOG(Network, "WebSocketChannel %p didFail() errorCode=%d", this, errorCode);	373	LOG(Network, "WebSocketChannel %p didFail() errorCode=%d", this, errorCode);
376	ASSERT(m_blobLoader);	374	ASSERT(m_blobLoader);
377	ASSERT(m_blobLoaderStatus == BlobLoaderStarted);	375	ASSERT(m_blobLoaderStatus == BlobLoaderStarted);
378	m_blobLoader.clear();	376	m_blobLoader = nullptr;
379	m_blobLoaderStatus = BlobLoaderFailed;	377	m_blobLoaderStatus = BlobLoaderFailed;
380	fail("Failed to load Blob: error code = " + String::number(errorCode)); // FIXME: Generate human-friendly reason message.	378	fail("Failed to load Blob: error code = " + String::number(errorCode)); // FIXME: Generate human-friendly reason message.
381	deref();	379	deref();
Lines 518-524 bool WebSocketChannel::processFrame() a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec4
518	ASSERT(m_buffer.data() < frameEnd);	516	ASSERT(m_buffer.data() < frameEnd);
519	ASSERT(frameEnd <= m_buffer.data() + m_buffer.size());	517	ASSERT(frameEnd <= m_buffer.data() + m_buffer.size());
520		518
521	OwnPtr<InflateResultHolder> inflateResult = m_deflateFramer.inflate(frame);	519	auto inflateResult = m_deflateFramer.inflate(frame);
522	if (!inflateResult->succeeded()) {	520	if (!inflateResult->succeeded()) {
523	fail(inflateResult->failureReason());	521	fail(inflateResult->failureReason());
524	return false;	522	return false;
Lines 685-691 bool WebSocketChannel::processFrame() a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec5
685	void WebSocketChannel::enqueueTextFrame(const CString& string)	683	void WebSocketChannel::enqueueTextFrame(const CString& string)
686	{	684	{
687	ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);	685	ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);
688	OwnPtr<QueuedFrame> frame = adoptPtr(new QueuedFrame);	686	auto frame = std::make_unique<QueuedFrame>();
689	frame->opCode = WebSocketFrame::OpCodeText;	687	frame->opCode = WebSocketFrame::OpCodeText;
690	frame->frameType = QueuedFrameTypeString;	688	frame->frameType = QueuedFrameTypeString;
691	frame->stringData = string;	689	frame->stringData = string;
Lines 695-701 void WebSocketChannel::enqueueTextFrame(const CString& string) a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec6
695	void WebSocketChannel::enqueueRawFrame(WebSocketFrame::OpCode opCode, const char* data, size_t dataLength)	693	void WebSocketChannel::enqueueRawFrame(WebSocketFrame::OpCode opCode, const char* data, size_t dataLength)
696	{	694	{
697	ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);	695	ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);
698	OwnPtr<QueuedFrame> frame = adoptPtr(new QueuedFrame);	696	auto frame = std::make_unique<QueuedFrame>();
699	frame->opCode = opCode;	697	frame->opCode = opCode;
700	frame->frameType = QueuedFrameTypeVector;	698	frame->frameType = QueuedFrameTypeVector;
701	frame->vectorData.resize(dataLength);	699	frame->vectorData.resize(dataLength);
Lines 707-713 void WebSocketChannel::enqueueRawFrame(WebSocketFrame::OpCode opCode, const char a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec7
707	void WebSocketChannel::enqueueBlobFrame(WebSocketFrame::OpCode opCode, Blob& blob)	705	void WebSocketChannel::enqueueBlobFrame(WebSocketFrame::OpCode opCode, Blob& blob)
708	{	706	{
709	ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);	707	ASSERT(m_outgoingFrameQueueStatus == OutgoingFrameQueueOpen);
710	OwnPtr<QueuedFrame> frame = adoptPtr(new QueuedFrame);	708	auto frame = std::make_unique<QueuedFrame>();
711	frame->opCode = opCode;	709	frame->opCode = opCode;
712	frame->frameType = QueuedFrameTypeBlob;	710	frame->frameType = QueuedFrameTypeBlob;
713	frame->blobData = &blob;	711	frame->blobData = &blob;
Lines 722-728 void WebSocketChannel::processOutgoingFrameQueue() a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec8
722	Ref<WebSocketChannel> protect(*this); // Any call to fail() will get the channel closed and dereferenced.	720	Ref<WebSocketChannel> protect(*this); // Any call to fail() will get the channel closed and dereferenced.
723		721
724	while (!m_outgoingFrameQueue.isEmpty()) {	722	while (!m_outgoingFrameQueue.isEmpty()) {
725	OwnPtr<QueuedFrame> frame = m_outgoingFrameQueue.takeFirst();	723	auto frame = m_outgoingFrameQueue.takeFirst();
726	switch (frame->frameType) {	724	switch (frame->frameType) {
727	case QueuedFrameTypeString: {	725	case QueuedFrameTypeString: {
728	if (!sendFrame(frame->opCode, frame->stringData.data(), frame->stringData.length()))	726	if (!sendFrame(frame->opCode, frame->stringData.data(), frame->stringData.length()))
Lines 740-746 void WebSocketChannel::processOutgoingFrameQueue() a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec9
740	case BlobLoaderNotStarted:	738	case BlobLoaderNotStarted:
741	ref(); // Will be derefed after didFinishLoading() or didFail().	739	ref(); // Will be derefed after didFinishLoading() or didFail().
742	ASSERT(!m_blobLoader);	740	ASSERT(!m_blobLoader);
743	m_blobLoader = adoptPtr(new FileReaderLoader(FileReaderLoader::ReadAsArrayBuffer, this));	741	m_blobLoader = std::make_unique<FileReaderLoader>(FileReaderLoader::ReadAsArrayBuffer, this);
744	m_blobLoaderStatus = BlobLoaderStarted;	742	m_blobLoaderStatus = BlobLoaderStarted;
745	m_blobLoader->start(m_document, frame->blobData.get());	743	m_blobLoader->start(m_document, frame->blobData.get());
746	m_outgoingFrameQueue.prepend(frame.release());	744	m_outgoingFrameQueue.prepend(frame.release());
Lines 753-759 void WebSocketChannel::processOutgoingFrameQueue() a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec10
753		751
754	case BlobLoaderFinished: {	752	case BlobLoaderFinished: {
755	RefPtr<ArrayBuffer> result = m_blobLoader->arrayBufferResult();	753	RefPtr<ArrayBuffer> result = m_blobLoader->arrayBufferResult();
756	m_blobLoader.clear();	754	m_blobLoader = nullptr;
757	m_blobLoaderStatus = BlobLoaderNotStarted;	755	m_blobLoaderStatus = BlobLoaderNotStarted;
758	if (!sendFrame(frame->opCode, static_cast<const char*>(result->data()), result->byteLength()))	756	if (!sendFrame(frame->opCode, static_cast<const char*>(result->data()), result->byteLength()))
759	fail("Failed to send WebSocket frame.");	757	fail("Failed to send WebSocket frame.");
Lines 794-800 bool WebSocketChannel::sendFrame(WebSocketFrame::OpCode opCode, const char* data a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec11
794	WebSocketFrame frame(opCode, true, false, true, data, dataLength);	792	WebSocketFrame frame(opCode, true, false, true, data, dataLength);
795	InspectorInstrumentation::didSendWebSocketFrame(m_document, m_identifier, frame);	793	InspectorInstrumentation::didSendWebSocketFrame(m_document, m_identifier, frame);
796		794
797	OwnPtr<DeflateResultHolder> deflateResult = m_deflateFramer.deflate(frame);	795	auto deflateResult = m_deflateFramer.deflate(frame);
798	if (!deflateResult->succeeded()) {	796	if (!deflateResult->succeeded()) {
799	fail(deflateResult->failureReason());	797	fail(deflateResult->failureReason());
800	return false;	798	return false;

Lines 186-192 private: a/Source/WebCore/Modules/websockets/WebSocketChannel.h_sec1
- a/Source/WebCore/Modules/websockets/WebSocketChannel.h -3 / +3 lines
186		186
187	Document* m_document;	187	Document* m_document;
188	WebSocketChannelClient* m_client;	188	WebSocketChannelClient* m_client;
189	OwnPtr<WebSocketHandshake> m_handshake;	189	std::unique_ptr<WebSocketHandshake> m_handshake;
190	RefPtr<SocketStreamHandle> m_handle;	190	RefPtr<SocketStreamHandle> m_handle;
191	Vector<char> m_buffer;	191	Vector<char> m_buffer;
192		192
Lines 208-218 private: a/Source/WebCore/Modules/websockets/WebSocketChannel.h_sec2
208	unsigned short m_closeEventCode;	208	unsigned short m_closeEventCode;
209	String m_closeEventReason;	209	String m_closeEventReason;
210		210
211	Deque<OwnPtr<QueuedFrame>> m_outgoingFrameQueue;	211	Deque<std::unique_ptr<QueuedFrame>> m_outgoingFrameQueue;
212	OutgoingFrameQueueStatus m_outgoingFrameQueueStatus;	212	OutgoingFrameQueueStatus m_outgoingFrameQueueStatus;
213		213
214	// FIXME: Load two or more Blobs simultaneously for better performance.	214	// FIXME: Load two or more Blobs simultaneously for better performance.
215	OwnPtr<FileReaderLoader> m_blobLoader;	215	std::unique_ptr<FileReaderLoader> m_blobLoader;
216	BlobLoaderStatus m_blobLoaderStatus;	216	BlobLoaderStatus m_blobLoaderStatus;
217		217
218	WebSocketDeflateFramer m_deflateFramer;	218	WebSocketDeflateFramer m_deflateFramer;

Lines 43-52 namespace WebCore { a/Source/WebCore/Modules/websockets/WebSocketDeflateFramer.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocketDeflateFramer.cpp -26 / +21 lines
43	class WebSocketExtensionDeflateFrame : public WebSocketExtensionProcessor {	43	class WebSocketExtensionDeflateFrame : public WebSocketExtensionProcessor {
44	WTF_MAKE_FAST_ALLOCATED;	44	WTF_MAKE_FAST_ALLOCATED;
45	public:	45	public:
46	static PassOwnPtr<WebSocketExtensionDeflateFrame> create(WebSocketDeflateFramer* framer)	46	explicit WebSocketExtensionDeflateFrame(WebSocketDeflateFramer*);
47	{
48	return adoptPtr(new WebSocketExtensionDeflateFrame(framer));
49	}
50	virtual ~WebSocketExtensionDeflateFrame() { }	47	virtual ~WebSocketExtensionDeflateFrame() { }
51		48
52	virtual String handshakeString() override;	49	virtual String handshakeString() override;
Lines 54-61 public: a/Source/WebCore/Modules/websockets/WebSocketDeflateFramer.cpp_sec2
54	virtual String failureReason() override { return m_failureReason; }	51	virtual String failureReason() override { return m_failureReason; }
55		52
56	private:	53	private:
57	WebSocketExtensionDeflateFrame(WebSocketDeflateFramer*);
58
59	WebSocketDeflateFramer* m_framer;	54	WebSocketDeflateFramer* m_framer;
60	bool m_responseProcessed;	55	bool m_responseProcessed;
61	String m_failureReason;	56	String m_failureReason;
Lines 161-169 WebSocketDeflateFramer::WebSocketDeflateFramer() a/Source/WebCore/Modules/websockets/WebSocketDeflateFramer.cpp_sec3
161	{	156	{
162	}	157	}
163		158
164	PassOwnPtr<WebSocketExtensionProcessor> WebSocketDeflateFramer::createExtensionProcessor()	159	std::unique_ptr<WebSocketExtensionProcessor> WebSocketDeflateFramer::createExtensionProcessor()
165	{	160	{
166	return WebSocketExtensionDeflateFrame::create(this);	161	return std::make_unique<WebSocketExtensionDeflateFrame>(this);
167	}	162	}
168		163
169	bool WebSocketDeflateFramer::canDeflate() const	164	bool WebSocketDeflateFramer::canDeflate() const
Lines 178-210 bool WebSocketDeflateFramer::canDeflate() const a/Source/WebCore/Modules/websockets/WebSocketDeflateFramer.cpp_sec4
178	#if USE(ZLIB)	173	#if USE(ZLIB)
179	void WebSocketDeflateFramer::enableDeflate(int windowBits, WebSocketDeflater::ContextTakeOverMode mode)	174	void WebSocketDeflateFramer::enableDeflate(int windowBits, WebSocketDeflater::ContextTakeOverMode mode)
180	{	175	{
181	m_deflater = WebSocketDeflater::create(windowBits, mode);	176	m_deflater = std::make_unique<WebSocketDeflater>(windowBits, mode);
182	m_inflater = WebSocketInflater::create();	177	m_inflater = std::make_unique<WebSocketInflater>();
183	if (!m_deflater->initialize() \|\| !m_inflater->initialize()) {	178	if (!m_deflater->initialize() \|\| !m_inflater->initialize()) {
184	m_deflater.clear();	179	m_deflater = nullptr;
185	m_inflater.clear();	180	m_inflater = nullptr;
186	return;	181	return;
187	}	182	}
188	m_enabled = true;	183	m_enabled = true;
189	}	184	}
190	#endif	185	#endif
191		186
192	PassOwnPtr<DeflateResultHolder> WebSocketDeflateFramer::deflate(WebSocketFrame& frame)	187	std::unique_ptr<DeflateResultHolder> WebSocketDeflateFramer::deflate(WebSocketFrame& frame)
193	{	188	{
194	#if USE(ZLIB)	189	#if USE(ZLIB)
195	OwnPtr<DeflateResultHolder> result = DeflateResultHolder::create(this);	190	auto result = std::make_unique<DeflateResultHolder>(this);
196	if (!enabled() \|\| !WebSocketFrame::isNonControlOpCode(frame.opCode) \|\| !frame.payloadLength)	191	if (!enabled() \|\| !WebSocketFrame::isNonControlOpCode(frame.opCode) \|\| !frame.payloadLength)
197	return result.release();	192	return result;
198	if (!m_deflater->addBytes(frame.payload, frame.payloadLength) \|\| !m_deflater->finish()) {	193	if (!m_deflater->addBytes(frame.payload, frame.payloadLength) \|\| !m_deflater->finish()) {
199	result->fail("Failed to compress frame");	194	result->fail("Failed to compress frame");
200	return result.release();	195	return result;
201	}	196	}
202	frame.compress = true;	197	frame.compress = true;
203	frame.payload = m_deflater->data();	198	frame.payload = m_deflater->data();
204	frame.payloadLength = m_deflater->size();	199	frame.payloadLength = m_deflater->size();
205	return result.release();	200	return result;
206	#else	201	#else
207	return DeflateResultHolder::create(this);	202	return std::make_unique<DeflateResultHolder>(this);
208	#endif	203	#endif
209	}	204	}
210		205
Lines 216-245 void WebSocketDeflateFramer::resetDeflateContext() a/Source/WebCore/Modules/websockets/WebSocketDeflateFramer.cpp_sec5
216	#endif	211	#endif
217	}	212	}
218		213
219	PassOwnPtr<InflateResultHolder> WebSocketDeflateFramer::inflate(WebSocketFrame& frame)	214	std::unique_ptr<InflateResultHolder> WebSocketDeflateFramer::inflate(WebSocketFrame& frame)
220	{	215	{
221	OwnPtr<InflateResultHolder> result = InflateResultHolder::create(this);	216	auto result = std::make_unique<InflateResultHolder>(this);
222	if (!enabled() && frame.compress) {	217	if (!enabled() && frame.compress) {
223	result->fail("Compressed bit must be 0 if no negotiated deflate-frame extension");	218	result->fail("Compressed bit must be 0 if no negotiated deflate-frame extension");
224	return result.release();	219	return result;
225	}	220	}
226	#if USE(ZLIB)	221	#if USE(ZLIB)
227	if (!frame.compress)	222	if (!frame.compress)
228	return result.release();	223	return result;
229	if (!WebSocketFrame::isNonControlOpCode(frame.opCode)) {	224	if (!WebSocketFrame::isNonControlOpCode(frame.opCode)) {
230	result->fail("Received unexpected compressed frame");	225	result->fail("Received unexpected compressed frame");
231	return result.release();	226	return result;
232	}	227	}
233	if (!m_inflater->addBytes(frame.payload, frame.payloadLength) \|\| !m_inflater->finish()) {	228	if (!m_inflater->addBytes(frame.payload, frame.payloadLength) \|\| !m_inflater->finish()) {
234	result->fail("Failed to decompress frame");	229	result->fail("Failed to decompress frame");
235	return result.release();	230	return result;
236	}	231	}
237	frame.compress = false;	232	frame.compress = false;
238	frame.payload = m_inflater->data();	233	frame.payload = m_inflater->data();
239	frame.payloadLength = m_inflater->size();	234	frame.payloadLength = m_inflater->size();
240	return result.release();	235	return result;
241	#else	236	#else
242	return result.release();	237	return result;
243	#endif	238	#endif
244	}	239	}
245		240

Lines 376-384 const ResourceResponse& WebSocketHandshake::serverHandshakeResponse() const a/Source/WebCore/Modules/websockets/WebSocketHandshake.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocketHandshake.cpp -2 / +2 lines
376	return m_serverHandshakeResponse;	376	return m_serverHandshakeResponse;
377	}	377	}
378		378
379	void WebSocketHandshake::addExtensionProcessor(PassOwnPtr<WebSocketExtensionProcessor> processor)	379	void WebSocketHandshake::addExtensionProcessor(std::unique_ptr<WebSocketExtensionProcessor> processor)
380	{	380	{
381	m_extensionDispatcher.addProcessor(processor);	381	m_extensionDispatcher.addProcessor(WTF::move(processor));
382	}	382	}
383		383
384	URL WebSocketHandshake::httpURLForAuthenticationAndCookies() const	384	URL WebSocketHandshake::httpURLForAuthenticationAndCookies() const

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +48 lines
		1	2014-11-11 Gyuyoung Kim <gyuyoung.kim@samsung.com>
		2
		3	Move Modules/websockets to std::unique_ptr
		4	https://bugs.webkit.org/show_bug.cgi?id=138649
		5
		6	Reviewed by Chris Dumez.
		7
		8	Remove create() factory function and use std::make_unique<>, std::unique_ptr<>
		9	instead of OwnPtr, PassOwnPtr.
		10	However didReceiveBinaryData() is still using PassOwnPtr. It should be replaced
		11	with std::unique_ptr<>
		12
		13	No new tests, no behavior.
		14
		15	* Modules/websockets/ThreadableWebSocketChannelClientWrapper.h:
		16	* Modules/websockets/WebSocket.cpp:
		17	* Modules/websockets/WebSocketChannel.cpp:
		18	(WebCore::WebSocketChannel::connect):
		19	(WebCore::WebSocketChannel::didFail):
		20	(WebCore::WebSocketChannel::processFrame):
		21	(WebCore::WebSocketChannel::enqueueTextFrame):
		22	(WebCore::WebSocketChannel::enqueueRawFrame):
		23	(WebCore::WebSocketChannel::enqueueBlobFrame):
		24	(WebCore::WebSocketChannel::processOutgoingFrameQueue):
		25	(WebCore::WebSocketChannel::sendFrame):
		26	* Modules/websockets/WebSocketChannel.h:
		27	* Modules/websockets/WebSocketDeflateFramer.cpp:
		28	(WebCore::WebSocketDeflateFramer::createExtensionProcessor):
		29	(WebCore::WebSocketDeflateFramer::enableDeflate):
		30	(WebCore::WebSocketDeflateFramer::deflate):
		31	(WebCore::WebSocketDeflateFramer::inflate):
		32	(WebCore::WebSocketExtensionDeflateFrame::create): Deleted.
		33	* Modules/websockets/WebSocketDeflateFramer.h:
		34	(WebCore::DeflateResultHolder::create): Deleted.
		35	(WebCore::InflateResultHolder::create): Deleted.
		36	* Modules/websockets/WebSocketDeflater.cpp:
		37	(WebCore::WebSocketDeflater::WebSocketDeflater):
		38	(WebCore::WebSocketInflater::WebSocketInflater):
		39	(WebCore::WebSocketDeflater::create): Deleted.
		40	(WebCore::WebSocketInflater::create): Deleted.
		41	* Modules/websockets/WebSocketDeflater.h:
		42	* Modules/websockets/WebSocketExtensionDispatcher.cpp:
		43	(WebCore::WebSocketExtensionDispatcher::addProcessor):
		44	* Modules/websockets/WebSocketExtensionDispatcher.h:
		45	* Modules/websockets/WebSocketHandshake.cpp:
		46	(WebCore::WebSocketHandshake::addExtensionProcessor):
		47	* Modules/websockets/WebSocketHandshake.h:
		48
1	2014-11-11 Jer Noble <jer.noble@apple.com>	49	2014-11-11 Jer Noble <jer.noble@apple.com>
2		50
3	[Mac] Add diagnostic logging for per-media-engine load failures	51	[Mac] Add diagnostic logging for per-media-engine load failures

Lines 47-64 namespace WebCore { a/Source/WebCore/Modules/websockets/WebSocketDeflater.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocketDeflater.cpp -12 / +2 lines
47	static const int defaultMemLevel = 1;	47	static const int defaultMemLevel = 1;
48	static const size_t bufferIncrementUnit = 4096;	48	static const size_t bufferIncrementUnit = 4096;
49		49
50	PassOwnPtr<WebSocketDeflater> WebSocketDeflater::create(int windowBits, ContextTakeOverMode contextTakeOverMode)
51	{
52	return adoptPtr(new WebSocketDeflater(windowBits, contextTakeOverMode));
53	}
54
55	WebSocketDeflater::WebSocketDeflater(int windowBits, ContextTakeOverMode contextTakeOverMode)	50	WebSocketDeflater::WebSocketDeflater(int windowBits, ContextTakeOverMode contextTakeOverMode)
56	: m_windowBits(windowBits)	51	: m_windowBits(windowBits)
57	, m_contextTakeOverMode(contextTakeOverMode)	52	, m_contextTakeOverMode(contextTakeOverMode)
58	{	53	{
59	ASSERT(m_windowBits >= 8);	54	ASSERT(m_windowBits >= 8);
60	ASSERT(m_windowBits <= 15);	55	ASSERT(m_windowBits <= 15);
61	m_stream = adoptPtr(new z_stream);	56	m_stream = std::make_unique<z_stream>();
62	memset(m_stream.get(), 0, sizeof(z_stream));	57	memset(m_stream.get(), 0, sizeof(z_stream));
63	}	58	}
64		59
Lines 127-141 void WebSocketDeflater::reset() a/Source/WebCore/Modules/websockets/WebSocketDeflater.cpp_sec2
127	deflateReset(m_stream.get());	122	deflateReset(m_stream.get());
128	}	123	}
129		124
130	PassOwnPtr<WebSocketInflater> WebSocketInflater::create(int windowBits)
131	{
132	return adoptPtr(new WebSocketInflater(windowBits));
133	}
134
135	WebSocketInflater::WebSocketInflater(int windowBits)	125	WebSocketInflater::WebSocketInflater(int windowBits)
136	: m_windowBits(windowBits)	126	: m_windowBits(windowBits)
137	{	127	{
138	m_stream = adoptPtr(new z_stream);	128	m_stream = std::make_unique<z_stream>();
139	memset(m_stream.get(), 0, sizeof(z_stream));	129	memset(m_stream.get(), 0, sizeof(z_stream));
140	}	130	}
141		131

Lines 34-41 a/Source/WebCore/Modules/websockets/WebSocketDeflater.h_sec1
- a/Source/WebCore/Modules/websockets/WebSocketDeflater.h -11 / +4 lines
34	#if ENABLE(WEB_SOCKETS)	34	#if ENABLE(WEB_SOCKETS)
35		35
36	#include <wtf/Noncopyable.h>	36	#include <wtf/Noncopyable.h>
37	#include <wtf/OwnPtr.h>
38	#include <wtf/PassOwnPtr.h>
39	#include <wtf/Vector.h>	37	#include <wtf/Vector.h>
40		38
41	struct z_stream_s;	39	struct z_stream_s;
Lines 50-57 public: a/Source/WebCore/Modules/websockets/WebSocketDeflater.h_sec2
50	DoNotTakeOverContext,	48	DoNotTakeOverContext,
51	TakeOverContext	49	TakeOverContext
52	};	50	};
53	static PassOwnPtr<WebSocketDeflater> create(int windowBits, ContextTakeOverMode = TakeOverContext);
54		51
		52	explicit WebSocketDeflater(int windowBits, ContextTakeOverMode = TakeOverContext);
55	~WebSocketDeflater();	53	~WebSocketDeflater();
56		54
57	bool initialize();	55	bool initialize();
Lines 62-80 public: a/Source/WebCore/Modules/websockets/WebSocketDeflater.h_sec3
62	void reset();	60	void reset();
63		61
64	private:	62	private:
65	WebSocketDeflater(int windowBits, ContextTakeOverMode);
66
67	int m_windowBits;	63	int m_windowBits;
68	ContextTakeOverMode m_contextTakeOverMode;	64	ContextTakeOverMode m_contextTakeOverMode;
69	Vector<char> m_buffer;	65	Vector<char> m_buffer;
70	OwnPtr<z_stream> m_stream;	66	std::unique_ptr<z_stream> m_stream;
71	};	67	};
72		68
73	class WebSocketInflater {	69	class WebSocketInflater {
74	WTF_MAKE_FAST_ALLOCATED;	70	WTF_MAKE_FAST_ALLOCATED;
75	public:	71	public:
76	static PassOwnPtr<WebSocketInflater> create(int windowBits = 15);	72	explicit WebSocketInflater(int windowBits = 15);
77
78	~WebSocketInflater();	73	~WebSocketInflater();
79		74
80	bool initialize();	75	bool initialize();
Lines 85-95 public: a/Source/WebCore/Modules/websockets/WebSocketDeflater.h_sec4
85	void reset();	80	void reset();
86		81
87	private:	82	private:
88	explicit WebSocketInflater(int windowBits);
89
90	int m_windowBits;	83	int m_windowBits;
91	Vector<char> m_buffer;	84	Vector<char> m_buffer;
92	OwnPtr<z_stream> m_stream;	85	std::unique_ptr<z_stream> m_stream;
93	};	86	};
94		87
95	}	88	}

Lines 48-54 void WebSocketExtensionDispatcher::reset() a/Source/WebCore/Modules/websockets/WebSocketExtensionDispatcher.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocketExtensionDispatcher.cpp -2 / +2 lines
48	m_processors.clear();	48	m_processors.clear();
49	}	49	}
50		50
51	void WebSocketExtensionDispatcher::addProcessor(PassOwnPtr<WebSocketExtensionProcessor> processor)	51	void WebSocketExtensionDispatcher::addProcessor(std::unique_ptr<WebSocketExtensionProcessor> processor)
52	{	52	{
53	for (size_t i = 0; i < m_processors.size(); ++i) {	53	for (size_t i = 0; i < m_processors.size(); ++i) {
54	if (m_processors[i]->extensionToken() == processor->extensionToken())	54	if (m_processors[i]->extensionToken() == processor->extensionToken())
Lines 57-63 void WebSocketExtensionDispatcher::addProcessor(PassOwnPtr<WebSocketExtensionPro a/Source/WebCore/Modules/websockets/WebSocketExtensionDispatcher.cpp_sec2
57	ASSERT(processor->handshakeString().length());	57	ASSERT(processor->handshakeString().length());
58	ASSERT(!processor->handshakeString().contains('\n'));	58	ASSERT(!processor->handshakeString().contains('\n'));
59	ASSERT(!processor->handshakeString().contains(static_cast<UChar>('\0')));	59	ASSERT(!processor->handshakeString().contains(static_cast<UChar>('\0')));
60	m_processors.append(processor);	60	m_processors.append(WTF::move(processor));
61	}	61	}
62		62
63	const String WebSocketExtensionDispatcher::createHeaderValue() const	63	const String WebSocketExtensionDispatcher::createHeaderValue() const

Lines 37-43 a/Source/WebCore/Modules/websockets/WebSocketHandshake.h_sec1
- a/Source/WebCore/Modules/websockets/WebSocketHandshake.h -2 / +1 lines
37	#include "ResourceResponse.h"	37	#include "ResourceResponse.h"
38	#include "WebSocketExtensionDispatcher.h"	38	#include "WebSocketExtensionDispatcher.h"
39	#include "WebSocketExtensionProcessor.h"	39	#include "WebSocketExtensionProcessor.h"
40	#include <wtf/PassOwnPtr.h>
41	#include <wtf/text/WTFString.h>	40	#include <wtf/text/WTFString.h>
42		41
43	namespace WebCore {	42	namespace WebCore {
Lines 86-92 public: a/Source/WebCore/Modules/websockets/WebSocketHandshake.h_sec2
86		85
87	const ResourceResponse& serverHandshakeResponse() const;	86	const ResourceResponse& serverHandshakeResponse() const;
88		87
89	void addExtensionProcessor(PassOwnPtr<WebSocketExtensionProcessor>);	88	void addExtensionProcessor(std::unique_ptr<WebSocketExtensionProcessor>);
90		89
91	static String getExpectedWebSocketAccept(const String& secWebSocketKey);	90	static String getExpectedWebSocketAccept(const String& secWebSocketKey);
92		91