[WebSocket] Make subprotocol and extensions live in WebSocket

Source/modules/websockets/WebSocketTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "modules/websockets/WebSocket.h"
 
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/V8Binding.h"
@@ skipping 28 matching lines @@
     static PassRefPtrWillBeRawPtr<MockWebSocketChannel> create()
     {
         return adoptRefWillBeRefCountedGarbageCollected(new testing::StrictMock<MockWebSocketChannel>());
     }
 
     virtual ~MockWebSocketChannel()
     {
     }
 
     MOCK_METHOD2(connect, bool(const KURL&, const String&));
-    MOCK_METHOD0(subprotocol, String());
-    MOCK_METHOD0(extensions, String());
     MOCK_METHOD1(send, SendResult(const String&));
     MOCK_METHOD3(send, SendResult(const ArrayBuffer&, unsigned, unsigned));
     MOCK_METHOD1(send, SendResult(PassRefPtr<BlobDataHandle>));
     MOCK_METHOD1(send, SendResult(PassOwnPtr<Vector<char> >));
     MOCK_CONST_METHOD0(bufferedAmount, unsigned long());
     MOCK_METHOD2(close, void(int, const String&));
     MOCK_METHOD4(fail, void(const String&, MessageLevel, const String&, unsigned));
     MOCK_METHOD0(disconnect, void());
     MOCK_METHOD0(suspend, void());
     MOCK_METHOD0(resume, void());
@@ skipping 203 matching lines @@
 }
 
 TEST_F(WebSocketTest, connectSuccess)
 {
     Vector<String> subprotocols;
     subprotocols.append("aa");
     subprotocols.append("bb");
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String("bb")));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String("cc")));
     }
     m_websocket->connect("ws://example.com/", subprotocols, m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("bb", "cc");
 
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     EXPECT_EQ("bb", m_websocket->protocol());
     EXPECT_EQ("cc", m_websocket->extensions());
 }
 
 TEST_F(WebSocketTest, didClose)
 {
     {
         InSequence s;
@@ skipping 69 matching lines @@
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, close)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), close(3005, String("bye")));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(3005, "bye", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWithoutReason)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), close(3005, String()));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(3005, m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWithoutCodeAndReason)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), close(-1, String()));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWhenClosing)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), close(-1, String()));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 
     m_websocket->close(m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, closeWhenClosed)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), close(-1, String()));
         EXPECT_CALL(channel(), disconnect());
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSING, m_websocket->readyState());
 
     m_websocket->didClose(0, WebSocketChannelClient::ClosingHandshakeComplete, 1000, String());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
     m_websocket->close(m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
@@ skipping 59 matching lines @@
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringSuccess)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), send(String("hello"))).WillOnce(Return(WebSocketChannel::SendSuccess));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringFail)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), send(String("hello"))).WillOnce(Return(WebSocketChannel::SendFail));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendStringInvalidMessage)
 {
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), send(String("hello"))).WillOnce(Return(WebSocketChannel::InvalidMessage));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     m_websocket->send("hello", m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SyntaxError, m_exceptionState.code());
     EXPECT_EQ("The message contains invalid characters.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferWhenConnecting)
 {
@@ skipping 57 matching lines @@
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::CLOSED, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferSuccess)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::SendSuccess));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferFail)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::SendFail));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 TEST_F(WebSocketTest, sendArrayBufferInvalidMessage)
 {
     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
     {
         InSequence s;
         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
-        EXPECT_CALL(channel(), subprotocol()).WillOnce(Return(String()));
-        EXPECT_CALL(channel(), extensions()).WillOnce(Return(String()));
         EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8)).WillOnce(Return(WebSocketChannel::InvalidMessage));
     }
     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 
     EXPECT_FALSE(m_exceptionState.hadException());
 
-    m_websocket->didConnect();
+    m_websocket->didConnect("", "");
     m_websocket->send(view->buffer().get(), m_exceptionState);
 
     EXPECT_TRUE(m_exceptionState.hadException());
     EXPECT_EQ(SyntaxError, m_exceptionState.code());
     EXPECT_EQ("The message contains invalid characters.", m_exceptionState.message());
     EXPECT_EQ(WebSocket::OPEN, m_websocket->readyState());
 }
 
 // FIXME: We should have Blob tests here.
 // We can't create a Blob because the blob registration cannot be mocked yet.
@@ skipping 70 matching lines @@
     EXPECT_EQ(InvalidAccessError, m_exceptionState.code());
     EXPECT_EQ(String::format("The code must be either 1000, or between 3000 and 4999. %d is neither.", GetParam()), m_exceptionState.message());
     EXPECT_EQ(WebSocket::CONNECTING, m_websocket->readyState());
 }
 
 INSTANTIATE_TEST_CASE_P(WebSocketInvalidClosingCode, WebSocketInvalidClosingCodeTest, ::testing::Values(0, 1, 998, 999, 1001, 2999, 5000, 9999, 65535));
 
 } // namespace
 
 } // namespace WebCore