| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "config.h" | |
| 6 #include "modules/websockets/WebSocketChannel.h" | |
| 7 | |
| 8 #include "core/dom/Document.h" | |
| 9 #include "core/fileapi/Blob.h" | |
| 10 #include "core/frame/ConsoleTypes.h" | |
| 11 #include "core/testing/DummyPageHolder.h" | |
| 12 #include "modules/websockets/NewWebSocketChannelImpl.h" | |
| 13 #include "modules/websockets/WebSocketChannelClient.h" | |
| 14 #include "platform/heap/Handle.h" | |
| 15 #include "platform/weborigin/KURL.h" | |
| 16 #include "public/platform/WebSerializedOrigin.h" | |
| 17 #include "public/platform/WebSocketHandle.h" | |
| 18 #include "public/platform/WebSocketHandleClient.h" | |
| 19 #include "public/platform/WebString.h" | |
| 20 #include "public/platform/WebURL.h" | |
| 21 #include "public/platform/WebVector.h" | |
| 22 #include "wtf/ArrayBuffer.h" | |
| 23 #include "wtf/OwnPtr.h" | |
| 24 #include "wtf/Vector.h" | |
| 25 #include "wtf/text/WTFString.h" | |
| 26 | |
| 27 #include <gmock/gmock.h> | |
| 28 #include <gtest/gtest.h> | |
| 29 | |
| 30 using testing::_; | |
| 31 using testing::InSequence; | |
| 32 using testing::PrintToString; | |
| 33 using testing::AnyNumber; | |
| 34 | |
| 35 | |
| 36 namespace blink { | |
| 37 | |
| 38 namespace { | |
| 39 | |
| 40 typedef testing::StrictMock< testing::MockFunction<void(int)> > Checkpoint; | |
| 41 | |
| 42 class MockWebSocketChannelClient : public GarbageCollectedFinalized<MockWebSocke
tChannelClient>, public WebSocketChannelClient { | |
| 43 USING_GARBAGE_COLLECTED_MIXIN(MockWebSocketChannelClient); | |
| 44 public: | |
| 45 static MockWebSocketChannelClient* create() | |
| 46 { | |
| 47 return new testing::StrictMock<MockWebSocketChannelClient>(); | |
| 48 } | |
| 49 | |
| 50 MockWebSocketChannelClient() { } | |
| 51 | |
| 52 virtual ~MockWebSocketChannelClient() { } | |
| 53 | |
| 54 MOCK_METHOD2(didConnect, void(const String&, const String&)); | |
| 55 MOCK_METHOD1(didReceiveTextMessage, void(const String&)); | |
| 56 virtual void didReceiveBinaryMessage(PassOwnPtr<Vector<char> > payload) over
ride | |
| 57 { | |
| 58 didReceiveBinaryMessageMock(*payload); | |
| 59 } | |
| 60 MOCK_METHOD1(didReceiveBinaryMessageMock, void(const Vector<char>&)); | |
| 61 MOCK_METHOD0(didError, void()); | |
| 62 MOCK_METHOD1(didConsumeBufferedAmount, void(unsigned long)); | |
| 63 MOCK_METHOD0(didStartClosingHandshake, void()); | |
| 64 MOCK_METHOD3(didClose, void(ClosingHandshakeCompletionStatus, unsigned short
, const String&)); | |
| 65 | |
| 66 virtual void trace(Visitor* visitor) override | |
| 67 { | |
| 68 WebSocketChannelClient::trace(visitor); | |
| 69 } | |
| 70 | |
| 71 }; | |
| 72 | |
| 73 class MockWebSocketHandle : public WebSocketHandle { | |
| 74 public: | |
| 75 static MockWebSocketHandle* create() | |
| 76 { | |
| 77 return new testing::StrictMock<MockWebSocketHandle>(); | |
| 78 } | |
| 79 | |
| 80 MockWebSocketHandle() { } | |
| 81 | |
| 82 virtual ~MockWebSocketHandle() { } | |
| 83 | |
| 84 MOCK_METHOD4(connect, void(const WebURL&, const WebVector<WebString>&, const
WebSerializedOrigin&, WebSocketHandleClient*)); | |
| 85 MOCK_METHOD4(send, void(bool, WebSocketHandle::MessageType, const char*, siz
e_t)); | |
| 86 MOCK_METHOD1(flowControl, void(int64_t)); | |
| 87 MOCK_METHOD2(close, void(unsigned short, const WebString&)); | |
| 88 }; | |
| 89 | |
| 90 class NewWebSocketChannelImplTest : public ::testing::Test { | |
| 91 public: | |
| 92 NewWebSocketChannelImplTest() | |
| 93 : m_pageHolder(DummyPageHolder::create()) | |
| 94 , m_channelClient(MockWebSocketChannelClient::create()) | |
| 95 , m_handle(MockWebSocketHandle::create()) | |
| 96 , m_channel(NewWebSocketChannelImpl::create(&m_pageHolder->document(), m
_channelClient.get(), String(), 0, handle())) | |
| 97 , m_sumOfConsumedBufferedAmount(0) | |
| 98 { | |
| 99 ON_CALL(*channelClient(), didConsumeBufferedAmount(_)).WillByDefault(Inv
oke(this, &NewWebSocketChannelImplTest::didConsumeBufferedAmount)); | |
| 100 } | |
| 101 | |
| 102 ~NewWebSocketChannelImplTest() | |
| 103 { | |
| 104 channel()->disconnect(); | |
| 105 } | |
| 106 | |
| 107 MockWebSocketChannelClient* channelClient() | |
| 108 { | |
| 109 return m_channelClient.get(); | |
| 110 } | |
| 111 | |
| 112 WebSocketChannel* channel() | |
| 113 { | |
| 114 return static_cast<WebSocketChannel*>(m_channel.get()); | |
| 115 } | |
| 116 | |
| 117 WebSocketHandleClient* handleClient() | |
| 118 { | |
| 119 return static_cast<WebSocketHandleClient*>(m_channel.get()); | |
| 120 } | |
| 121 | |
| 122 MockWebSocketHandle* handle() | |
| 123 { | |
| 124 return m_handle; | |
| 125 } | |
| 126 | |
| 127 void didConsumeBufferedAmount(unsigned long a) | |
| 128 { | |
| 129 m_sumOfConsumedBufferedAmount += a; | |
| 130 } | |
| 131 | |
| 132 void connect() | |
| 133 { | |
| 134 { | |
| 135 InSequence s; | |
| 136 EXPECT_CALL(*handle(), connect(WebURL(KURL(KURL(), "ws://localhost/"
)), _, _, handleClient())); | |
| 137 EXPECT_CALL(*handle(), flowControl(65536)); | |
| 138 EXPECT_CALL(*channelClient(), didConnect(String("a"), String("b"))); | |
| 139 } | |
| 140 EXPECT_TRUE(channel()->connect(KURL(KURL(), "ws://localhost/"), "x")); | |
| 141 handleClient()->didConnect(handle(), false, WebString("a"), WebString("b
")); | |
| 142 ::testing::Mock::VerifyAndClearExpectations(this); | |
| 143 } | |
| 144 | |
| 145 OwnPtr<DummyPageHolder> m_pageHolder; | |
| 146 Persistent<MockWebSocketChannelClient> m_channelClient; | |
| 147 MockWebSocketHandle* m_handle; | |
| 148 Persistent<NewWebSocketChannelImpl> m_channel; | |
| 149 unsigned long m_sumOfConsumedBufferedAmount; | |
| 150 }; | |
| 151 | |
| 152 MATCHER_P2(MemEq, p, len, | |
| 153 std::string("pointing to memory") | |
| 154 + (negation ? " not" : "") | |
| 155 + " equal to \"" | |
| 156 + std::string(p, len) + "\" (length=" + PrintToString(len) + ")" | |
| 157 ) | |
| 158 { | |
| 159 return memcmp(arg, p, len) == 0; | |
| 160 } | |
| 161 | |
| 162 TEST_F(NewWebSocketChannelImplTest, connectSuccess) | |
| 163 { | |
| 164 Checkpoint checkpoint; | |
| 165 { | |
| 166 InSequence s; | |
| 167 EXPECT_CALL(*handle(), connect(WebURL(KURL(KURL(), "ws://localhost/")),
_, _, handleClient())); | |
| 168 EXPECT_CALL(*handle(), flowControl(65536)); | |
| 169 EXPECT_CALL(checkpoint, Call(1)); | |
| 170 EXPECT_CALL(*channelClient(), didConnect(String("a"), String("b"))); | |
| 171 } | |
| 172 | |
| 173 EXPECT_TRUE(channel()->connect(KURL(KURL(), "ws://localhost/"), "x")); | |
| 174 checkpoint.Call(1); | |
| 175 handleClient()->didConnect(handle(), false, WebString("a"), WebString("b")); | |
| 176 } | |
| 177 | |
| 178 TEST_F(NewWebSocketChannelImplTest, sendText) | |
| 179 { | |
| 180 connect(); | |
| 181 { | |
| 182 InSequence s; | |
| 183 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText, MemE
q("foo", 3), 3)); | |
| 184 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText, MemE
q("bar", 3), 3)); | |
| 185 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText, MemE
q("baz", 3), 3)); | |
| 186 } | |
| 187 | |
| 188 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 189 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 190 | |
| 191 channel()->send("foo"); | |
| 192 channel()->send("bar"); | |
| 193 channel()->send("baz"); | |
| 194 | |
| 195 EXPECT_EQ(9ul, m_sumOfConsumedBufferedAmount); | |
| 196 } | |
| 197 | |
| 198 TEST_F(NewWebSocketChannelImplTest, sendTextContinuation) | |
| 199 { | |
| 200 connect(); | |
| 201 Checkpoint checkpoint; | |
| 202 { | |
| 203 InSequence s; | |
| 204 EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeText, Mem
Eq("0123456789abcdef", 16), 16)); | |
| 205 EXPECT_CALL(checkpoint, Call(1)); | |
| 206 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuati
on, MemEq("g", 1), 1)); | |
| 207 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText, MemE
q("hijk", 4), 4)); | |
| 208 EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeText, Mem
Eq("lmnopqrstuv", 11), 11)); | |
| 209 EXPECT_CALL(checkpoint, Call(2)); | |
| 210 EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeContinuat
ion, MemEq("wxyzABCDEFGHIJKL", 16), 16)); | |
| 211 EXPECT_CALL(checkpoint, Call(3)); | |
| 212 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuati
on, MemEq("MNOPQRSTUVWXYZ", 14), 14)); | |
| 213 } | |
| 214 | |
| 215 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 216 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 217 | |
| 218 channel()->send("0123456789abcdefg"); | |
| 219 channel()->send("hijk"); | |
| 220 channel()->send("lmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); | |
| 221 checkpoint.Call(1); | |
| 222 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 223 checkpoint.Call(2); | |
| 224 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 225 checkpoint.Call(3); | |
| 226 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 227 | |
| 228 EXPECT_EQ(62ul, m_sumOfConsumedBufferedAmount); | |
| 229 } | |
| 230 | |
| 231 TEST_F(NewWebSocketChannelImplTest, sendTextNonLatin1) | |
| 232 { | |
| 233 connect(); | |
| 234 { | |
| 235 InSequence s; | |
| 236 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText, MemE
q("\xe7\x8b\x90\xe0\xa4\x94", 6), 6)); | |
| 237 } | |
| 238 | |
| 239 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 240 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 241 | |
| 242 UChar nonLatin1String[] = { | |
| 243 0x72d0, | |
| 244 0x0914, | |
| 245 0x0000 | |
| 246 }; | |
| 247 channel()->send(nonLatin1String); | |
| 248 | |
| 249 EXPECT_EQ(6ul, m_sumOfConsumedBufferedAmount); | |
| 250 } | |
| 251 | |
| 252 TEST_F(NewWebSocketChannelImplTest, sendTextNonLatin1Continuation) | |
| 253 { | |
| 254 connect(); | |
| 255 Checkpoint checkpoint; | |
| 256 { | |
| 257 InSequence s; | |
| 258 EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeText, Mem
Eq("\xe7\x8b\x90\xe0\xa4\x94\xe7\x8b\x90\xe0\xa4\x94\xe7\x8b\x90\xe0", 16), 16))
; | |
| 259 EXPECT_CALL(checkpoint, Call(1)); | |
| 260 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuati
on, MemEq("\xa4\x94", 2), 2)); | |
| 261 } | |
| 262 | |
| 263 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 264 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 265 | |
| 266 UChar nonLatin1String[] = { | |
| 267 0x72d0, | |
| 268 0x0914, | |
| 269 0x72d0, | |
| 270 0x0914, | |
| 271 0x72d0, | |
| 272 0x0914, | |
| 273 0x0000 | |
| 274 }; | |
| 275 channel()->send(nonLatin1String); | |
| 276 checkpoint.Call(1); | |
| 277 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 278 | |
| 279 EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount); | |
| 280 } | |
| 281 | |
| 282 TEST_F(NewWebSocketChannelImplTest, sendBinaryInVector) | |
| 283 { | |
| 284 connect(); | |
| 285 { | |
| 286 InSequence s; | |
| 287 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("foo", 3), 3)); | |
| 288 } | |
| 289 | |
| 290 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 291 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 292 | |
| 293 Vector<char> fooVector; | |
| 294 fooVector.append("foo", 3); | |
| 295 channel()->send(adoptPtr(new Vector<char>(fooVector))); | |
| 296 | |
| 297 EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount); | |
| 298 } | |
| 299 | |
| 300 TEST_F(NewWebSocketChannelImplTest, sendBinaryInVectorWithNullBytes) | |
| 301 { | |
| 302 connect(); | |
| 303 { | |
| 304 InSequence s; | |
| 305 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("\0ar", 3), 3)); | |
| 306 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("b\0z", 3), 3)); | |
| 307 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("qu\0", 3), 3)); | |
| 308 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("\0\0\0", 3), 3)); | |
| 309 } | |
| 310 | |
| 311 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 312 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 313 | |
| 314 { | |
| 315 Vector<char> v; | |
| 316 v.append("\0ar", 3); | |
| 317 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 318 } | |
| 319 { | |
| 320 Vector<char> v; | |
| 321 v.append("b\0z", 3); | |
| 322 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 323 } | |
| 324 { | |
| 325 Vector<char> v; | |
| 326 v.append("qu\0", 3); | |
| 327 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 328 } | |
| 329 { | |
| 330 Vector<char> v; | |
| 331 v.append("\0\0\0", 3); | |
| 332 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 333 } | |
| 334 | |
| 335 EXPECT_EQ(12ul, m_sumOfConsumedBufferedAmount); | |
| 336 } | |
| 337 | |
| 338 TEST_F(NewWebSocketChannelImplTest, sendBinaryInVectorNonLatin1UTF8) | |
| 339 { | |
| 340 connect(); | |
| 341 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq(
"\xe7\x8b\x90", 3), 3)); | |
| 342 | |
| 343 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 344 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 345 | |
| 346 Vector<char> v; | |
| 347 v.append("\xe7\x8b\x90", 3); | |
| 348 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 349 | |
| 350 EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount); | |
| 351 } | |
| 352 | |
| 353 TEST_F(NewWebSocketChannelImplTest, sendBinaryInVectorNonUTF8) | |
| 354 { | |
| 355 connect(); | |
| 356 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq(
"\x80\xff\xe7", 3), 3)); | |
| 357 | |
| 358 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 359 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 360 | |
| 361 Vector<char> v; | |
| 362 v.append("\x80\xff\xe7", 3); | |
| 363 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 364 | |
| 365 EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount); | |
| 366 } | |
| 367 | |
| 368 TEST_F(NewWebSocketChannelImplTest, sendBinaryInVectorNonLatin1UTF8Continuation) | |
| 369 { | |
| 370 connect(); | |
| 371 Checkpoint checkpoint; | |
| 372 { | |
| 373 InSequence s; | |
| 374 EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeBinary, M
emEq("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7", 16), 16
)); | |
| 375 EXPECT_CALL(checkpoint, Call(1)); | |
| 376 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuati
on, MemEq("\x8b\x90", 2), 2)); | |
| 377 } | |
| 378 | |
| 379 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 380 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 381 | |
| 382 Vector<char> v; | |
| 383 v.append("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x
8b\x90", 18); | |
| 384 channel()->send(adoptPtr(new Vector<char>(v))); | |
| 385 checkpoint.Call(1); | |
| 386 | |
| 387 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 388 | |
| 389 EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount); | |
| 390 } | |
| 391 | |
| 392 TEST_F(NewWebSocketChannelImplTest, sendBinaryInArrayBuffer) | |
| 393 { | |
| 394 connect(); | |
| 395 { | |
| 396 InSequence s; | |
| 397 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("foo", 3), 3)); | |
| 398 } | |
| 399 | |
| 400 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 401 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 402 | |
| 403 RefPtr<ArrayBuffer> fooBuffer = ArrayBuffer::create("foo", 3); | |
| 404 channel()->send(*fooBuffer, 0, 3); | |
| 405 | |
| 406 EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount); | |
| 407 } | |
| 408 | |
| 409 TEST_F(NewWebSocketChannelImplTest, sendBinaryInArrayBufferPartial) | |
| 410 { | |
| 411 connect(); | |
| 412 { | |
| 413 InSequence s; | |
| 414 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("foo", 3), 3)); | |
| 415 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("bar", 3), 3)); | |
| 416 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("baz", 3), 3)); | |
| 417 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("a", 1), 1)); | |
| 418 } | |
| 419 | |
| 420 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 421 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 422 | |
| 423 RefPtr<ArrayBuffer> foobarBuffer = ArrayBuffer::create("foobar", 6); | |
| 424 RefPtr<ArrayBuffer> qbazuxBuffer = ArrayBuffer::create("qbazux", 6); | |
| 425 channel()->send(*foobarBuffer, 0, 3); | |
| 426 channel()->send(*foobarBuffer, 3, 3); | |
| 427 channel()->send(*qbazuxBuffer, 1, 3); | |
| 428 channel()->send(*qbazuxBuffer, 2, 1); | |
| 429 | |
| 430 EXPECT_EQ(10ul, m_sumOfConsumedBufferedAmount); | |
| 431 } | |
| 432 | |
| 433 TEST_F(NewWebSocketChannelImplTest, sendBinaryInArrayBufferWithNullBytes) | |
| 434 { | |
| 435 connect(); | |
| 436 { | |
| 437 InSequence s; | |
| 438 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("\0ar", 3), 3)); | |
| 439 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("b\0z", 3), 3)); | |
| 440 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("qu\0", 3), 3)); | |
| 441 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, Me
mEq("\0\0\0", 3), 3)); | |
| 442 } | |
| 443 | |
| 444 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 445 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 446 | |
| 447 { | |
| 448 RefPtr<ArrayBuffer> b = ArrayBuffer::create("\0ar", 3); | |
| 449 channel()->send(*b, 0, 3); | |
| 450 } | |
| 451 { | |
| 452 RefPtr<ArrayBuffer> b = ArrayBuffer::create("b\0z", 3); | |
| 453 channel()->send(*b, 0, 3); | |
| 454 } | |
| 455 { | |
| 456 RefPtr<ArrayBuffer> b = ArrayBuffer::create("qu\0", 3); | |
| 457 channel()->send(*b, 0, 3); | |
| 458 } | |
| 459 { | |
| 460 RefPtr<ArrayBuffer> b = ArrayBuffer::create("\0\0\0", 3); | |
| 461 channel()->send(*b, 0, 3); | |
| 462 } | |
| 463 | |
| 464 EXPECT_EQ(12ul, m_sumOfConsumedBufferedAmount); | |
| 465 } | |
| 466 | |
| 467 TEST_F(NewWebSocketChannelImplTest, sendBinaryInArrayBufferNonLatin1UTF8) | |
| 468 { | |
| 469 connect(); | |
| 470 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq(
"\xe7\x8b\x90", 3), 3)); | |
| 471 | |
| 472 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 473 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 474 | |
| 475 RefPtr<ArrayBuffer> b = ArrayBuffer::create("\xe7\x8b\x90", 3); | |
| 476 channel()->send(*b, 0, 3); | |
| 477 | |
| 478 EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount); | |
| 479 } | |
| 480 | |
| 481 TEST_F(NewWebSocketChannelImplTest, sendBinaryInArrayBufferNonUTF8) | |
| 482 { | |
| 483 connect(); | |
| 484 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq(
"\x80\xff\xe7", 3), 3)); | |
| 485 | |
| 486 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 487 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 488 | |
| 489 RefPtr<ArrayBuffer> b = ArrayBuffer::create("\x80\xff\xe7", 3); | |
| 490 channel()->send(*b, 0, 3); | |
| 491 | |
| 492 EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount); | |
| 493 } | |
| 494 | |
| 495 TEST_F(NewWebSocketChannelImplTest, sendBinaryInArrayBufferNonLatin1UTF8Continua
tion) | |
| 496 { | |
| 497 connect(); | |
| 498 Checkpoint checkpoint; | |
| 499 { | |
| 500 InSequence s; | |
| 501 EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeBinary, M
emEq("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7", 16), 16
)); | |
| 502 EXPECT_CALL(checkpoint, Call(1)); | |
| 503 EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuati
on, MemEq("\x8b\x90", 2), 2)); | |
| 504 } | |
| 505 | |
| 506 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 507 EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber()
); | |
| 508 | |
| 509 RefPtr<ArrayBuffer> b = ArrayBuffer::create("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8
b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90", 18); | |
| 510 channel()->send(*b, 0, 18); | |
| 511 checkpoint.Call(1); | |
| 512 | |
| 513 handleClient()->didReceiveFlowControl(handle(), 16); | |
| 514 | |
| 515 EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount); | |
| 516 } | |
| 517 | |
| 518 // FIXME: Add tests for WebSocketChannel::send(PassRefPtr<BlobDataHandle>) | |
| 519 | |
| 520 TEST_F(NewWebSocketChannelImplTest, receiveText) | |
| 521 { | |
| 522 connect(); | |
| 523 { | |
| 524 InSequence s; | |
| 525 EXPECT_CALL(*channelClient(), didReceiveTextMessage(String("FOO"))); | |
| 526 EXPECT_CALL(*channelClient(), didReceiveTextMessage(String("BAR"))); | |
| 527 } | |
| 528 | |
| 529 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeT
ext, "FOOX", 3); | |
| 530 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeT
ext, "BARX", 3); | |
| 531 } | |
| 532 | |
| 533 TEST_F(NewWebSocketChannelImplTest, receiveTextContinuation) | |
| 534 { | |
| 535 connect(); | |
| 536 EXPECT_CALL(*channelClient(), didReceiveTextMessage(String("BAZ"))); | |
| 537 | |
| 538 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Text, "BX", 1); | |
| 539 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Continuation, "AX", 1); | |
| 540 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeC
ontinuation, "ZX", 1); | |
| 541 } | |
| 542 | |
| 543 TEST_F(NewWebSocketChannelImplTest, receiveTextNonLatin1) | |
| 544 { | |
| 545 connect(); | |
| 546 UChar nonLatin1String[] = { | |
| 547 0x72d0, | |
| 548 0x0914, | |
| 549 0x0000 | |
| 550 }; | |
| 551 EXPECT_CALL(*channelClient(), didReceiveTextMessage(String(nonLatin1String))
); | |
| 552 | |
| 553 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeT
ext, "\xe7\x8b\x90\xe0\xa4\x94", 6); | |
| 554 } | |
| 555 | |
| 556 TEST_F(NewWebSocketChannelImplTest, receiveTextNonLatin1Continuation) | |
| 557 { | |
| 558 connect(); | |
| 559 UChar nonLatin1String[] = { | |
| 560 0x72d0, | |
| 561 0x0914, | |
| 562 0x0000 | |
| 563 }; | |
| 564 EXPECT_CALL(*channelClient(), didReceiveTextMessage(String(nonLatin1String))
); | |
| 565 | |
| 566 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Text, "\xe7\x8b", 2); | |
| 567 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Continuation, "\x90\xe0", 2); | |
| 568 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Continuation, "\xa4", 1); | |
| 569 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeC
ontinuation, "\x94", 1); | |
| 570 } | |
| 571 | |
| 572 TEST_F(NewWebSocketChannelImplTest, receiveBinary) | |
| 573 { | |
| 574 connect(); | |
| 575 Vector<char> fooVector; | |
| 576 fooVector.append("FOO", 3); | |
| 577 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(fooVector)); | |
| 578 | |
| 579 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "FOOx", 3); | |
| 580 } | |
| 581 | |
| 582 TEST_F(NewWebSocketChannelImplTest, receiveBinaryContinuation) | |
| 583 { | |
| 584 connect(); | |
| 585 Vector<char> bazVector; | |
| 586 bazVector.append("BAZ", 3); | |
| 587 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(bazVector)); | |
| 588 | |
| 589 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Binary, "Bx", 1); | |
| 590 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Continuation, "Ax", 1); | |
| 591 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeC
ontinuation, "Zx", 1); | |
| 592 } | |
| 593 | |
| 594 TEST_F(NewWebSocketChannelImplTest, receiveBinaryWithNullBytes) | |
| 595 { | |
| 596 connect(); | |
| 597 { | |
| 598 InSequence s; | |
| 599 { | |
| 600 Vector<char> v; | |
| 601 v.append("\0AR", 3); | |
| 602 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 603 } | |
| 604 { | |
| 605 Vector<char> v; | |
| 606 v.append("B\0Z", 3); | |
| 607 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 608 } | |
| 609 { | |
| 610 Vector<char> v; | |
| 611 v.append("QU\0", 3); | |
| 612 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 613 } | |
| 614 { | |
| 615 Vector<char> v; | |
| 616 v.append("\0\0\0", 3); | |
| 617 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 618 } | |
| 619 } | |
| 620 | |
| 621 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "\0AR", 3); | |
| 622 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "B\0Z", 3); | |
| 623 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "QU\0", 3); | |
| 624 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "\0\0\0", 3); | |
| 625 } | |
| 626 | |
| 627 TEST_F(NewWebSocketChannelImplTest, receiveBinaryNonLatin1UTF8) | |
| 628 { | |
| 629 connect(); | |
| 630 Vector<char> v; | |
| 631 v.append("\xe7\x8b\x90\xe0\xa4\x94", 6); | |
| 632 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 633 | |
| 634 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "\xe7\x8b\x90\xe0\xa4\x94", 6); | |
| 635 } | |
| 636 | |
| 637 TEST_F(NewWebSocketChannelImplTest, receiveBinaryNonLatin1UTF8Continuation) | |
| 638 { | |
| 639 connect(); | |
| 640 Vector<char> v; | |
| 641 v.append("\xe7\x8b\x90\xe0\xa4\x94", 6); | |
| 642 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 643 | |
| 644 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Binary, "\xe7\x8b", 2); | |
| 645 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Continuation, "\x90\xe0", 2); | |
| 646 handleClient()->didReceiveData(handle(), false, WebSocketHandle::MessageType
Continuation, "\xa4", 1); | |
| 647 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeC
ontinuation, "\x94", 1); | |
| 648 } | |
| 649 | |
| 650 TEST_F(NewWebSocketChannelImplTest, receiveBinaryNonUTF8) | |
| 651 { | |
| 652 connect(); | |
| 653 Vector<char> v; | |
| 654 v.append("\x80\xff", 2); | |
| 655 EXPECT_CALL(*channelClient(), didReceiveBinaryMessageMock(v)); | |
| 656 | |
| 657 handleClient()->didReceiveData(handle(), true, WebSocketHandle::MessageTypeB
inary, "\x80\xff", 2); | |
| 658 } | |
| 659 | |
| 660 TEST_F(NewWebSocketChannelImplTest, closeFromBrowser) | |
| 661 { | |
| 662 connect(); | |
| 663 Checkpoint checkpoint; | |
| 664 { | |
| 665 InSequence s; | |
| 666 | |
| 667 EXPECT_CALL(*channelClient(), didStartClosingHandshake()); | |
| 668 EXPECT_CALL(checkpoint, Call(1)); | |
| 669 | |
| 670 EXPECT_CALL(*handle(), close(WebSocketChannel::CloseEventCodeNormalClosu
re, WebString("close reason"))); | |
| 671 EXPECT_CALL(checkpoint, Call(2)); | |
| 672 | |
| 673 EXPECT_CALL(*channelClient(), didClose(WebSocketChannelClient::ClosingHa
ndshakeComplete, WebSocketChannel::CloseEventCodeNormalClosure, String("close re
ason"))); | |
| 674 EXPECT_CALL(checkpoint, Call(3)); | |
| 675 } | |
| 676 | |
| 677 handleClient()->didStartClosingHandshake(handle()); | |
| 678 checkpoint.Call(1); | |
| 679 | |
| 680 channel()->close(WebSocketChannel::CloseEventCodeNormalClosure, String("clos
e reason")); | |
| 681 checkpoint.Call(2); | |
| 682 | |
| 683 handleClient()->didClose(handle(), true, WebSocketChannel::CloseEventCodeNor
malClosure, String("close reason")); | |
| 684 checkpoint.Call(3); | |
| 685 | |
| 686 channel()->disconnect(); | |
| 687 } | |
| 688 | |
| 689 TEST_F(NewWebSocketChannelImplTest, closeFromWebSocket) | |
| 690 { | |
| 691 connect(); | |
| 692 Checkpoint checkpoint; | |
| 693 { | |
| 694 InSequence s; | |
| 695 | |
| 696 EXPECT_CALL(*handle(), close(WebSocketChannel::CloseEventCodeNormalClosu
re, WebString("close reason"))); | |
| 697 EXPECT_CALL(checkpoint, Call(1)); | |
| 698 | |
| 699 EXPECT_CALL(*channelClient(), didClose(WebSocketChannelClient::ClosingHa
ndshakeComplete, WebSocketChannel::CloseEventCodeNormalClosure, String("close re
ason"))); | |
| 700 EXPECT_CALL(checkpoint, Call(2)); | |
| 701 } | |
| 702 | |
| 703 channel()->close(WebSocketChannel::CloseEventCodeNormalClosure, String("clos
e reason")); | |
| 704 checkpoint.Call(1); | |
| 705 | |
| 706 handleClient()->didClose(handle(), true, WebSocketChannel::CloseEventCodeNor
malClosure, String("close reason")); | |
| 707 checkpoint.Call(2); | |
| 708 | |
| 709 channel()->disconnect(); | |
| 710 } | |
| 711 | |
| 712 TEST_F(NewWebSocketChannelImplTest, failFromBrowser) | |
| 713 { | |
| 714 connect(); | |
| 715 { | |
| 716 InSequence s; | |
| 717 | |
| 718 EXPECT_CALL(*channelClient(), didError()); | |
| 719 EXPECT_CALL(*channelClient(), didClose(WebSocketChannelClient::ClosingHa
ndshakeIncomplete, WebSocketChannel::CloseEventCodeAbnormalClosure, String())); | |
| 720 } | |
| 721 | |
| 722 handleClient()->didFail(handle(), "fail message"); | |
| 723 } | |
| 724 | |
| 725 TEST_F(NewWebSocketChannelImplTest, failFromWebSocket) | |
| 726 { | |
| 727 connect(); | |
| 728 { | |
| 729 InSequence s; | |
| 730 | |
| 731 EXPECT_CALL(*channelClient(), didError()); | |
| 732 EXPECT_CALL(*channelClient(), didClose(WebSocketChannelClient::ClosingHa
ndshakeIncomplete, WebSocketChannel::CloseEventCodeAbnormalClosure, String())); | |
| 733 } | |
| 734 | |
| 735 channel()->fail("fail message from WebSocket", ErrorMessageLevel, "sourceURL
", 1234); | |
| 736 } | |
| 737 | |
| 738 } // namespace | |
| 739 | |
| 740 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 690883002:
Rename NewWebSocketChannelImpl to DocumentWebSocketChannel. (Closed)
Base URL: https://chromium.googlesource.com/chromium/blink.git@master