Enables compositing support for webview.
[chromium-blink-merge.git] / net / spdy / spdy_websocket_stream_spdy2_unittest.cc
blob20b72176fd01c71161932dd6e19d21ef2be26197
1 // Copyright (c) 2012 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.
5 #include "net/spdy/spdy_websocket_stream.h"
7 #include <string>
8 #include <vector>
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/ssl_client_socket.h"
15 #include "net/spdy/spdy_http_utils.h"
16 #include "net/spdy/spdy_protocol.h"
17 #include "net/spdy/spdy_session.h"
18 #include "net/spdy/spdy_test_util_spdy2.h"
19 #include "net/spdy/spdy_websocket_test_util_spdy2.h"
20 #include "testing/gtest/include/gtest/gtest.h"
22 using namespace net::test_spdy2;
24 namespace net {
26 namespace {
28 struct SpdyWebSocketStreamEvent {
29 enum EventType {
30 EVENT_CREATED,
31 EVENT_SENT_HEADERS,
32 EVENT_RECEIVED_HEADER,
33 EVENT_SENT_DATA,
34 EVENT_RECEIVED_DATA,
35 EVENT_CLOSE,
37 SpdyWebSocketStreamEvent(EventType type,
38 const SpdyHeaderBlock& headers,
39 int result,
40 const std::string& data)
41 : event_type(type),
42 headers(headers),
43 result(result),
44 data(data) {}
46 EventType event_type;
47 SpdyHeaderBlock headers;
48 int result;
49 std::string data;
52 class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
53 public:
54 explicit SpdyWebSocketStreamEventRecorder(const CompletionCallback& callback)
55 : callback_(callback) {}
56 virtual ~SpdyWebSocketStreamEventRecorder() {}
58 typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
60 void SetOnCreated(const StreamEventCallback& callback) {
61 on_created_ = callback;
63 void SetOnSentHeaders(const StreamEventCallback& callback) {
64 on_sent_headers_ = callback;
66 void SetOnReceivedHeader(const StreamEventCallback& callback) {
67 on_received_header_ = callback;
69 void SetOnSentData(const StreamEventCallback& callback) {
70 on_sent_data_ = callback;
72 void SetOnReceivedData(const StreamEventCallback& callback) {
73 on_received_data_ = callback;
75 void SetOnClose(const StreamEventCallback& callback) {
76 on_close_ = callback;
79 virtual void OnCreatedSpdyStream(int result) {
80 events_.push_back(
81 SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
82 SpdyHeaderBlock(),
83 result,
84 std::string()));
85 if (!on_created_.is_null())
86 on_created_.Run(&events_.back());
88 virtual void OnSentSpdyHeaders(int result) {
89 events_.push_back(
90 SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
91 SpdyHeaderBlock(),
92 result,
93 std::string()));
94 if (!on_sent_data_.is_null())
95 on_sent_data_.Run(&events_.back());
97 virtual int OnReceivedSpdyResponseHeader(
98 const SpdyHeaderBlock& headers, int status) {
99 events_.push_back(
100 SpdyWebSocketStreamEvent(
101 SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
102 headers,
103 status,
104 std::string()));
105 if (!on_received_header_.is_null())
106 on_received_header_.Run(&events_.back());
107 return status;
109 virtual void OnSentSpdyData(int amount_sent) {
110 events_.push_back(
111 SpdyWebSocketStreamEvent(
112 SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
113 SpdyHeaderBlock(),
114 amount_sent,
115 std::string()));
116 if (!on_sent_data_.is_null())
117 on_sent_data_.Run(&events_.back());
119 virtual void OnReceivedSpdyData(const char* data, int length) {
120 events_.push_back(
121 SpdyWebSocketStreamEvent(
122 SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
123 SpdyHeaderBlock(),
124 length,
125 std::string(data, length)));
126 if (!on_received_data_.is_null())
127 on_received_data_.Run(&events_.back());
129 virtual void OnCloseSpdyStream() {
130 events_.push_back(
131 SpdyWebSocketStreamEvent(
132 SpdyWebSocketStreamEvent::EVENT_CLOSE,
133 SpdyHeaderBlock(),
135 std::string()));
136 if (!on_close_.is_null())
137 on_close_.Run(&events_.back());
138 if (!callback_.is_null())
139 callback_.Run(OK);
142 const std::vector<SpdyWebSocketStreamEvent>& GetSeenEvents() const {
143 return events_;
146 private:
147 std::vector<SpdyWebSocketStreamEvent> events_;
148 StreamEventCallback on_created_;
149 StreamEventCallback on_sent_headers_;
150 StreamEventCallback on_received_header_;
151 StreamEventCallback on_sent_data_;
152 StreamEventCallback on_received_data_;
153 StreamEventCallback on_close_;
154 CompletionCallback callback_;
156 DISALLOW_COPY_AND_ASSIGN(SpdyWebSocketStreamEventRecorder);
159 } // namespace
161 class SpdyWebSocketStreamSpdy2Test : public testing::Test {
162 public:
163 OrderedSocketData* data() { return data_.get(); }
165 void DoSendHelloFrame(SpdyWebSocketStreamEvent* event) {
166 // Record the actual stream_id.
167 created_stream_id_ = websocket_stream_->stream_->stream_id();
168 websocket_stream_->SendData(kMessageFrame, kMessageFrameLength);
171 void DoSendClosingFrame(SpdyWebSocketStreamEvent* event) {
172 websocket_stream_->SendData(kClosingFrame, kClosingFrameLength);
175 void DoClose(SpdyWebSocketStreamEvent* event) {
176 websocket_stream_->Close();
179 void DoSync(SpdyWebSocketStreamEvent* event) {
180 sync_callback_.callback().Run(OK);
183 protected:
184 SpdyWebSocketStreamSpdy2Test() {}
185 virtual ~SpdyWebSocketStreamSpdy2Test() {}
187 virtual void SetUp() {
188 host_port_pair_.set_host("example.com");
189 host_port_pair_.set_port(80);
190 host_port_proxy_pair_.first = host_port_pair_;
191 host_port_proxy_pair_.second = ProxyServer::Direct();
193 spdy_settings_id_to_set_ = SETTINGS_MAX_CONCURRENT_STREAMS;
194 spdy_settings_flags_to_set_ = SETTINGS_FLAG_PLEASE_PERSIST;
195 spdy_settings_value_to_set_ = 1;
197 spdy_settings_to_send_[spdy_settings_id_to_set_] =
198 SettingsFlagsAndValue(
199 SETTINGS_FLAG_PERSISTED, spdy_settings_value_to_set_);
202 virtual void TearDown() {
203 MessageLoop::current()->RunUntilIdle();
206 void Prepare(SpdyStreamId stream_id) {
207 stream_id_ = stream_id;
209 request_frame_.reset(ConstructSpdyWebSocketSynStream(
210 stream_id_,
211 "/echo",
212 "example.com",
213 "http://example.com/wsdemo"));
215 response_frame_.reset(ConstructSpdyWebSocketSynReply(stream_id_));
217 message_frame_.reset(ConstructSpdyWebSocketDataFrame(
218 kMessageFrame,
219 kMessageFrameLength,
220 stream_id_,
221 false));
223 closing_frame_.reset(ConstructSpdyWebSocketDataFrame(
224 kClosingFrame,
225 kClosingFrameLength,
226 stream_id_,
227 false));
230 int InitSession(MockRead* reads, size_t reads_count,
231 MockWrite* writes, size_t writes_count,
232 bool throttling) {
233 data_.reset(new OrderedSocketData(reads, reads_count,
234 writes, writes_count));
235 session_deps_.socket_factory->AddSocketDataProvider(data_.get());
236 http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
237 SpdySessionPool* spdy_session_pool(http_session_->spdy_session_pool());
239 if (throttling) {
240 // Set max concurrent streams to 1.
241 spdy_session_pool->http_server_properties()->SetSpdySetting(
242 host_port_pair_,
243 spdy_settings_id_to_set_,
244 spdy_settings_flags_to_set_,
245 spdy_settings_value_to_set_);
248 EXPECT_FALSE(spdy_session_pool->HasSession(host_port_proxy_pair_));
249 session_ = spdy_session_pool->Get(host_port_proxy_pair_, BoundNetLog());
250 EXPECT_TRUE(spdy_session_pool->HasSession(host_port_proxy_pair_));
251 transport_params_ = new TransportSocketParams(host_port_pair_, MEDIUM,
252 false, false,
253 OnHostResolutionCallback());
254 TestCompletionCallback callback;
255 scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
256 EXPECT_EQ(ERR_IO_PENDING,
257 connection->Init(host_port_pair_.ToString(), transport_params_,
258 MEDIUM, callback.callback(),
259 http_session_->GetTransportSocketPool(
260 HttpNetworkSession::NORMAL_SOCKET_POOL),
261 BoundNetLog()));
262 EXPECT_EQ(OK, callback.WaitForResult());
263 return session_->InitializeWithSocket(connection.release(), false, OK);
266 void SendRequest() {
267 scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
268 (*headers)["path"] = "/echo";
269 (*headers)["host"] = "example.com";
270 (*headers)["version"] = "WebSocket/13";
271 (*headers)["scheme"] = "ws";
272 (*headers)["origin"] = "http://example.com/wsdemo";
274 websocket_stream_->SendRequest(headers.Pass());
277 SpdySettingsIds spdy_settings_id_to_set_;
278 SpdySettingsFlags spdy_settings_flags_to_set_;
279 uint32 spdy_settings_value_to_set_;
280 SettingsMap spdy_settings_to_send_;
281 SpdySessionDependencies session_deps_;
282 scoped_ptr<OrderedSocketData> data_;
283 scoped_refptr<HttpNetworkSession> http_session_;
284 scoped_refptr<SpdySession> session_;
285 scoped_refptr<TransportSocketParams> transport_params_;
286 scoped_ptr<SpdyWebSocketStream> websocket_stream_;
287 SpdyStreamId stream_id_;
288 SpdyStreamId created_stream_id_;
289 scoped_ptr<SpdyFrame> request_frame_;
290 scoped_ptr<SpdyFrame> response_frame_;
291 scoped_ptr<SpdyFrame> message_frame_;
292 scoped_ptr<SpdyFrame> closing_frame_;
293 HostPortPair host_port_pair_;
294 HostPortProxyPair host_port_proxy_pair_;
295 TestCompletionCallback completion_callback_;
296 TestCompletionCallback sync_callback_;
298 static const char kMessageFrame[];
299 static const char kClosingFrame[];
300 static const size_t kMessageFrameLength;
301 static const size_t kClosingFrameLength;
304 // TODO(toyoshim): Replace old framing data to new one, then use HEADERS and
305 // data frames.
306 const char SpdyWebSocketStreamSpdy2Test::kMessageFrame[] = "\x81\x05hello";
307 const char SpdyWebSocketStreamSpdy2Test::kClosingFrame[] = "\x88\0";
308 const size_t SpdyWebSocketStreamSpdy2Test::kMessageFrameLength =
309 arraysize(SpdyWebSocketStreamSpdy2Test::kMessageFrame) - 1;
310 const size_t SpdyWebSocketStreamSpdy2Test::kClosingFrameLength =
311 arraysize(SpdyWebSocketStreamSpdy2Test::kClosingFrame) - 1;
313 TEST_F(SpdyWebSocketStreamSpdy2Test, Basic) {
314 Prepare(1);
315 MockWrite writes[] = {
316 CreateMockWrite(*request_frame_.get(), 1),
317 CreateMockWrite(*message_frame_.get(), 3),
318 CreateMockWrite(*closing_frame_.get(), 5)
321 MockRead reads[] = {
322 CreateMockRead(*response_frame_.get(), 2),
323 CreateMockRead(*message_frame_.get(), 4),
324 // Skip sequence 6 to notify closing has been sent.
325 CreateMockRead(*closing_frame_.get(), 7),
326 MockRead(SYNCHRONOUS, 0, 8) // EOF cause OnCloseSpdyStream event.
329 EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
330 writes, arraysize(writes), false));
332 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
333 delegate.SetOnReceivedHeader(
334 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendHelloFrame,
335 base::Unretained(this)));
336 delegate.SetOnReceivedData(
337 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendClosingFrame,
338 base::Unretained(this)));
340 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
342 BoundNetLog net_log;
343 GURL url("ws://example.com/echo");
344 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
346 ASSERT_TRUE(websocket_stream_->stream_);
348 SendRequest();
350 completion_callback_.WaitForResult();
352 EXPECT_EQ(stream_id_, created_stream_id_);
354 websocket_stream_.reset();
356 const std::vector<SpdyWebSocketStreamEvent>& events =
357 delegate.GetSeenEvents();
358 ASSERT_EQ(7U, events.size());
360 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
361 events[0].event_type);
362 EXPECT_LT(0, events[0].result);
363 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
364 events[1].event_type);
365 EXPECT_EQ(OK, events[1].result);
366 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
367 events[2].event_type);
368 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
369 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
370 events[3].event_type);
371 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
372 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
373 events[4].event_type);
374 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[4].result);
375 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
376 events[5].event_type);
377 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
378 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
379 events[6].event_type);
380 EXPECT_EQ(OK, events[6].result);
382 // EOF close SPDY session.
383 EXPECT_TRUE(!http_session_->spdy_session_pool()->HasSession(
384 host_port_proxy_pair_));
385 EXPECT_TRUE(data()->at_read_eof());
386 EXPECT_TRUE(data()->at_write_eof());
389 TEST_F(SpdyWebSocketStreamSpdy2Test, DestructionBeforeClose) {
390 Prepare(1);
391 MockWrite writes[] = {
392 CreateMockWrite(*request_frame_.get(), 1),
393 CreateMockWrite(*message_frame_.get(), 3)
396 MockRead reads[] = {
397 CreateMockRead(*response_frame_.get(), 2),
398 CreateMockRead(*message_frame_.get(), 4),
399 MockRead(ASYNC, ERR_IO_PENDING, 5)
402 EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
403 writes, arraysize(writes), false));
405 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
406 delegate.SetOnReceivedHeader(
407 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendHelloFrame,
408 base::Unretained(this)));
409 delegate.SetOnReceivedData(
410 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSync,
411 base::Unretained(this)));
413 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
415 BoundNetLog net_log;
416 GURL url("ws://example.com/echo");
417 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
419 SendRequest();
421 sync_callback_.WaitForResult();
423 // WebSocketStream destruction remove its SPDY stream from the session.
424 EXPECT_TRUE(session_->IsStreamActive(stream_id_));
425 websocket_stream_.reset();
426 EXPECT_FALSE(session_->IsStreamActive(stream_id_));
428 const std::vector<SpdyWebSocketStreamEvent>& events =
429 delegate.GetSeenEvents();
430 ASSERT_GE(4U, events.size());
432 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
433 events[0].event_type);
434 EXPECT_LT(0, events[0].result);
435 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
436 events[1].event_type);
437 EXPECT_EQ(OK, events[1].result);
438 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
439 events[2].event_type);
440 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
441 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
442 events[3].event_type);
443 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
445 EXPECT_TRUE(http_session_->spdy_session_pool()->HasSession(
446 host_port_proxy_pair_));
447 EXPECT_TRUE(data()->at_read_eof());
448 EXPECT_TRUE(data()->at_write_eof());
451 TEST_F(SpdyWebSocketStreamSpdy2Test, DestructionAfterExplicitClose) {
452 Prepare(1);
453 MockWrite writes[] = {
454 CreateMockWrite(*request_frame_.get(), 1),
455 CreateMockWrite(*message_frame_.get(), 3),
456 CreateMockWrite(*closing_frame_.get(), 5)
459 MockRead reads[] = {
460 CreateMockRead(*response_frame_.get(), 2),
461 CreateMockRead(*message_frame_.get(), 4),
462 MockRead(ASYNC, ERR_IO_PENDING, 6)
465 EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
466 writes, arraysize(writes), false));
468 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
469 delegate.SetOnReceivedHeader(
470 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendHelloFrame,
471 base::Unretained(this)));
472 delegate.SetOnReceivedData(
473 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoClose,
474 base::Unretained(this)));
476 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
478 BoundNetLog net_log;
479 GURL url("ws://example.com/echo");
480 ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
482 SendRequest();
484 completion_callback_.WaitForResult();
486 // SPDY stream has already been removed from the session by Close().
487 EXPECT_FALSE(session_->IsStreamActive(stream_id_));
488 websocket_stream_.reset();
490 const std::vector<SpdyWebSocketStreamEvent>& events =
491 delegate.GetSeenEvents();
492 ASSERT_EQ(5U, events.size());
494 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
495 events[0].event_type);
496 EXPECT_LT(0, events[0].result);
497 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
498 events[1].event_type);
499 EXPECT_EQ(OK, events[1].result);
500 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
501 events[2].event_type);
502 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
503 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
504 events[3].event_type);
505 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
506 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE, events[4].event_type);
508 EXPECT_TRUE(http_session_->spdy_session_pool()->HasSession(
509 host_port_proxy_pair_));
512 TEST_F(SpdyWebSocketStreamSpdy2Test, IOPending) {
513 Prepare(1);
514 scoped_ptr<SpdyFrame> settings_frame(
515 ConstructSpdySettings(spdy_settings_to_send_));
516 MockWrite writes[] = {
517 // Setting throttling make SpdySession send settings frame automatically.
518 CreateMockWrite(*settings_frame.get(), 1),
519 CreateMockWrite(*request_frame_.get(), 3),
520 CreateMockWrite(*message_frame_.get(), 6),
521 CreateMockWrite(*closing_frame_.get(), 9)
524 MockRead reads[] = {
525 CreateMockRead(*settings_frame.get(), 2),
526 CreateMockRead(*response_frame_.get(), 4),
527 // Skip sequence 5 (I/O Pending)
528 CreateMockRead(*message_frame_.get(), 7),
529 // Skip sequence 8 (I/O Pending)
530 CreateMockRead(*closing_frame_.get(), 10),
531 MockRead(SYNCHRONOUS, 0, 11) // EOF cause OnCloseSpdyStream event.
534 EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
535 writes, arraysize(writes), true));
537 // Create a dummy WebSocketStream which cause ERR_IO_PENDING to another
538 // WebSocketStream under test.
539 SpdyWebSocketStreamEventRecorder block_delegate((CompletionCallback()));
541 scoped_ptr<SpdyWebSocketStream> block_stream(
542 new SpdyWebSocketStream(session_, &block_delegate));
543 BoundNetLog block_net_log;
544 GURL block_url("ws://example.com/block");
545 ASSERT_EQ(OK,
546 block_stream->InitializeStream(block_url, HIGHEST, block_net_log));
548 // Create a WebSocketStream under test.
549 SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
550 delegate.SetOnCreated(
551 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSync,
552 base::Unretained(this)));
553 delegate.SetOnReceivedHeader(
554 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendHelloFrame,
555 base::Unretained(this)));
556 delegate.SetOnReceivedData(
557 base::Bind(&SpdyWebSocketStreamSpdy2Test::DoSendClosingFrame,
558 base::Unretained(this)));
560 websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
561 BoundNetLog net_log;
562 GURL url("ws://example.com/echo");
563 ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
564 url, HIGHEST, net_log));
566 // Delete the fist stream to allow create the second stream.
567 block_stream.reset();
568 ASSERT_EQ(OK, sync_callback_.WaitForResult());
570 SendRequest();
572 completion_callback_.WaitForResult();
574 websocket_stream_.reset();
576 const std::vector<SpdyWebSocketStreamEvent>& block_events =
577 block_delegate.GetSeenEvents();
578 ASSERT_EQ(0U, block_events.size());
580 const std::vector<SpdyWebSocketStreamEvent>& events =
581 delegate.GetSeenEvents();
582 ASSERT_EQ(8U, events.size());
583 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CREATED,
584 events[0].event_type);
585 EXPECT_EQ(0, events[0].result);
586 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
587 events[1].event_type);
588 EXPECT_LT(0, events[1].result);
589 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
590 events[2].event_type);
591 EXPECT_EQ(OK, events[2].result);
592 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
593 events[3].event_type);
594 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
595 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
596 events[4].event_type);
597 EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[4].result);
598 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
599 events[5].event_type);
600 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
601 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
602 events[6].event_type);
603 EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[6].result);
604 EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
605 events[7].event_type);
606 EXPECT_EQ(OK, events[7].result);
608 // EOF close SPDY session.
609 EXPECT_TRUE(!http_session_->spdy_session_pool()->HasSession(
610 host_port_proxy_pair_));
611 EXPECT_TRUE(data()->at_read_eof());
612 EXPECT_TRUE(data()->at_write_eof());
615 } // namespace net