1 // Copyright 2013 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 "net/spdy/spdy_websocket_stream.h"
6
7 #include <string>
8 #include <vector>
9
10 #include "base/bind.h"
11 #include "base/bind_helpers.h"
12 #include "net/base/completion_callback.h"
13 #include "net/proxy/proxy_server.h"
14 #include "net/socket/next_proto.h"
15 #include "net/socket/ssl_client_socket.h"
16 #include "net/spdy/spdy_http_utils.h"
17 #include "net/spdy/spdy_protocol.h"
18 #include "net/spdy/spdy_session.h"
19 #include "net/spdy/spdy_websocket_test_util.h"
20 #include "testing/gtest/include/gtest/gtest.h"
21
22 namespace net {
23
24 namespace {
25
26 struct SpdyWebSocketStreamEvent {
27 enum EventType {
28 EVENT_CREATED,
29 EVENT_SENT_HEADERS,
30 EVENT_RECEIVED_HEADER,
31 EVENT_SENT_DATA,
32 EVENT_RECEIVED_DATA,
33 EVENT_CLOSE,
34 };
SpdyWebSocketStreamEventnet::__anonfbdedacb0111::SpdyWebSocketStreamEvent35 SpdyWebSocketStreamEvent(EventType type,
36 const SpdyHeaderBlock& headers,
37 int result,
38 const std::string& data)
39 : event_type(type),
40 headers(headers),
41 result(result),
42 data(data) {}
43
44 EventType event_type;
45 SpdyHeaderBlock headers;
46 int result;
47 std::string data;
48 };
49
50 class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
51 public:
SpdyWebSocketStreamEventRecorder(const CompletionCallback & callback)52 explicit SpdyWebSocketStreamEventRecorder(const CompletionCallback& callback)
53 : callback_(callback) {}
~SpdyWebSocketStreamEventRecorder()54 virtual ~SpdyWebSocketStreamEventRecorder() {}
55
56 typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
57
SetOnCreated(const StreamEventCallback & callback)58 void SetOnCreated(const StreamEventCallback& callback) {
59 on_created_ = callback;
60 }
SetOnSentHeaders(const StreamEventCallback & callback)61 void SetOnSentHeaders(const StreamEventCallback& callback) {
62 on_sent_headers_ = callback;
63 }
SetOnReceivedHeader(const StreamEventCallback & callback)64 void SetOnReceivedHeader(const StreamEventCallback& callback) {
65 on_received_header_ = callback;
66 }
SetOnSentData(const StreamEventCallback & callback)67 void SetOnSentData(const StreamEventCallback& callback) {
68 on_sent_data_ = callback;
69 }
SetOnReceivedData(const StreamEventCallback & callback)70 void SetOnReceivedData(const StreamEventCallback& callback) {
71 on_received_data_ = callback;
72 }
SetOnClose(const StreamEventCallback & callback)73 void SetOnClose(const StreamEventCallback& callback) {
74 on_close_ = callback;
75 }
76
OnCreatedSpdyStream(int result)77 virtual void OnCreatedSpdyStream(int result) OVERRIDE {
78 events_.push_back(
79 SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
80 SpdyHeaderBlock(),
81 result,
82 std::string()));
83 if (!on_created_.is_null())
84 on_created_.Run(&events_.back());
85 }
OnSentSpdyHeaders()86 virtual void OnSentSpdyHeaders() OVERRIDE {
87 events_.push_back(
88 SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
89 SpdyHeaderBlock(),
90 OK,
91 std::string()));
92 if (!on_sent_data_.is_null())
93 on_sent_data_.Run(&events_.back());
94 }
OnSpdyResponseHeadersUpdated(const SpdyHeaderBlock & response_headers)95 virtual void OnSpdyResponseHeadersUpdated(
96 const SpdyHeaderBlock& response_headers) OVERRIDE {
97 events_.push_back(
98 SpdyWebSocketStreamEvent(
99 SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
100 response_headers,
101 OK,
102 std::string()));
103 if (!on_received_header_.is_null())
104 on_received_header_.Run(&events_.back());
105 }
OnSentSpdyData(size_t bytes_sent)106 virtual void OnSentSpdyData(size_t bytes_sent) OVERRIDE {
107 events_.push_back(
108 SpdyWebSocketStreamEvent(
109 SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
110 SpdyHeaderBlock(),
111 static_cast<int>(bytes_sent),
112 std::string()));
113 if (!on_sent_data_.is_null())
114 on_sent_data_.Run(&events_.back());
115 }
OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer)116 virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) OVERRIDE {
117 std::string buffer_data;
118 size_t buffer_len = 0;
119 if (buffer) {
120 buffer_len = buffer->GetRemainingSize();
121 buffer_data.append(buffer->GetRemainingData(), buffer_len);
122 }
123 events_.push_back(
124 SpdyWebSocketStreamEvent(
125 SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
126 SpdyHeaderBlock(),
127 buffer_len,
128 buffer_data));
129 if (!on_received_data_.is_null())
130 on_received_data_.Run(&events_.back());
131 }
OnCloseSpdyStream()132 virtual void OnCloseSpdyStream() OVERRIDE {
133 events_.push_back(
134 SpdyWebSocketStreamEvent(
135 SpdyWebSocketStreamEvent::EVENT_CLOSE,
136 SpdyHeaderBlock(),
137 OK,
138 std::string()));
139 if (!on_close_.is_null())
140 on_close_.Run(&events_.back());
141 if (!callback_.is_null())
142 callback_.Run(OK);
143 }
144
GetSeenEvents() const145 const std::vector<SpdyWebSocketStreamEvent>& GetSeenEvents() const {
146 return events_;
147 }
148
149 private:
150 std::vector<SpdyWebSocketStreamEvent> events_;
151 StreamEventCallback on_created_;
152 StreamEventCallback on_sent_headers_;
153 StreamEventCallback on_received_header_;
154 StreamEventCallback on_sent_data_;
155 StreamEventCallback on_received_data_;
156 StreamEventCallback on_close_;
157 CompletionCallback callback_;
158
159 DISALLOW_COPY_AND_ASSIGN(SpdyWebSocketStreamEventRecorder);
160 };
161
162 } // namespace
163
164 class SpdyWebSocketStreamTest
165 : public ::testing::Test,
166 public ::testing::WithParamInterface<NextProto> {
167 public:
data()168 OrderedSocketData* data() { return data_.get(); }
169
DoSendHelloFrame(SpdyWebSocketStreamEvent * event)170 void DoSendHelloFrame(SpdyWebSocketStreamEvent* event) {
171 // Record the actual stream_id.
172 created_stream_id_ = websocket_stream_->stream_->stream_id();
173 websocket_stream_->SendData(kMessageFrame, kMessageFrameLength);
174 }
175
DoSendClosingFrame(SpdyWebSocketStreamEvent * event)176 void DoSendClosingFrame(SpdyWebSocketStreamEvent* event) {
177 websocket_stream_->SendData(kClosingFrame, kClosingFrameLength);
178 }
179
DoClose(SpdyWebSocketStreamEvent * event)180 void DoClose(SpdyWebSocketStreamEvent* event) {
181 websocket_stream_->Close();
182 }
183
DoSync(SpdyWebSocketStreamEvent * event)184 void DoSync(SpdyWebSocketStreamEvent* event) {
185 sync_callback_.callback().Run(OK);
186 }
187
188 protected:
SpdyWebSocketStreamTest()189 SpdyWebSocketStreamTest()
190 : spdy_util_(GetParam()),
191 spdy_settings_id_to_set_(SETTINGS_MAX_CONCURRENT_STREAMS),
192 spdy_settings_flags_to_set_(SETTINGS_FLAG_PLEASE_PERSIST),
193 spdy_settings_value_to_set_(1),
194 session_deps_(GetParam()),
195 stream_id_(0),
196 created_stream_id_(0) {}
~SpdyWebSocketStreamTest()197 virtual ~SpdyWebSocketStreamTest() {}
198
SetUp()199 virtual void SetUp() {
200 host_port_pair_.set_host("example.com");
201 host_port_pair_.set_port(80);
202 spdy_session_key_ = SpdySessionKey(host_port_pair_,
203 ProxyServer::Direct(),
204 PRIVACY_MODE_DISABLED);
205
206 spdy_settings_to_send_[spdy_settings_id_to_set_] =
207 SettingsFlagsAndValue(
208 SETTINGS_FLAG_PERSISTED, spdy_settings_value_to_set_);
209 }
210
TearDown()211 virtual void TearDown() {
212 base::MessageLoop::current()->RunUntilIdle();
213 }
214
Prepare(SpdyStreamId stream_id)215 void Prepare(SpdyStreamId stream_id) {
216 stream_id_ = stream_id;
217
218 request_frame_.reset(spdy_util_.ConstructSpdyWebSocketSynStream(
219 stream_id_,
220 "/echo",
221 "example.com",
222 "http://example.com/wsdemo"));
223
224 response_frame_.reset(
225 spdy_util_.ConstructSpdyWebSocketSynReply(stream_id_));
226
227 message_frame_.reset(spdy_util_.ConstructSpdyWebSocketDataFrame(
228 kMessageFrame,
229 kMessageFrameLength,
230 stream_id_,
231 false));
232
233 closing_frame_.reset(spdy_util_.ConstructSpdyWebSocketDataFrame(
234 kClosingFrame,
235 kClosingFrameLength,
236 stream_id_,
237 false));
238
239 closing_frame_fin_.reset(spdy_util_.ConstructSpdyWebSocketDataFrame(
240 kClosingFrame,
241 kClosingFrameLength,
242 stream_id_,
243 true));
244 }
245
InitSession(MockRead * reads,size_t reads_count,MockWrite * writes,size_t writes_count)246 void InitSession(MockRead* reads, size_t reads_count,
247 MockWrite* writes, size_t writes_count) {
248 data_.reset(new OrderedSocketData(reads, reads_count,
249 writes, writes_count));
250 session_deps_.socket_factory->AddSocketDataProvider(data_.get());
251 http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
252 session_ = CreateInsecureSpdySession(
253 http_session_, spdy_session_key_, BoundNetLog());
254 }
255
SendRequest()256 void SendRequest() {
257 scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
258 spdy_util_.SetHeader("path", "/echo", headers.get());
259 spdy_util_.SetHeader("host", "example.com", headers.get());
260 spdy_util_.SetHeader("version", "WebSocket/13", headers.get());
261 spdy_util_.SetHeader("scheme", "ws", headers.get());
262 spdy_util_.SetHeader("origin", "http://example.com/wsdemo", headers.get());
263 websocket_stream_->SendRequest(headers.Pass());
264 }
265
266 SpdyWebSocketTestUtil spdy_util_;
267 SpdySettingsIds spdy_settings_id_to_set_;
268 SpdySettingsFlags spdy_settings_flags_to_set_;
269 uint32 spdy_settings_value_to_set_;
270 SettingsMap spdy_settings_to_send_;
271 SpdySessionDependencies session_deps_;
272 scoped_ptr<OrderedSocketData> data_;
273 scoped_refptr<HttpNetworkSession> http_session_;
274 base::WeakPtr<SpdySession> session_;
275 scoped_ptr<SpdyWebSocketStream> websocket_stream_;
276 SpdyStreamId stream_id_;
277 SpdyStreamId created_stream_id_;
278 scoped_ptr<SpdyFrame> request_frame_;
279 scoped_ptr<SpdyFrame> response_frame_;
280 scoped_ptr<SpdyFrame> message_frame_;
281 scoped_ptr<SpdyFrame> closing_frame_;
282 scoped_ptr<SpdyFrame> closing_frame_fin_;
283 HostPortPair host_port_pair_;
284 SpdySessionKey spdy_session_key_;
285 TestCompletionCallback completion_callback_;
286 TestCompletionCallback sync_callback_;
287
288 static const char kMessageFrame[];
289 static const char kClosingFrame[];
290 static const size_t kMessageFrameLength;
291 static const size_t kClosingFrameLength;
292 };
293
294 INSTANTIATE_TEST_CASE_P(
295 NextProto,
296 SpdyWebSocketStreamTest,
297 testing::Values(kProtoDeprecatedSPDY2,
298 kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
299
300 // TODO(toyoshim): Replace old framing data to new one, then use HEADERS and
301 // data frames.
302 const char SpdyWebSocketStreamTest::kMessageFrame[] = "\x81\x05hello";
303 const char SpdyWebSocketStreamTest::kClosingFrame[] = "\x88\0";
304 const size_t SpdyWebSocketStreamTest::kMessageFrameLength =
305 arraysize(SpdyWebSocketStreamTest::kMessageFrame) - 1;
306 const size_t SpdyWebSocketStreamTest::kClosingFrameLength =
307 arraysize(SpdyWebSocketStreamTest::kClosingFrame) - 1;
308
TEST_P(SpdyWebSocketStreamTest,Basic)309 TEST_P(SpdyWebSocketStreamTest, Basic) {
310 Prepare(1);
311 MockWrite writes[] = {
312 CreateMockWrite(*request_frame_.get(), 1),
313 CreateMockWrite(*message_frame_.get(), 3),
314 CreateMockWrite(*closing_frame_.get(), 5)
315 };
316
317 MockRead reads[] = {
318 CreateMockRead(*response_frame_.get(), 2),
319 CreateMockRead(*message_frame_.get(), 4),
320 // Skip sequence 6 to notify closing has been sent.
321 CreateMockRead(*closing_frame_.get(), 7),
322 MockRead(SYNCHRONOUS, 0, 8) // EOF cause OnCloseSpdyStream event.
323 };
324
325 InitSession(reads, arraysize(reads), writes, arraysize(writes));
326
327 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
328 delegate.SetOnReceivedHeader(
329 base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
330 base::Unretained(this)));
331 delegate.SetOnReceivedData(
332 base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
333 base::Unretained(this)));
334
335 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
336
337 BoundNetLog net_log;
338 GURL url("ws://example.com/echo");
339 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
340
341 ASSERT_TRUE(websocket_stream_->stream_.get());
342
343 SendRequest();
344
345 completion_callback_.WaitForResult();
346
347 EXPECT_EQ(stream_id_, created_stream_id_);
348
349 websocket_stream_.reset();
350
351 const std::vector<SpdyWebSocketStreamEvent>& events =
352 delegate.GetSeenEvents();
353 ASSERT_EQ(7U, events.size());
354
355 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
356 events[0].event_type);
357 EXPECT_EQ(OK, events[0].result);
358 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
359 events[1].event_type);
360 EXPECT_EQ(OK, events[1].result);
361 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
362 events[2].event_type);
363 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
364 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
365 events[3].event_type);
366 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
367 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
368 events[4].event_type);
369 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[4].result);
370 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
371 events[5].event_type);
372 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
373 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
374 events[6].event_type);
375 EXPECT_EQ(OK, events[6].result);
376
377 // EOF close SPDY session.
378 EXPECT_FALSE(
379 HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
380 EXPECT_TRUE(data()->at_read_eof());
381 EXPECT_TRUE(data()->at_write_eof());
382 }
383
384 // A SPDY websocket may still send it's close frame after
385 // recieving a close with SPDY stream FIN.
TEST_P(SpdyWebSocketStreamTest,RemoteCloseWithFin)386 TEST_P(SpdyWebSocketStreamTest, RemoteCloseWithFin) {
387 Prepare(1);
388 MockWrite writes[] = {
389 CreateMockWrite(*request_frame_.get(), 1),
390 CreateMockWrite(*closing_frame_.get(), 4),
391 };
392 MockRead reads[] = {
393 CreateMockRead(*response_frame_.get(), 2),
394 CreateMockRead(*closing_frame_fin_.get(), 3),
395 MockRead(SYNCHRONOUS, 0, 5) // EOF cause OnCloseSpdyStream event.
396 };
397 InitSession(reads, arraysize(reads), writes, arraysize(writes));
398
399 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
400 delegate.SetOnReceivedData(
401 base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
402 base::Unretained(this)));
403
404 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
405 BoundNetLog net_log;
406 GURL url("ws://example.com/echo");
407 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
408
409 SendRequest();
410 completion_callback_.WaitForResult();
411 websocket_stream_.reset();
412
413 const std::vector<SpdyWebSocketStreamEvent>& events =
414 delegate.GetSeenEvents();
415 EXPECT_EQ(5U, events.size());
416
417 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
418 events[0].event_type);
419 EXPECT_EQ(OK, events[0].result);
420 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
421 events[1].event_type);
422 EXPECT_EQ(OK, events[1].result);
423 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
424 events[2].event_type);
425 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[2].result);
426 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
427 events[3].event_type);
428 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[3].result);
429 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
430 events[4].event_type);
431 EXPECT_EQ(OK, events[4].result);
432
433 // EOF closes SPDY session.
434 EXPECT_FALSE(
435 HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
436 EXPECT_TRUE(data()->at_read_eof());
437 EXPECT_TRUE(data()->at_write_eof());
438 }
439
TEST_P(SpdyWebSocketStreamTest,DestructionBeforeClose)440 TEST_P(SpdyWebSocketStreamTest, DestructionBeforeClose) {
441 Prepare(1);
442 MockWrite writes[] = {
443 CreateMockWrite(*request_frame_.get(), 1),
444 CreateMockWrite(*message_frame_.get(), 3)
445 };
446
447 MockRead reads[] = {
448 CreateMockRead(*response_frame_.get(), 2),
449 CreateMockRead(*message_frame_.get(), 4),
450 MockRead(ASYNC, ERR_IO_PENDING, 5)
451 };
452
453 InitSession(reads, arraysize(reads), writes, arraysize(writes));
454
455 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
456 delegate.SetOnReceivedHeader(
457 base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
458 base::Unretained(this)));
459 delegate.SetOnReceivedData(
460 base::Bind(&SpdyWebSocketStreamTest::DoSync,
461 base::Unretained(this)));
462
463 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
464
465 BoundNetLog net_log;
466 GURL url("ws://example.com/echo");
467 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
468
469 SendRequest();
470
471 sync_callback_.WaitForResult();
472
473 // WebSocketStream destruction remove its SPDY stream from the session.
474 EXPECT_TRUE(session_->IsStreamActive(stream_id_));
475 websocket_stream_.reset();
476 EXPECT_FALSE(session_->IsStreamActive(stream_id_));
477
478 const std::vector<SpdyWebSocketStreamEvent>& events =
479 delegate.GetSeenEvents();
480 ASSERT_GE(4U, events.size());
481
482 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
483 events[0].event_type);
484 EXPECT_EQ(OK, events[0].result);
485 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
486 events[1].event_type);
487 EXPECT_EQ(OK, events[1].result);
488 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
489 events[2].event_type);
490 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
491 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
492 events[3].event_type);
493 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
494
495 EXPECT_TRUE(
496 HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
497 EXPECT_TRUE(data()->at_read_eof());
498 EXPECT_TRUE(data()->at_write_eof());
499 }
500
TEST_P(SpdyWebSocketStreamTest,DestructionAfterExplicitClose)501 TEST_P(SpdyWebSocketStreamTest, DestructionAfterExplicitClose) {
502 Prepare(1);
503 MockWrite writes[] = {
504 CreateMockWrite(*request_frame_.get(), 1),
505 CreateMockWrite(*message_frame_.get(), 3),
506 CreateMockWrite(*closing_frame_.get(), 5)
507 };
508
509 MockRead reads[] = {
510 CreateMockRead(*response_frame_.get(), 2),
511 CreateMockRead(*message_frame_.get(), 4),
512 MockRead(ASYNC, ERR_IO_PENDING, 6)
513 };
514
515 InitSession(reads, arraysize(reads), writes, arraysize(writes));
516
517 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
518 delegate.SetOnReceivedHeader(
519 base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
520 base::Unretained(this)));
521 delegate.SetOnReceivedData(
522 base::Bind(&SpdyWebSocketStreamTest::DoClose,
523 base::Unretained(this)));
524
525 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
526
527 BoundNetLog net_log;
528 GURL url("ws://example.com/echo");
529 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
530
531 SendRequest();
532
533 completion_callback_.WaitForResult();
534
535 // SPDY stream has already been removed from the session by Close().
536 EXPECT_FALSE(session_->IsStreamActive(stream_id_));
537 websocket_stream_.reset();
538
539 const std::vector<SpdyWebSocketStreamEvent>& events =
540 delegate.GetSeenEvents();
541 ASSERT_EQ(5U, events.size());
542
543 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
544 events[0].event_type);
545 EXPECT_EQ(OK, events[0].result);
546 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
547 events[1].event_type);
548 EXPECT_EQ(OK, events[1].result);
549 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
550 events[2].event_type);
551 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
552 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
553 events[3].event_type);
554 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
555 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE, events[4].event_type);
556
557 EXPECT_TRUE(
558 HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
559 }
560
TEST_P(SpdyWebSocketStreamTest,IOPending)561 TEST_P(SpdyWebSocketStreamTest, IOPending) {
562 Prepare(1);
563 scoped_ptr<SpdyFrame> settings_frame(
564 spdy_util_.ConstructSpdySettings(spdy_settings_to_send_));
565 scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
566 MockWrite writes[] = {
567 CreateMockWrite(*settings_ack, 1),
568 CreateMockWrite(*request_frame_.get(), 2),
569 CreateMockWrite(*message_frame_.get(), 4),
570 CreateMockWrite(*closing_frame_.get(), 6)
571 };
572
573 MockRead reads[] = {
574 CreateMockRead(*settings_frame.get(), 0),
575 CreateMockRead(*response_frame_.get(), 3),
576 CreateMockRead(*message_frame_.get(), 5),
577 CreateMockRead(*closing_frame_.get(), 7),
578 MockRead(SYNCHRONOUS, 0, 8) // EOF cause OnCloseSpdyStream event.
579 };
580
581 DeterministicSocketData data(reads, arraysize(reads),
582 writes, arraysize(writes));
583 session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
584 http_session_ =
585 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
586
587 session_ = CreateInsecureSpdySession(
588 http_session_, spdy_session_key_, BoundNetLog());
589
590 // Create a dummy WebSocketStream which cause ERR_IO_PENDING to another
591 // WebSocketStream under test.
592 SpdyWebSocketStreamEventRecorder block_delegate((CompletionCallback()));
593
594 scoped_ptr<SpdyWebSocketStream> block_stream(
595 new SpdyWebSocketStream(session_, &block_delegate));
596 BoundNetLog block_net_log;
597 GURL block_url("ws://example.com/block");
598 ASSERT_EQ(OK,
599 block_stream->InitializeStream(block_url, HIGHEST, block_net_log));
600
601 data.RunFor(1);
602
603 // Create a WebSocketStream under test.
604 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
605 delegate.SetOnCreated(
606 base::Bind(&SpdyWebSocketStreamTest::DoSync,
607 base::Unretained(this)));
608 delegate.SetOnReceivedHeader(
609 base::Bind(&SpdyWebSocketStreamTest::DoSendHelloFrame,
610 base::Unretained(this)));
611 delegate.SetOnReceivedData(
612 base::Bind(&SpdyWebSocketStreamTest::DoSendClosingFrame,
613 base::Unretained(this)));
614
615 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
616 BoundNetLog net_log;
617 GURL url("ws://example.com/echo");
618 ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
619 url, HIGHEST, net_log));
620
621 // Delete the fist stream to allow create the second stream.
622 block_stream.reset();
623 ASSERT_EQ(OK, sync_callback_.WaitForResult());
624
625 SendRequest();
626
627 data.RunFor(8);
628 completion_callback_.WaitForResult();
629
630 websocket_stream_.reset();
631
632 const std::vector<SpdyWebSocketStreamEvent>& block_events =
633 block_delegate.GetSeenEvents();
634 ASSERT_EQ(0U, block_events.size());
635
636 const std::vector<SpdyWebSocketStreamEvent>& events =
637 delegate.GetSeenEvents();
638 ASSERT_EQ(8U, events.size());
639 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CREATED,
640 events[0].event_type);
641 EXPECT_EQ(0, events[0].result);
642 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
643 events[1].event_type);
644 EXPECT_EQ(OK, events[1].result);
645 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
646 events[2].event_type);
647 EXPECT_EQ(OK, events[2].result);
648 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
649 events[3].event_type);
650 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
651 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
652 events[4].event_type);
653 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[4].result);
654 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
655 events[5].event_type);
656 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
657 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
658 events[6].event_type);
659 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[6].result);
660 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
661 events[7].event_type);
662 EXPECT_EQ(OK, events[7].result);
663
664 // EOF close SPDY session.
665 EXPECT_FALSE(
666 HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
667 EXPECT_TRUE(data.at_read_eof());
668 EXPECT_TRUE(data.at_write_eof());
669 }
670
671 } // namespace net
672