net/spdy/spdy_websocket_stream_spdy3_unittest.cc

   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.
   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/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_spdy3.h"
  19 #include "net/spdy/spdy_websocket_test_util_spdy3.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 using namespace net::test_spdy3;
  23
  24 namespace net {
  25
  26 namespace {
  27
  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,
  36   };
  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) {}
  45
  46   EventType event_type;
  47   SpdyHeaderBlock headers;
  48   int result;
  49   std::string data;
  50 };
  51
  52 class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
  53  public:
  54   explicit SpdyWebSocketStreamEventRecorder(const CompletionCallback& callback)
  55       : callback_(callback) {}
  56   virtual ~SpdyWebSocketStreamEventRecorder() {}
  57
  58   typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
  59
  60   void SetOnCreated(const StreamEventCallback& callback) {
  61     on_created_ = callback;
  62   }
  63   void SetOnSentHeaders(const StreamEventCallback& callback) {
  64     on_sent_headers_ = callback;
  65   }
  66   void SetOnReceivedHeader(const StreamEventCallback& callback) {
  67     on_received_header_ = callback;
  68   }
  69   void SetOnSentData(const StreamEventCallback& callback) {
  70     on_sent_data_ = callback;
  71   }
  72   void SetOnReceivedData(const StreamEventCallback& callback) {
  73     on_received_data_ = callback;
  74   }
  75   void SetOnClose(const StreamEventCallback& callback) {
  76     on_close_ = callback;
  77   }
  78
  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());
  87   }
  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());
  96   }
  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;
 108   }
 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());
 118   }
 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());
 128   }
 129   virtual void OnCloseSpdyStream() {
 130     events_.push_back(
 131         SpdyWebSocketStreamEvent(
 132             SpdyWebSocketStreamEvent::EVENT_CLOSE,
 133             SpdyHeaderBlock(),
 134             OK,
 135             std::string()));
 136     if (!on_close_.is_null())
 137       on_close_.Run(&events_.back());
 138     if (!callback_.is_null())
 139       callback_.Run(OK);
 140   }
 141
 142   const std::vector<SpdyWebSocketStreamEvent>& GetSeenEvents() const {
 143     return events_;
 144   }
 145
 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_;
 155
 156   DISALLOW_COPY_AND_ASSIGN(SpdyWebSocketStreamEventRecorder);
 157 };
 158
 159 }  // namespace
 160
 161 class SpdyWebSocketStreamSpdy3Test : public testing::Test {
 162  public:
 163   OrderedSocketData* data() { return data_.get(); }
 164
 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);
 169   }
 170
 171   void DoSendClosingFrame(SpdyWebSocketStreamEvent* event) {
 172     websocket_stream_->SendData(kClosingFrame, kClosingFrameLength);
 173   }
 174
 175   void DoClose(SpdyWebSocketStreamEvent* event) {
 176     websocket_stream_->Close();
 177   }
 178
 179   void DoSync(SpdyWebSocketStreamEvent* event) {
 180     sync_callback_.callback().Run(OK);
 181   }
 182
 183  protected:
 184   SpdyWebSocketStreamSpdy3Test() {}
 185   virtual ~SpdyWebSocketStreamSpdy3Test() {}
 186
 187   virtual void SetUp() {
 188     SpdySession::set_default_protocol(kProtoSPDY3);
 189
 190     host_port_pair_.set_host("example.com");
 191     host_port_pair_.set_port(80);
 192     host_port_proxy_pair_.first = host_port_pair_;
 193     host_port_proxy_pair_.second = ProxyServer::Direct();
 194
 195     spdy_settings_id_to_set_ = SETTINGS_MAX_CONCURRENT_STREAMS;
 196     spdy_settings_flags_to_set_ = SETTINGS_FLAG_PLEASE_PERSIST;
 197     spdy_settings_value_to_set_ = 1;
 198
 199     spdy_settings_to_send_[spdy_settings_id_to_set_] =
 200         SettingsFlagsAndValue(
 201             SETTINGS_FLAG_PERSISTED, spdy_settings_value_to_set_);
 202   }
 203
 204   virtual void TearDown() {
 205     MessageLoop::current()->RunAllPending();
 206   }
 207
 208   void Prepare(SpdyStreamId stream_id) {
 209     stream_id_ = stream_id;
 210
 211     request_frame_.reset(ConstructSpdyWebSocketSynStream(
 212         stream_id_,
 213         "/echo",
 214         "example.com",
 215         "http://example.com/wsdemo"));
 216
 217     response_frame_.reset(ConstructSpdyWebSocketSynReply(stream_id_));
 218
 219     message_frame_.reset(ConstructSpdyWebSocketDataFrame(
 220         kMessageFrame,
 221         kMessageFrameLength,
 222         stream_id_,
 223         false));
 224
 225     closing_frame_.reset(ConstructSpdyWebSocketDataFrame(
 226         kClosingFrame,
 227         kClosingFrameLength,
 228         stream_id_,
 229         false));
 230   }
 231
 232   int InitSession(MockRead* reads, size_t reads_count,
 233                   MockWrite* writes, size_t writes_count,
 234                   bool throttling) {
 235     data_.reset(new OrderedSocketData(reads, reads_count,
 236                                       writes, writes_count));
 237     session_deps_.socket_factory->AddSocketDataProvider(data_.get());
 238     http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 239     SpdySessionPool* spdy_session_pool(http_session_->spdy_session_pool());
 240
 241     if (throttling) {
 242       // Set max concurrent streams to 1.
 243       spdy_session_pool->http_server_properties()->SetSpdySetting(
 244           host_port_pair_,
 245           spdy_settings_id_to_set_,
 246           spdy_settings_flags_to_set_,
 247           spdy_settings_value_to_set_);
 248     }
 249
 250     EXPECT_FALSE(spdy_session_pool->HasSession(host_port_proxy_pair_));
 251     session_ = spdy_session_pool->Get(host_port_proxy_pair_, BoundNetLog());
 252     EXPECT_TRUE(spdy_session_pool->HasSession(host_port_proxy_pair_));
 253     transport_params_ = new TransportSocketParams(host_port_pair_, MEDIUM,
 254                                                   false, false,
 255                                                   OnHostResolutionCallback());
 256     TestCompletionCallback callback;
 257     scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
 258     EXPECT_EQ(ERR_IO_PENDING,
 259               connection->Init(host_port_pair_.ToString(), transport_params_,
 260                                MEDIUM, callback.callback(),
 261                                http_session_->GetTransportSocketPool(
 262                                    HttpNetworkSession::NORMAL_SOCKET_POOL),
 263                                BoundNetLog()));
 264     EXPECT_EQ(OK, callback.WaitForResult());
 265     return session_->InitializeWithSocket(connection.release(), false, OK);
 266   }
 267
 268   void SendRequest() {
 269     scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
 270     (*headers)[":path"] = "/echo";
 271     (*headers)[":host"] = "example.com";
 272     (*headers)[":version"] = "WebSocket/13";
 273     (*headers)[":scheme"] = "ws";
 274     (*headers)[":origin"] = "http://example.com/wsdemo";
 275
 276     websocket_stream_->SendRequest(headers.Pass());
 277   }
 278
 279   SpdySettingsIds spdy_settings_id_to_set_;
 280   SpdySettingsFlags spdy_settings_flags_to_set_;
 281   uint32 spdy_settings_value_to_set_;
 282   SettingsMap spdy_settings_to_send_;
 283   SpdySessionDependencies session_deps_;
 284   scoped_ptr<OrderedSocketData> data_;
 285   scoped_refptr<HttpNetworkSession> http_session_;
 286   scoped_refptr<SpdySession> session_;
 287   scoped_refptr<TransportSocketParams> transport_params_;
 288   scoped_ptr<SpdyWebSocketStream> websocket_stream_;
 289   SpdyStreamId stream_id_;
 290   SpdyStreamId created_stream_id_;
 291   scoped_ptr<SpdyFrame> request_frame_;
 292   scoped_ptr<SpdyFrame> response_frame_;
 293   scoped_ptr<SpdyFrame> message_frame_;
 294   scoped_ptr<SpdyFrame> closing_frame_;
 295   HostPortPair host_port_pair_;
 296   HostPortProxyPair host_port_proxy_pair_;
 297   TestCompletionCallback completion_callback_;
 298   TestCompletionCallback sync_callback_;
 299
 300   static const char kMessageFrame[];
 301   static const char kClosingFrame[];
 302   static const size_t kMessageFrameLength;
 303   static const size_t kClosingFrameLength;
 304
 305  private:
 306   SpdyTestStateHelper spdy_state_;
 307 };
 308
 309 // TODO(toyoshim): Replace old framing data to new one, then use HEADERS and
 310 // data frames.
 311 const char SpdyWebSocketStreamSpdy3Test::kMessageFrame[] = "\x81\x05hello";
 312 const char SpdyWebSocketStreamSpdy3Test::kClosingFrame[] = "\x88\0";
 313 const size_t SpdyWebSocketStreamSpdy3Test::kMessageFrameLength =
 314     arraysize(SpdyWebSocketStreamSpdy3Test::kMessageFrame) - 1;
 315 const size_t SpdyWebSocketStreamSpdy3Test::kClosingFrameLength =
 316     arraysize(SpdyWebSocketStreamSpdy3Test::kClosingFrame) - 1;
 317
 318 TEST_F(SpdyWebSocketStreamSpdy3Test, Basic) {
 319   Prepare(1);
 320   MockWrite writes[] = {
 321     CreateMockWrite(*request_frame_.get(), 1),
 322     CreateMockWrite(*message_frame_.get(), 3),
 323     CreateMockWrite(*closing_frame_.get(), 5)
 324   };
 325
 326   MockRead reads[] = {
 327     CreateMockRead(*response_frame_.get(), 2),
 328     CreateMockRead(*message_frame_.get(), 4),
 329     // Skip sequence 6 to notify closing has been sent.
 330     CreateMockRead(*closing_frame_.get(), 7),
 331     MockRead(SYNCHRONOUS, 0, 8)  // EOF cause OnCloseSpdyStream event.
 332   };
 333
 334   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
 335                             writes, arraysize(writes), false));
 336
 337   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
 338   delegate.SetOnReceivedHeader(
 339       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
 340                  base::Unretained(this)));
 341   delegate.SetOnReceivedData(
 342       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendClosingFrame,
 343                  base::Unretained(this)));
 344
 345   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 346
 347   BoundNetLog net_log;
 348   GURL url("ws://example.com/echo");
 349   ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
 350
 351   ASSERT_TRUE(websocket_stream_->stream_);
 352
 353   SendRequest();
 354
 355   completion_callback_.WaitForResult();
 356
 357   EXPECT_EQ(stream_id_, created_stream_id_);
 358
 359   websocket_stream_.reset();
 360
 361   const std::vector<SpdyWebSocketStreamEvent>& events =
 362       delegate.GetSeenEvents();
 363   ASSERT_EQ(7U, events.size());
 364
 365   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
 366             events[0].event_type);
 367   EXPECT_LT(0, events[0].result);
 368   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
 369             events[1].event_type);
 370   EXPECT_EQ(OK, events[1].result);
 371   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
 372             events[2].event_type);
 373   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
 374   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
 375             events[3].event_type);
 376   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
 377   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
 378             events[4].event_type);
 379   EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[4].result);
 380   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
 381             events[5].event_type);
 382   EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
 383   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
 384             events[6].event_type);
 385   EXPECT_EQ(OK, events[6].result);
 386
 387   // EOF close SPDY session.
 388   EXPECT_TRUE(!http_session_->spdy_session_pool()->HasSession(
 389       host_port_proxy_pair_));
 390   EXPECT_TRUE(data()->at_read_eof());
 391   EXPECT_TRUE(data()->at_write_eof());
 392 }
 393
 394 TEST_F(SpdyWebSocketStreamSpdy3Test, DestructionBeforeClose) {
 395   Prepare(1);
 396   MockWrite writes[] = {
 397     CreateMockWrite(*request_frame_.get(), 1),
 398     CreateMockWrite(*message_frame_.get(), 3)
 399   };
 400
 401   MockRead reads[] = {
 402     CreateMockRead(*response_frame_.get(), 2),
 403     CreateMockRead(*message_frame_.get(), 4),
 404     MockRead(ASYNC, ERR_IO_PENDING, 5)
 405   };
 406
 407   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
 408                             writes, arraysize(writes), false));
 409
 410   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
 411   delegate.SetOnReceivedHeader(
 412       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
 413                  base::Unretained(this)));
 414   delegate.SetOnReceivedData(
 415       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSync,
 416                  base::Unretained(this)));
 417
 418   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 419
 420   BoundNetLog net_log;
 421   GURL url("ws://example.com/echo");
 422   ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
 423
 424   SendRequest();
 425
 426   sync_callback_.WaitForResult();
 427
 428   // WebSocketStream destruction remove its SPDY stream from the session.
 429   EXPECT_TRUE(session_->IsStreamActive(stream_id_));
 430   websocket_stream_.reset();
 431   EXPECT_FALSE(session_->IsStreamActive(stream_id_));
 432
 433   const std::vector<SpdyWebSocketStreamEvent>& events =
 434       delegate.GetSeenEvents();
 435   ASSERT_GE(4U, events.size());
 436
 437   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
 438             events[0].event_type);
 439   EXPECT_LT(0, events[0].result);
 440   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
 441             events[1].event_type);
 442   EXPECT_EQ(OK, events[1].result);
 443   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
 444             events[2].event_type);
 445   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
 446   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
 447             events[3].event_type);
 448   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
 449
 450   EXPECT_TRUE(http_session_->spdy_session_pool()->HasSession(
 451       host_port_proxy_pair_));
 452   EXPECT_TRUE(data()->at_read_eof());
 453   EXPECT_TRUE(data()->at_write_eof());
 454 }
 455
 456 TEST_F(SpdyWebSocketStreamSpdy3Test, DestructionAfterExplicitClose) {
 457   Prepare(1);
 458   MockWrite writes[] = {
 459     CreateMockWrite(*request_frame_.get(), 1),
 460     CreateMockWrite(*message_frame_.get(), 3),
 461     CreateMockWrite(*closing_frame_.get(), 5)
 462   };
 463
 464   MockRead reads[] = {
 465     CreateMockRead(*response_frame_.get(), 2),
 466     CreateMockRead(*message_frame_.get(), 4),
 467     MockRead(ASYNC, ERR_IO_PENDING, 6)
 468   };
 469
 470   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
 471                             writes, arraysize(writes), false));
 472
 473   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
 474   delegate.SetOnReceivedHeader(
 475       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
 476                  base::Unretained(this)));
 477   delegate.SetOnReceivedData(
 478       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoClose,
 479                  base::Unretained(this)));
 480
 481   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 482
 483   BoundNetLog net_log;
 484   GURL url("ws://example.com/echo");
 485   ASSERT_EQ(OK, websocket_stream_->InitializeStream(url, HIGHEST, net_log));
 486
 487   SendRequest();
 488
 489   completion_callback_.WaitForResult();
 490
 491   // SPDY stream has already been removed from the session by Close().
 492   EXPECT_FALSE(session_->IsStreamActive(stream_id_));
 493   websocket_stream_.reset();
 494
 495   const std::vector<SpdyWebSocketStreamEvent>& events =
 496       delegate.GetSeenEvents();
 497   ASSERT_EQ(5U, events.size());
 498
 499   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
 500             events[0].event_type);
 501   EXPECT_LT(0, events[0].result);
 502   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
 503             events[1].event_type);
 504   EXPECT_EQ(OK, events[1].result);
 505   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
 506             events[2].event_type);
 507   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[2].result);
 508   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
 509             events[3].event_type);
 510   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
 511   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE, events[4].event_type);
 512
 513   EXPECT_TRUE(http_session_->spdy_session_pool()->HasSession(
 514       host_port_proxy_pair_));
 515 }
 516
 517 TEST_F(SpdyWebSocketStreamSpdy3Test, IOPending) {
 518   Prepare(1);
 519   scoped_ptr<SpdyFrame> settings_frame(
 520       ConstructSpdySettings(spdy_settings_to_send_));
 521   MockWrite writes[] = {
 522     // Setting throttling make SpdySession send settings frame automatically.
 523     CreateMockWrite(*settings_frame.get(), 1),
 524     CreateMockWrite(*request_frame_.get(), 3),
 525     CreateMockWrite(*message_frame_.get(), 6),
 526     CreateMockWrite(*closing_frame_.get(), 9)
 527   };
 528
 529   MockRead reads[] = {
 530     CreateMockRead(*settings_frame.get(), 2),
 531     CreateMockRead(*response_frame_.get(), 4),
 532     // Skip sequence 5 (I/O Pending)
 533     CreateMockRead(*message_frame_.get(), 7),
 534     // Skip sequence 8 (I/O Pending)
 535     CreateMockRead(*closing_frame_.get(), 10),
 536     MockRead(SYNCHRONOUS, 0, 11)  // EOF cause OnCloseSpdyStream event.
 537   };
 538
 539   EXPECT_EQ(OK, InitSession(reads, arraysize(reads),
 540                             writes, arraysize(writes), true));
 541
 542   // Create a dummy WebSocketStream which cause ERR_IO_PENDING to another
 543   // WebSocketStream under test.
 544   SpdyWebSocketStreamEventRecorder block_delegate((CompletionCallback()));
 545
 546   scoped_ptr<SpdyWebSocketStream> block_stream(
 547       new SpdyWebSocketStream(session_, &block_delegate));
 548   BoundNetLog block_net_log;
 549   GURL block_url("ws://example.com/block");
 550   ASSERT_EQ(OK,
 551             block_stream->InitializeStream(block_url, HIGHEST, block_net_log));
 552
 553   // Create a WebSocketStream under test.
 554   SpdyWebSocketStreamEventRecorder delegate(completion_callback_.callback());
 555   delegate.SetOnCreated(
 556       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSync,
 557                  base::Unretained(this)));
 558   delegate.SetOnReceivedHeader(
 559       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendHelloFrame,
 560                  base::Unretained(this)));
 561   delegate.SetOnReceivedData(
 562       base::Bind(&SpdyWebSocketStreamSpdy3Test::DoSendClosingFrame,
 563                  base::Unretained(this)));
 564
 565   websocket_stream_.reset(new SpdyWebSocketStream(session_, &delegate));
 566   BoundNetLog net_log;
 567   GURL url("ws://example.com/echo");
 568   ASSERT_EQ(ERR_IO_PENDING, websocket_stream_->InitializeStream(
 569       url, HIGHEST, net_log));
 570
 571   // Delete the first stream to allow create the second stream.
 572   block_stream.reset();
 573   ASSERT_EQ(OK, sync_callback_.WaitForResult());
 574
 575   SendRequest();
 576
 577   completion_callback_.WaitForResult();
 578
 579   websocket_stream_.reset();
 580
 581   const std::vector<SpdyWebSocketStreamEvent>& block_events =
 582       block_delegate.GetSeenEvents();
 583   ASSERT_EQ(0U, block_events.size());
 584
 585   const std::vector<SpdyWebSocketStreamEvent>& events =
 586       delegate.GetSeenEvents();
 587   ASSERT_EQ(8U, events.size());
 588   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CREATED,
 589             events[0].event_type);
 590   EXPECT_EQ(0, events[0].result);
 591   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
 592             events[1].event_type);
 593   EXPECT_LT(0, events[1].result);
 594   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
 595             events[2].event_type);
 596   EXPECT_EQ(OK, events[2].result);
 597   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
 598             events[3].event_type);
 599   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[3].result);
 600   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
 601             events[4].event_type);
 602   EXPECT_EQ(static_cast<int>(kMessageFrameLength), events[4].result);
 603   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
 604             events[5].event_type);
 605   EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[5].result);
 606   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
 607             events[6].event_type);
 608   EXPECT_EQ(static_cast<int>(kClosingFrameLength), events[6].result);
 609   EXPECT_EQ(SpdyWebSocketStreamEvent::EVENT_CLOSE,
 610             events[7].event_type);
 611   EXPECT_EQ(OK, events[7].result);
 612
 613   // EOF close SPDY session.
 614   EXPECT_TRUE(!http_session_->spdy_session_pool()->HasSession(
 615       host_port_proxy_pair_));
 616   EXPECT_TRUE(data()->at_read_eof());
 617   EXPECT_TRUE(data()->at_write_eof());
 618 }
 619
 620 }  // namespace net