Attachment #102494 for bug #65367

View Details Raw Unified Return to Bug 65367

| Differences between



2011-08-01  Yuta Kitamura  <yutak@chromium.org>

        WebSocket: Receive URL and subprotocol in WebSocketChannel::connect()
        https://bugs.webkit.org/show_bug.cgi?id=65367

        Reviewed by NOBODY (OOPS!).

        To implement multiple subprotocols support (bug 65247), WebSocket::connect() will need to validate
        the value of subprotocols after constructing WebSocketChannel, because the result depends on which
        WebSocket protocol is used, which is obtained from WebSocketChannel::useHixie76Protocol(). This
        means the subprotocol value will not be available at the time of WebSocketChannel construction.

        This change moves URL and subprotocol arguments in WebSocketChannel constructor to
        WebSocketChannel::connect(), which allows WebSocket::connect() function to check the subprotocol
        value before the actual connection is established.

        Relocating URL argument is technically not necessary, but seemed legitimate in terms of functional
        correspondence between WebSocket and WebSocketChannel (constructor versus connect()).

        No change in behavior, thus no new tests.

        * websockets/ThreadableWebSocketChannel.cpp:
        Remove "url" and "protocol" arguments from constructor and add them in connect().
        (WebCore::ThreadableWebSocketChannel::create):
        * websockets/ThreadableWebSocketChannel.h:
        * websockets/WebSocket.cpp:
        (WebCore::WebSocket::connect):
        * websockets/WebSocketChannel.cpp: Same as ThreadableWebSocketChannel.
        (WebCore::WebSocketChannel::WebSocketChannel):
        (WebCore::WebSocketChannel::connect):
        InspectorInstrumentation::didCreateWebSocket() call was moved to connect() because it needs URL.
        This does not change behavior, because connect() is guaranteed to be called immediately after
        WebSocketChannel is constructed.
        * websockets/WebSocketChannel.h:
        (WebCore::WebSocketChannel::create):
        * websockets/WorkerThreadableWebSocketChannel.cpp: Same as ThreadableWebSocketChannel.
        (WebCore::WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel):
        (WebCore::WorkerThreadableWebSocketChannel::connect):
        (WebCore::WorkerThreadableWebSocketChannel::Peer::Peer):
        (WebCore::WorkerThreadableWebSocketChannel::Peer::connect):
        (WebCore::WorkerThreadableWebSocketChannel::Bridge::mainThreadCreateWebSocketChannel):
        (WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
        (WebCore::WorkerThreadableWebSocketChannel::mainThreadConnect):
        (WebCore::WorkerThreadableWebSocketChannel::Bridge::connect):
        * websockets/WorkerThreadableWebSocketChannel.h:
        (WebCore::WorkerThreadableWebSocketChannel::create):
        (WebCore::WorkerThreadableWebSocketChannel::Peer::create):
        (WebCore::WorkerThreadableWebSocketChannel::Bridge::create):

2011-07-28  Leandro Gracia Gil  <leandrogracia@chromium.org>

        Fix speech input icon rect on RTL directions.




static const char webSocketChannelMode[] = "webSocketChannelMode";

PassRefPtr<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
{
    ASSERT(context);
    ASSERT(client);

        WorkerRunLoop& runLoop = workerContext->thread()->runLoop();
        String mode = webSocketChannelMode;
        mode.append(String::number(runLoop.createUniqueId()));
        return WorkerThreadableWebSocketChannel::create(workerContext, client, mode);
    }
#endif // ENABLE(WORKERS)

    ASSERT(context->isDocument());
    return WebSocketChannel::create(context, client);
}

} // namespace WebCore



    WTF_MAKE_NONCOPYABLE(ThreadableWebSocketChannel);
public:
    ThreadableWebSocketChannel() { }
    static PassRefPtr<ThreadableWebSocketChannel> create(ScriptExecutionContext*, WebSocketChannelClient*);

    virtual bool useHixie76Protocol() = 0;
    virtual void connect(const KURL&, const String& protocol) = 0;
    virtual bool send(const String& message) = 0;
    virtual unsigned long bufferedAmount() const = 0;
    virtual void close() = 0;



        return;
    }

    m_channel = ThreadableWebSocketChannel::create(scriptExecutionContext(), this);
    m_channel->connect(m_url, m_protocol);
    ActiveDOMObject::setPendingActivity(this);
}




const WebSocketChannel::OpCode WebSocketChannel::OpCodePing = 0x9;
const WebSocketChannel::OpCode WebSocketChannel::OpCodePong = 0xA;

WebSocketChannel::WebSocketChannel(ScriptExecutionContext* context, WebSocketChannelClient* client)
    : m_context(context)
    , m_client(client)
    , m_buffer(0)

    Document* document = static_cast<Document*>(m_context);
    if (Settings* settings = document->settings())
        m_useHixie76Protocol = settings->useHixie76WebSocketProtocol();
    m_handshake = adoptPtr(new WebSocketHandshake(url, protocol, context, m_useHixie76Protocol));

    if (Page* page = document->page())
        m_identifier = page->progress()->createUniqueIdentifier();
    if (m_identifier)
        InspectorInstrumentation::didCreateWebSocket(m_context, m_identifier, url, m_context->url());
}

WebSocketChannel::~WebSocketChannel()

    return m_useHixie76Protocol;
}

void WebSocketChannel::connect(const KURL& url, const String& protocol)
{
    LOG(Network, "WebSocketChannel %p connect", this);
    ASSERT(!m_handle);
    ASSERT(!m_suspended);
    m_handshake = adoptPtr(new WebSocketHandshake(url, protocol, m_context, m_useHixie76Protocol));
    m_handshake->reset();
    if (m_identifier)
        InspectorInstrumentation::didCreateWebSocket(m_context, m_identifier, url, m_context->url());
    ref();
    m_handle = SocketStreamHandle::create(m_handshake->url(), this);
}



    class WebSocketChannel : public RefCounted<WebSocketChannel>, public SocketStreamHandleClient, public ThreadableWebSocketChannel {
        WTF_MAKE_FAST_ALLOCATED;
    public:
        static PassRefPtr<WebSocketChannel> create(ScriptExecutionContext* context, WebSocketChannelClient* client) { return adoptRef(new WebSocketChannel(context, client)); }
        virtual ~WebSocketChannel();

        virtual bool useHixie76Protocol();
        virtual void connect(const KURL&, const String& protocol);
        virtual bool send(const String& message);
        virtual unsigned long bufferedAmount() const;
        virtual void close(); // Start closing handshake.

        virtual void derefThreadableWebSocketChannel() { deref(); }

    private:
        WebSocketChannel(ScriptExecutionContext*, WebSocketChannelClient*);

        bool appendToBuffer(const char* data, size_t len);
        void skipBuffer(size_t len);




namespace WebCore {

WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerContext* context, WebSocketChannelClient* client, const String& taskMode)
    : m_workerContext(context)
    , m_workerClientWrapper(ThreadableWebSocketChannelClientWrapper::create(client))
    , m_bridge(Bridge::create(m_workerClientWrapper, m_workerContext, taskMode))
{
}


    return m_workerClientWrapper->useHixie76Protocol();
}

void WorkerThreadableWebSocketChannel::connect(const KURL& url, const String& protocol)
{
    if (m_bridge)
        m_bridge->connect(url, protocol);
}

bool WorkerThreadableWebSocketChannel::send(const String& message)

        m_bridge->resume();
}

WorkerThreadableWebSocketChannel::Peer::Peer(PassRefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode)
    : m_workerClientWrapper(clientWrapper)
    , m_loaderProxy(loaderProxy)
    , m_mainWebSocketChannel(WebSocketChannel::create(context, this))
    , m_taskMode(taskMode)
{
    ASSERT(isMainThread());

    return m_mainWebSocketChannel->useHixie76Protocol();
}

void WorkerThreadableWebSocketChannel::Peer::connect(const KURL& url, const String& protocol)
{
    ASSERT(isMainThread());
    if (!m_mainWebSocketChannel)
        return;
    m_mainWebSocketChannel->connect(url, protocol);
}

static void workerContextDidSend(ScriptExecutionContext* context, RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, bool sent)

    workerClientWrapper->setSyncMethodDone();
}

void WorkerThreadableWebSocketChannel::Bridge::mainThreadCreateWebSocketChannel(ScriptExecutionContext* context, Bridge* thisPtr, PassRefPtr<ThreadableWebSocketChannelClientWrapper> prpClientWrapper, const String& taskMode)
{
    ASSERT(isMainThread());
    ASSERT_UNUSED(context, context->isDocument());

    RefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper = prpClientWrapper;

    Peer* peer = Peer::create(clientWrapper, thisPtr->m_loaderProxy, context, taskMode);
    thisPtr->m_loaderProxy.postTaskForModeToWorkerContext(
        createCallbackTask(&Bridge::setWebSocketChannel,
                           AllowCrossThreadAccess(thisPtr),
                           AllowCrossThreadAccess(peer), clientWrapper, peer->useHixie76Protocol()), taskMode);
}

WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerContext> workerContext, const String& taskMode)
    : m_workerClientWrapper(workerClientWrapper)
    , m_workerContext(workerContext)
    , m_loaderProxy(m_workerContext->thread()->workerLoaderProxy())

    setMethodNotCompleted();
    m_loaderProxy.postTaskToLoader(
        createCallbackTask(&Bridge::mainThreadCreateWebSocketChannel,
                           AllowCrossThreadAccess(this), m_workerClientWrapper, m_taskMode));
    waitForMethodCompletion();
    ASSERT(m_peer);
}

    disconnect();
}

void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer, const KURL& url, const String& protocol)
{
    ASSERT(isMainThread());
    ASSERT_UNUSED(context, context->isDocument());
    ASSERT(peer);

    peer->connect(url, protocol);
}

void WorkerThreadableWebSocketChannel::Bridge::connect(const KURL& url, const String& protocol)
{
    ASSERT(m_workerClientWrapper);
    ASSERT(m_peer);
    m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadConnect, AllowCrossThreadAccess(m_peer), url, protocol));
}

void WorkerThreadableWebSocketChannel::mainThreadSend(ScriptExecutionContext* context, Peer* peer, const String& message)



class WorkerThreadableWebSocketChannel : public RefCounted<WorkerThreadableWebSocketChannel>, public ThreadableWebSocketChannel {
    WTF_MAKE_FAST_ALLOCATED;
public:
    static PassRefPtr<ThreadableWebSocketChannel> create(WorkerContext* workerContext, WebSocketChannelClient* client, const String& taskMode)
    {
        return adoptRef(new WorkerThreadableWebSocketChannel(workerContext, client, taskMode));
    }
    virtual ~WorkerThreadableWebSocketChannel();

    virtual bool useHixie76Protocol();
    virtual void connect(const KURL&, const String& protocol);
    virtual bool send(const String& message);
    virtual unsigned long bufferedAmount() const;
    virtual void close();

    class Peer : public WebSocketChannelClient {
        WTF_MAKE_NONCOPYABLE(Peer); WTF_MAKE_FAST_ALLOCATED;
    public:
        static Peer* create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode)
        {
            return new Peer(clientWrapper, loaderProxy, context, taskMode);
        }
        ~Peer();

        bool useHixie76Protocol();
        void connect(const KURL&, const String& protocol);
        void send(const String& message);
        void bufferedAmount();
        void close();

        virtual void didClose(unsigned long unhandledBufferedAmount, ClosingHandshakeCompletionStatus);

    private:
        Peer(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, WorkerLoaderProxy&, ScriptExecutionContext*, const String& taskMode);

        RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
        WorkerLoaderProxy& m_loaderProxy;

    // Bridge for Peer.  Running on the worker thread.
    class Bridge : public RefCounted<Bridge> {
    public:
        static PassRefPtr<Bridge> create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerContext> workerContext, const String& taskMode)
        {
            return adoptRef(new Bridge(workerClientWrapper, workerContext, taskMode));
        }
        ~Bridge();
        void connect(const KURL&, const String& protocol);
        bool send(const String& message);
        unsigned long bufferedAmount();
        void close();

        using RefCounted<Bridge>::deref;

    private:
        Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, PassRefPtr<WorkerContext>, const String& taskMode);

        static void setWebSocketChannel(ScriptExecutionContext*, Bridge* thisPtr, Peer*, PassRefPtr<ThreadableWebSocketChannelClientWrapper>, bool useHixie76Protocol);

        // Executed on the main thread to create a Peer for this bridge.
        static void mainThreadCreateWebSocketChannel(ScriptExecutionContext*, Bridge* thisPtr, PassRefPtr<ThreadableWebSocketChannelClientWrapper>, const String& taskMode);

        // Executed on the worker context's thread.
        void clearClientWrapper();

        Peer* m_peer;
    };

    WorkerThreadableWebSocketChannel(WorkerContext*, WebSocketChannelClient*, const String& taskMode);

    static void mainThreadConnect(ScriptExecutionContext*, Peer*, const KURL&, const String& protocol);
    static void mainThreadSend(ScriptExecutionContext*, Peer*, const String& message);
    static void mainThreadBufferedAmount(ScriptExecutionContext*, Peer*);
    static void mainThreadClose(ScriptExecutionContext*, Peer*);

Return to Bug 65367

Lines 50-56 namespace WebCore { a/Source/WebCore/websockets/ThreadableWebSocketChannel.cpp_sec1
- a/Source/WebCore/websockets/ThreadableWebSocketChannel.cpp -3 / +3 lines
50		50
51	static const char webSocketChannelMode[] = "webSocketChannelMode";	51	static const char webSocketChannelMode[] = "webSocketChannelMode";
52		52
53	PassRefPtr<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext* context, WebSocketChannelClient* client, const KURL& url, const String& protocol)	53	PassRefPtr<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
54	{	54	{
55	ASSERT(context);	55	ASSERT(context);
56	ASSERT(client);	56	ASSERT(client);
Lines 61-72 PassRefPtr<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(Script a/Source/WebCore/websockets/ThreadableWebSocketChannel.cpp_sec2
61	WorkerRunLoop& runLoop = workerContext->thread()->runLoop();	61	WorkerRunLoop& runLoop = workerContext->thread()->runLoop();
62	String mode = webSocketChannelMode;	62	String mode = webSocketChannelMode;
63	mode.append(String::number(runLoop.createUniqueId()));	63	mode.append(String::number(runLoop.createUniqueId()));
64	return WorkerThreadableWebSocketChannel::create(workerContext, client, mode, url, protocol);	64	return WorkerThreadableWebSocketChannel::create(workerContext, client, mode);
65	}	65	}
66	#endif // ENABLE(WORKERS)	66	#endif // ENABLE(WORKERS)
67		67
68	ASSERT(context->isDocument());	68	ASSERT(context->isDocument());
69	return WebSocketChannel::create(context, client, url, protocol);	69	return WebSocketChannel::create(context, client);
70	}	70	}
71		71
72	} // namespace WebCore	72	} // namespace WebCore

Lines 151-158 void WebSocket::connect(const String& url, const String& protocol, ExceptionCode a/Source/WebCore/websockets/WebSocket.cpp_sec1
- a/Source/WebCore/websockets/WebSocket.cpp -2 / +2 lines
151	return;	151	return;
152	}	152	}
153		153
154	m_channel = ThreadableWebSocketChannel::create(scriptExecutionContext(), this, m_url, m_protocol);	154	m_channel = ThreadableWebSocketChannel::create(scriptExecutionContext(), this);
155	m_channel->connect();	155	m_channel->connect(m_url, m_protocol);
156	ActiveDOMObject::setPendingActivity(this);	156	ActiveDOMObject::setPendingActivity(this);
157	}	157	}
158		158

Lines 82-88 const WebSocketChannel::OpCode WebSocketChannel::OpCodeClose = 0x8; a/Source/WebCore/websockets/WebSocketChannel.cpp_sec1
- a/Source/WebCore/websockets/WebSocketChannel.cpp -5 / +5 lines
82	const WebSocketChannel::OpCode WebSocketChannel::OpCodePing = 0x9;	82	const WebSocketChannel::OpCode WebSocketChannel::OpCodePing = 0x9;
83	const WebSocketChannel::OpCode WebSocketChannel::OpCodePong = 0xA;	83	const WebSocketChannel::OpCode WebSocketChannel::OpCodePong = 0xA;
84		84
85	WebSocketChannel::WebSocketChannel(ScriptExecutionContext* context, WebSocketChannelClient* client, const KURL& url, const String& protocol)	85	WebSocketChannel::WebSocketChannel(ScriptExecutionContext* context, WebSocketChannelClient* client)
86	: m_context(context)	86	: m_context(context)
87	, m_client(client)	87	, m_client(client)
88	, m_buffer(0)	88	, m_buffer(0)
Lines 103-114 WebSocketChannel::WebSocketChannel(ScriptExecutionContext* context, WebSocketCha a/Source/WebCore/websockets/WebSocketChannel.cpp_sec2
103	Document* document = static_cast<Document*>(m_context);	103	Document* document = static_cast<Document*>(m_context);
104	if (Settings* settings = document->settings())	104	if (Settings* settings = document->settings())
105	m_useHixie76Protocol = settings->useHixie76WebSocketProtocol();	105	m_useHixie76Protocol = settings->useHixie76WebSocketProtocol();
106	m_handshake = adoptPtr(new WebSocketHandshake(url, protocol, context, m_useHixie76Protocol));
107		106
108	if (Page* page = document->page())	107	if (Page* page = document->page())
109	m_identifier = page->progress()->createUniqueIdentifier();	108	m_identifier = page->progress()->createUniqueIdentifier();
110	if (m_identifier)
111	InspectorInstrumentation::didCreateWebSocket(m_context, m_identifier, url, m_context->url());
112	}	109	}
113		110
114	WebSocketChannel::~WebSocketChannel()	111	WebSocketChannel::~WebSocketChannel()
Lines 121-132 bool WebSocketChannel::useHixie76Protocol() a/Source/WebCore/websockets/WebSocketChannel.cpp_sec3
121	return m_useHixie76Protocol;	118	return m_useHixie76Protocol;
122	}	119	}
123		120
124	void WebSocketChannel::connect()	121	void WebSocketChannel::connect(const KURL& url, const String& protocol)
125	{	122	{
126	LOG(Network, "WebSocketChannel %p connect", this);	123	LOG(Network, "WebSocketChannel %p connect", this);
127	ASSERT(!m_handle);	124	ASSERT(!m_handle);
128	ASSERT(!m_suspended);	125	ASSERT(!m_suspended);
		126	m_handshake = adoptPtr(new WebSocketHandshake(url, protocol, m_context, m_useHixie76Protocol));
129	m_handshake->reset();	127	m_handshake->reset();
		128	if (m_identifier)
		129	InspectorInstrumentation::didCreateWebSocket(m_context, m_identifier, url, m_context->url());
130	ref();	130	ref();
131	m_handle = SocketStreamHandle::create(m_handshake->url(), this);	131	m_handle = SocketStreamHandle::create(m_handshake->url(), this);
132	}	132	}

Lines 51-61 namespace WebCore { a/Source/WebCore/websockets/WebSocketChannel.h_sec1
- a/Source/WebCore/websockets/WebSocketChannel.h -3 / +3 lines
51	class WebSocketChannel : public RefCounted<WebSocketChannel>, public SocketStreamHandleClient, public ThreadableWebSocketChannel {	51	class WebSocketChannel : public RefCounted<WebSocketChannel>, public SocketStreamHandleClient, public ThreadableWebSocketChannel {
52	WTF_MAKE_FAST_ALLOCATED;	52	WTF_MAKE_FAST_ALLOCATED;
53	public:	53	public:
54	static PassRefPtr<WebSocketChannel> create(ScriptExecutionContext* context, WebSocketChannelClient* client, const KURL& url, const String& protocol) { return adoptRef(new WebSocketChannel(context, client, url, protocol)); }	54	static PassRefPtr<WebSocketChannel> create(ScriptExecutionContext* context, WebSocketChannelClient* client) { return adoptRef(new WebSocketChannel(context, client)); }
55	virtual ~WebSocketChannel();	55	virtual ~WebSocketChannel();
56		56
57	virtual bool useHixie76Protocol();	57	virtual bool useHixie76Protocol();
58	virtual void connect();	58	virtual void connect(const KURL&, const String& protocol);
59	virtual bool send(const String& message);	59	virtual bool send(const String& message);
60	virtual unsigned long bufferedAmount() const;	60	virtual unsigned long bufferedAmount() const;
61	virtual void close(); // Start closing handshake.	61	virtual void close(); // Start closing handshake.
Lines 80-86 namespace WebCore { a/Source/WebCore/websockets/WebSocketChannel.h_sec2
80	virtual void derefThreadableWebSocketChannel() { deref(); }	80	virtual void derefThreadableWebSocketChannel() { deref(); }
81		81
82	private:	82	private:
83	WebSocketChannel(ScriptExecutionContext, WebSocketChannelClient, const KURL&, const String& protocol);	83	WebSocketChannel(ScriptExecutionContext, WebSocketChannelClient);
84		84
85	bool appendToBuffer(const char* data, size_t len);	85	bool appendToBuffer(const char* data, size_t len);
86	void skipBuffer(size_t len);	86	void skipBuffer(size_t len);

Lines 49-58 a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec1
- a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp -16 / +16 lines
49		49
50	namespace WebCore {	50	namespace WebCore {
51		51
52	WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerContext* context, WebSocketChannelClient* client, const String& taskMode, const KURL& url, const String& protocol)	52	WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerContext* context, WebSocketChannelClient* client, const String& taskMode)
53	: m_workerContext(context)	53	: m_workerContext(context)
54	, m_workerClientWrapper(ThreadableWebSocketChannelClientWrapper::create(client))	54	, m_workerClientWrapper(ThreadableWebSocketChannelClientWrapper::create(client))
55	, m_bridge(Bridge::create(m_workerClientWrapper, m_workerContext, taskMode, url, protocol))	55	, m_bridge(Bridge::create(m_workerClientWrapper, m_workerContext, taskMode))
56	{	56	{
57	}	57	}
58		58
Lines 68-77 bool WorkerThreadableWebSocketChannel::useHixie76Protocol() a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec2
68	return m_workerClientWrapper->useHixie76Protocol();	68	return m_workerClientWrapper->useHixie76Protocol();
69	}	69	}
70		70
71	void WorkerThreadableWebSocketChannel::connect()	71	void WorkerThreadableWebSocketChannel::connect(const KURL& url, const String& protocol)
72	{	72	{
73	if (m_bridge)	73	if (m_bridge)
74	m_bridge->connect();	74	m_bridge->connect(url, protocol);
75	}	75	}
76		76
77	bool WorkerThreadableWebSocketChannel::send(const String& message)	77	bool WorkerThreadableWebSocketChannel::send(const String& message)
Lines 120-129 void WorkerThreadableWebSocketChannel::resume() a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec3
120	m_bridge->resume();	120	m_bridge->resume();
121	}	121	}
122		122
123	WorkerThreadableWebSocketChannel::Peer::Peer(PassRefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode, const KURL& url, const String& protocol)	123	WorkerThreadableWebSocketChannel::Peer::Peer(PassRefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode)
124	: m_workerClientWrapper(clientWrapper)	124	: m_workerClientWrapper(clientWrapper)
125	, m_loaderProxy(loaderProxy)	125	, m_loaderProxy(loaderProxy)
126	, m_mainWebSocketChannel(WebSocketChannel::create(context, this, url, protocol))	126	, m_mainWebSocketChannel(WebSocketChannel::create(context, this))
127	, m_taskMode(taskMode)	127	, m_taskMode(taskMode)
128	{	128	{
129	ASSERT(isMainThread());	129	ASSERT(isMainThread());
Lines 143-154 bool WorkerThreadableWebSocketChannel::Peer::useHixie76Protocol() a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec4
143	return m_mainWebSocketChannel->useHixie76Protocol();	143	return m_mainWebSocketChannel->useHixie76Protocol();
144	}	144	}
145		145
146	void WorkerThreadableWebSocketChannel::Peer::connect()	146	void WorkerThreadableWebSocketChannel::Peer::connect(const KURL& url, const String& protocol)
147	{	147	{
148	ASSERT(isMainThread());	148	ASSERT(isMainThread());
149	if (!m_mainWebSocketChannel)	149	if (!m_mainWebSocketChannel)
150	return;	150	return;
151	m_mainWebSocketChannel->connect();	151	m_mainWebSocketChannel->connect(url, protocol);
152	}	152	}
153		153
154	static void workerContextDidSend(ScriptExecutionContext* context, RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, bool sent)	154	static void workerContextDidSend(ScriptExecutionContext* context, RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, bool sent)
Lines 279-299 void WorkerThreadableWebSocketChannel::Bridge::setWebSocketChannel(ScriptExecuti a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec5
279	workerClientWrapper->setSyncMethodDone();	279	workerClientWrapper->setSyncMethodDone();
280	}	280	}
281		281
282	void WorkerThreadableWebSocketChannel::Bridge::mainThreadCreateWebSocketChannel(ScriptExecutionContext* context, Bridge* thisPtr, PassRefPtr<ThreadableWebSocketChannelClientWrapper> prpClientWrapper, const String& taskMode, const KURL& url, const String& protocol)	282	void WorkerThreadableWebSocketChannel::Bridge::mainThreadCreateWebSocketChannel(ScriptExecutionContext* context, Bridge* thisPtr, PassRefPtr<ThreadableWebSocketChannelClientWrapper> prpClientWrapper, const String& taskMode)
283	{	283	{
284	ASSERT(isMainThread());	284	ASSERT(isMainThread());
285	ASSERT_UNUSED(context, context->isDocument());	285	ASSERT_UNUSED(context, context->isDocument());
286		286
287	RefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper = prpClientWrapper;	287	RefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper = prpClientWrapper;
288		288
289	Peer* peer = Peer::create(clientWrapper, thisPtr->m_loaderProxy, context, taskMode, url, protocol);	289	Peer* peer = Peer::create(clientWrapper, thisPtr->m_loaderProxy, context, taskMode);
290	thisPtr->m_loaderProxy.postTaskForModeToWorkerContext(	290	thisPtr->m_loaderProxy.postTaskForModeToWorkerContext(
291	createCallbackTask(&Bridge::setWebSocketChannel,	291	createCallbackTask(&Bridge::setWebSocketChannel,
292	AllowCrossThreadAccess(thisPtr),	292	AllowCrossThreadAccess(thisPtr),
293	AllowCrossThreadAccess(peer), clientWrapper, peer->useHixie76Protocol()), taskMode);	293	AllowCrossThreadAccess(peer), clientWrapper, peer->useHixie76Protocol()), taskMode);
294	}	294	}
295		295
296	WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerContext> workerContext, const String& taskMode, const KURL& url, const String& protocol)	296	WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerContext> workerContext, const String& taskMode)
297	: m_workerClientWrapper(workerClientWrapper)	297	: m_workerClientWrapper(workerClientWrapper)
298	, m_workerContext(workerContext)	298	, m_workerContext(workerContext)
299	, m_loaderProxy(m_workerContext->thread()->workerLoaderProxy())	299	, m_loaderProxy(m_workerContext->thread()->workerLoaderProxy())
Lines 304-310 WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketC a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec6
304	setMethodNotCompleted();	304	setMethodNotCompleted();
305	m_loaderProxy.postTaskToLoader(	305	m_loaderProxy.postTaskToLoader(
306	createCallbackTask(&Bridge::mainThreadCreateWebSocketChannel,	306	createCallbackTask(&Bridge::mainThreadCreateWebSocketChannel,
307	AllowCrossThreadAccess(this), m_workerClientWrapper, m_taskMode, url, protocol));	307	AllowCrossThreadAccess(this), m_workerClientWrapper, m_taskMode));
308	waitForMethodCompletion();	308	waitForMethodCompletion();
309	ASSERT(m_peer);	309	ASSERT(m_peer);
310	}	310	}
Lines 314-333 WorkerThreadableWebSocketChannel::Bridge::~Bridge() a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp_sec7
314	disconnect();	314	disconnect();
315	}	315	}
316		316
317	void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer)	317	void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer, const KURL& url, const String& protocol)
318	{	318	{
319	ASSERT(isMainThread());	319	ASSERT(isMainThread());
320	ASSERT_UNUSED(context, context->isDocument());	320	ASSERT_UNUSED(context, context->isDocument());
321	ASSERT(peer);	321	ASSERT(peer);
322		322
323	peer->connect();	323	peer->connect(url, protocol);
324	}	324	}
325		325
326	void WorkerThreadableWebSocketChannel::Bridge::connect()	326	void WorkerThreadableWebSocketChannel::Bridge::connect(const KURL& url, const String& protocol)
327	{	327	{
328	ASSERT(m_workerClientWrapper);	328	ASSERT(m_workerClientWrapper);
329	ASSERT(m_peer);	329	ASSERT(m_peer);
330	m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadConnect, AllowCrossThreadAccess(m_peer)));	330	m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadConnect, AllowCrossThreadAccess(m_peer), url, protocol));
331	}	331	}
332		332
333	void WorkerThreadableWebSocketChannel::mainThreadSend(ScriptExecutionContext* context, Peer* peer, const String& message)	333	void WorkerThreadableWebSocketChannel::mainThreadSend(ScriptExecutionContext* context, Peer* peer, const String& message)

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +49 lines
		1	2011-08-01 Yuta Kitamura <yutak@chromium.org>
		2
		3	WebSocket: Receive URL and subprotocol in WebSocketChannel::connect()
		4	https://bugs.webkit.org/show_bug.cgi?id=65367
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	To implement multiple subprotocols support (bug 65247), WebSocket::connect() will need to validate
		9	the value of subprotocols after constructing WebSocketChannel, because the result depends on which
		10	WebSocket protocol is used, which is obtained from WebSocketChannel::useHixie76Protocol(). This
		11	means the subprotocol value will not be available at the time of WebSocketChannel construction.
		12
		13	This change moves URL and subprotocol arguments in WebSocketChannel constructor to
		14	WebSocketChannel::connect(), which allows WebSocket::connect() function to check the subprotocol
		15	value before the actual connection is established.
		16
		17	Relocating URL argument is technically not necessary, but seemed legitimate in terms of functional
		18	correspondence between WebSocket and WebSocketChannel (constructor versus connect()).
		19
		20	No change in behavior, thus no new tests.
		21
		22	* websockets/ThreadableWebSocketChannel.cpp:
		23	Remove "url" and "protocol" arguments from constructor and add them in connect().
		24	(WebCore::ThreadableWebSocketChannel::create):
		25	* websockets/ThreadableWebSocketChannel.h:
		26	* websockets/WebSocket.cpp:
		27	(WebCore::WebSocket::connect):
		28	* websockets/WebSocketChannel.cpp: Same as ThreadableWebSocketChannel.
		29	(WebCore::WebSocketChannel::WebSocketChannel):
		30	(WebCore::WebSocketChannel::connect):
		31	InspectorInstrumentation::didCreateWebSocket() call was moved to connect() because it needs URL.
		32	This does not change behavior, because connect() is guaranteed to be called immediately after
		33	WebSocketChannel is constructed.
		34	* websockets/WebSocketChannel.h:
		35	(WebCore::WebSocketChannel::create):
		36	* websockets/WorkerThreadableWebSocketChannel.cpp: Same as ThreadableWebSocketChannel.
		37	(WebCore::WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel):
		38	(WebCore::WorkerThreadableWebSocketChannel::connect):
		39	(WebCore::WorkerThreadableWebSocketChannel::Peer::Peer):
		40	(WebCore::WorkerThreadableWebSocketChannel::Peer::connect):
		41	(WebCore::WorkerThreadableWebSocketChannel::Bridge::mainThreadCreateWebSocketChannel):
		42	(WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
		43	(WebCore::WorkerThreadableWebSocketChannel::mainThreadConnect):
		44	(WebCore::WorkerThreadableWebSocketChannel::Bridge::connect):
		45	* websockets/WorkerThreadableWebSocketChannel.h:
		46	(WebCore::WorkerThreadableWebSocketChannel::create):
		47	(WebCore::WorkerThreadableWebSocketChannel::Peer::create):
		48	(WebCore::WorkerThreadableWebSocketChannel::Bridge::create):
		49
1	2011-07-28 Leandro Gracia Gil <leandrogracia@chromium.org>	50	2011-07-28 Leandro Gracia Gil <leandrogracia@chromium.org>
2		51
3	Fix speech input icon rect on RTL directions.	52	Fix speech input icon rect on RTL directions.

Lines 47-56 class ThreadableWebSocketChannel { a/Source/WebCore/websockets/ThreadableWebSocketChannel.h_sec1
- a/Source/WebCore/websockets/ThreadableWebSocketChannel.h -2 / +2 lines
47	WTF_MAKE_NONCOPYABLE(ThreadableWebSocketChannel);	47	WTF_MAKE_NONCOPYABLE(ThreadableWebSocketChannel);
48	public:	48	public:
49	ThreadableWebSocketChannel() { }	49	ThreadableWebSocketChannel() { }
50	static PassRefPtr<ThreadableWebSocketChannel> create(ScriptExecutionContext, WebSocketChannelClient, const KURL&, const String& protocol);	50	static PassRefPtr<ThreadableWebSocketChannel> create(ScriptExecutionContext, WebSocketChannelClient);
51		51
52	virtual bool useHixie76Protocol() = 0;	52	virtual bool useHixie76Protocol() = 0;
53	virtual void connect() = 0;	53	virtual void connect(const KURL&, const String& protocol) = 0;
54	virtual bool send(const String& message) = 0;	54	virtual bool send(const String& message) = 0;
55	virtual unsigned long bufferedAmount() const = 0;	55	virtual unsigned long bufferedAmount() const = 0;
56	virtual void close() = 0;	56	virtual void close() = 0;

Lines 54-67 class WorkerRunLoop; a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h_sec1
- a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h -14 / +14 lines
54	class WorkerThreadableWebSocketChannel : public RefCounted<WorkerThreadableWebSocketChannel>, public ThreadableWebSocketChannel {	54	class WorkerThreadableWebSocketChannel : public RefCounted<WorkerThreadableWebSocketChannel>, public ThreadableWebSocketChannel {
55	WTF_MAKE_FAST_ALLOCATED;	55	WTF_MAKE_FAST_ALLOCATED;
56	public:	56	public:
57	static PassRefPtr<ThreadableWebSocketChannel> create(WorkerContext* workerContext, WebSocketChannelClient* client, const String& taskMode, const KURL& url, const String& protocol)	57	static PassRefPtr<ThreadableWebSocketChannel> create(WorkerContext* workerContext, WebSocketChannelClient* client, const String& taskMode)
58	{	58	{
59	return adoptRef(new WorkerThreadableWebSocketChannel(workerContext, client, taskMode, url, protocol));	59	return adoptRef(new WorkerThreadableWebSocketChannel(workerContext, client, taskMode));
60	}	60	}
61	virtual ~WorkerThreadableWebSocketChannel();	61	virtual ~WorkerThreadableWebSocketChannel();
62		62
63	virtual bool useHixie76Protocol();	63	virtual bool useHixie76Protocol();
64	virtual void connect();	64	virtual void connect(const KURL&, const String& protocol);
65	virtual bool send(const String& message);	65	virtual bool send(const String& message);
66	virtual unsigned long bufferedAmount() const;	66	virtual unsigned long bufferedAmount() const;
67	virtual void close();	67	virtual void close();
Lines 83-96 private: a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h_sec2
83	class Peer : public WebSocketChannelClient {	83	class Peer : public WebSocketChannelClient {
84	WTF_MAKE_NONCOPYABLE(Peer); WTF_MAKE_FAST_ALLOCATED;	84	WTF_MAKE_NONCOPYABLE(Peer); WTF_MAKE_FAST_ALLOCATED;
85	public:	85	public:
86	static Peer* create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode, const KURL& url, const String& protocol)	86	static Peer* create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode)
87	{	87	{
88	return new Peer(clientWrapper, loaderProxy, context, taskMode, url, protocol);	88	return new Peer(clientWrapper, loaderProxy, context, taskMode);
89	}	89	}
90	~Peer();	90	~Peer();
91		91
92	bool useHixie76Protocol();	92	bool useHixie76Protocol();
93	void connect();	93	void connect(const KURL&, const String& protocol);
94	void send(const String& message);	94	void send(const String& message);
95	void bufferedAmount();	95	void bufferedAmount();
96	void close();	96	void close();
Lines 105-111 private: a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h_sec3
105	virtual void didClose(unsigned long unhandledBufferedAmount, ClosingHandshakeCompletionStatus);	105	virtual void didClose(unsigned long unhandledBufferedAmount, ClosingHandshakeCompletionStatus);
106		106
107	private:	107	private:
108	Peer(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, WorkerLoaderProxy&, ScriptExecutionContext*, const String& taskMode, const KURL&, const String& protocol);	108	Peer(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, WorkerLoaderProxy&, ScriptExecutionContext*, const String& taskMode);
109		109
110	RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;	110	RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
111	WorkerLoaderProxy& m_loaderProxy;	111	WorkerLoaderProxy& m_loaderProxy;
Lines 116-127 private: a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h_sec4
116	// Bridge for Peer. Running on the worker thread.	116	// Bridge for Peer. Running on the worker thread.
117	class Bridge : public RefCounted<Bridge> {	117	class Bridge : public RefCounted<Bridge> {
118	public:	118	public:
119	static PassRefPtr<Bridge> create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerContext> workerContext, const String& taskMode, const KURL& url, const String& protocol)	119	static PassRefPtr<Bridge> create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerContext> workerContext, const String& taskMode)
120	{	120	{
121	return adoptRef(new Bridge(workerClientWrapper, workerContext, taskMode, url, protocol));	121	return adoptRef(new Bridge(workerClientWrapper, workerContext, taskMode));
122	}	122	}
123	~Bridge();	123	~Bridge();
124	void connect();	124	void connect(const KURL&, const String& protocol);
125	bool send(const String& message);	125	bool send(const String& message);
126	unsigned long bufferedAmount();	126	unsigned long bufferedAmount();
127	void close();	127	void close();
Lines 134-145 private: a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h_sec5
134	using RefCounted<Bridge>::deref;	134	using RefCounted<Bridge>::deref;
135		135
136	private:	136	private:
137	Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, PassRefPtr<WorkerContext>, const String& taskMode, const KURL&, const String& protocol);	137	Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, PassRefPtr<WorkerContext>, const String& taskMode);
138		138
139	static void setWebSocketChannel(ScriptExecutionContext, Bridge thisPtr, Peer*, PassRefPtr<ThreadableWebSocketChannelClientWrapper>, bool useHixie76Protocol);	139	static void setWebSocketChannel(ScriptExecutionContext, Bridge thisPtr, Peer*, PassRefPtr<ThreadableWebSocketChannelClientWrapper>, bool useHixie76Protocol);
140		140
141	// Executed on the main thread to create a Peer for this bridge.	141	// Executed on the main thread to create a Peer for this bridge.
142	static void mainThreadCreateWebSocketChannel(ScriptExecutionContext, Bridge thisPtr, PassRefPtr<ThreadableWebSocketChannelClientWrapper>, const String& taskMode, const KURL&, const String& protocol);	142	static void mainThreadCreateWebSocketChannel(ScriptExecutionContext, Bridge thisPtr, PassRefPtr<ThreadableWebSocketChannelClientWrapper>, const String& taskMode);
143		143
144	// Executed on the worker context's thread.	144	// Executed on the worker context's thread.
145	void clearClientWrapper();	145	void clearClientWrapper();
Lines 154-162 private: a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.h_sec6
154	Peer* m_peer;	154	Peer* m_peer;
155	};	155	};
156		156
157	WorkerThreadableWebSocketChannel(WorkerContext, WebSocketChannelClient, const String& taskMode, const KURL&, const String& protocol);	157	WorkerThreadableWebSocketChannel(WorkerContext, WebSocketChannelClient, const String& taskMode);
158		158
159	static void mainThreadConnect(ScriptExecutionContext, Peer);	159	static void mainThreadConnect(ScriptExecutionContext, Peer, const KURL&, const String& protocol);
160	static void mainThreadSend(ScriptExecutionContext, Peer, const String& message);	160	static void mainThreadSend(ScriptExecutionContext, Peer, const String& message);
161	static void mainThreadBufferedAmount(ScriptExecutionContext, Peer);	161	static void mainThreadBufferedAmount(ScriptExecutionContext, Peer);
162	static void mainThreadClose(ScriptExecutionContext, Peer);	162	static void mainThreadClose(ScriptExecutionContext, Peer);