net/spdy/spdy_stream_unittest.cc

   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 <cstddef>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_piece.h"
  13 #include "net/base/completion_callback.h"
  14 #include "net/base/net_log_unittest.h"
  15 #include "net/base/request_priority.h"
  16 #include "net/socket/next_proto.h"
  17 #include "net/socket/socket_test_util.h"
  18 #include "net/spdy/buffered_spdy_framer.h"
  19 #include "net/spdy/spdy_http_utils.h"
  20 #include "net/spdy/spdy_protocol.h"
  21 #include "net/spdy/spdy_session.h"
  22 #include "net/spdy/spdy_stream.h"
  23 #include "net/spdy/spdy_stream_test_util.h"
  24 #include "net/spdy/spdy_test_util_common.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 // TODO(ukai): factor out common part with spdy_http_stream_unittest.cc
  28 //
  29 namespace net {
  30
  31 namespace test {
  32
  33 namespace {
  34
  35 const char kStreamUrl[] = "http://www.google.com/";
  36 const char kPostBody[] = "\0hello!\xff";
  37 const size_t kPostBodyLength = arraysize(kPostBody);
  38 const base::StringPiece kPostBodyStringPiece(kPostBody, kPostBodyLength);
  39
  40 class SpdyStreamTest : public ::testing::Test,
  41                        public ::testing::WithParamInterface<NextProto> {
  42  protected:
  43   // A function that takes a SpdyStream and the number of bytes which
  44   // will unstall the next frame completely.
  45   typedef base::Callback<void(const base::WeakPtr<SpdyStream>&, int32)>
  46       UnstallFunction;
  47
  48   SpdyStreamTest()
  49       : spdy_util_(GetParam()),
  50         session_deps_(GetParam()),
  51         offset_(0) {}
  52
  53   base::WeakPtr<SpdySession> CreateDefaultSpdySession() {
  54     SpdySessionKey key(HostPortPair("www.google.com", 80),
  55                        ProxyServer::Direct(),
  56                        kPrivacyModeDisabled);
  57     return CreateInsecureSpdySession(session_, key, BoundNetLog());
  58   }
  59
  60   virtual void TearDown() {
  61     base::MessageLoop::current()->RunUntilIdle();
  62   }
  63
  64   void RunResumeAfterUnstallRequestResponseTest(
  65       const UnstallFunction& unstall_function);
  66
  67   void RunResumeAfterUnstallBidirectionalTest(
  68       const UnstallFunction& unstall_function);
  69
  70   // Add{Read,Write}() populates lists that are eventually passed to a
  71   // SocketData class. |frame| must live for the whole test.
  72
  73   void AddRead(const SpdyFrame& frame) {
  74     reads_.push_back(CreateMockRead(frame, offset_++));
  75   }
  76
  77   void AddWrite(const SpdyFrame& frame) {
  78     writes_.push_back(CreateMockWrite(frame, offset_++));
  79   }
  80
  81   void AddReadEOF() {
  82     reads_.push_back(MockRead(ASYNC, 0, offset_++));
  83   }
  84
  85   MockRead* GetReads() {
  86     return vector_as_array(&reads_);
  87   }
  88
  89   size_t GetNumReads() const {
  90     return reads_.size();
  91   }
  92
  93   MockWrite* GetWrites() {
  94     return vector_as_array(&writes_);
  95   }
  96
  97   int GetNumWrites() const {
  98     return writes_.size();
  99   }
 100
 101   SpdyTestUtil spdy_util_;
 102   SpdySessionDependencies session_deps_;
 103   scoped_refptr<HttpNetworkSession> session_;
 104
 105  private:
 106   // Used by Add{Read,Write}() above.
 107   std::vector<MockWrite> writes_;
 108   std::vector<MockRead> reads_;
 109   int offset_;
 110 };
 111
 112 INSTANTIATE_TEST_CASE_P(
 113     NextProto,
 114     SpdyStreamTest,
 115     testing::Values(kProtoDeprecatedSPDY2,
 116                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2,
 117                     kProtoHTTP2Draft04));
 118
 119 TEST_P(SpdyStreamTest, SendDataAfterOpen) {
 120   GURL url(kStreamUrl);
 121
 122   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 123
 124   scoped_ptr<SpdyFrame> req(
 125       spdy_util_.ConstructSpdyPost(
 126           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 127   AddWrite(*req);
 128
 129   scoped_ptr<SpdyFrame> resp(
 130       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
 131   AddRead(*resp);
 132
 133   scoped_ptr<SpdyFrame> msg(
 134       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
 135   AddWrite(*msg);
 136
 137   scoped_ptr<SpdyFrame> echo(
 138       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
 139   AddRead(*echo);
 140
 141   AddReadEOF();
 142
 143   OrderedSocketData data(GetReads(), GetNumReads(),
 144                          GetWrites(), GetNumWrites());
 145   MockConnect connect_data(SYNCHRONOUS, OK);
 146   data.set_connect_data(connect_data);
 147
 148   session_deps_.socket_factory->AddSocketDataProvider(&data);
 149
 150   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 151
 152   base::WeakPtr<SpdyStream> stream =
 153       CreateStreamSynchronously(
 154           SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog());
 155   ASSERT_TRUE(stream.get() != NULL);
 156
 157   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
 158   stream->SetDelegate(&delegate);
 159
 160   EXPECT_FALSE(stream->HasUrlFromHeaders());
 161
 162   scoped_ptr<SpdyHeaderBlock> headers(
 163       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 164   EXPECT_EQ(ERR_IO_PENDING,
 165             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 166   EXPECT_TRUE(stream->HasUrlFromHeaders());
 167   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 168
 169   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 170
 171   EXPECT_TRUE(delegate.send_headers_completed());
 172   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
 173   EXPECT_EQ("HTTP/1.1",
 174             delegate.GetResponseHeaderValue(spdy_util_.GetVersionKey()));
 175   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
 176             delegate.TakeReceivedData());
 177   EXPECT_TRUE(data.at_write_eof());
 178 }
 179
 180 TEST_P(SpdyStreamTest, PushedStream) {
 181   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 182
 183   AddReadEOF();
 184
 185   OrderedSocketData data(GetReads(), GetNumReads(),
 186                          GetWrites(), GetNumWrites());
 187   MockConnect connect_data(SYNCHRONOUS, OK);
 188   data.set_connect_data(connect_data);
 189
 190   session_deps_.socket_factory->AddSocketDataProvider(&data);
 191
 192   base::WeakPtr<SpdySession> spdy_session(CreateDefaultSpdySession());
 193
 194   // Conjure up a stream.
 195   SpdyStream stream(SPDY_PUSH_STREAM,
 196                     spdy_session,
 197                     GURL(),
 198                     DEFAULT_PRIORITY,
 199                     kSpdyStreamInitialWindowSize,
 200                     kSpdyStreamInitialWindowSize,
 201                     BoundNetLog());
 202   stream.set_stream_id(2);
 203   EXPECT_FALSE(stream.HasUrlFromHeaders());
 204
 205   // Set a couple of headers.
 206   SpdyHeaderBlock response;
 207   spdy_util_.AddUrlToHeaderBlock(kStreamUrl, &response);
 208   stream.OnInitialResponseHeadersReceived(
 209       response, base::Time::Now(), base::TimeTicks::Now());
 210
 211   // Send some basic headers.
 212   SpdyHeaderBlock headers;
 213   headers[spdy_util_.GetStatusKey()] = "200";
 214   headers[spdy_util_.GetVersionKey()] = "OK";
 215   stream.OnAdditionalResponseHeadersReceived(headers);
 216
 217   EXPECT_TRUE(stream.HasUrlFromHeaders());
 218   EXPECT_EQ(kStreamUrl, stream.GetUrlFromHeaders().spec());
 219
 220   StreamDelegateDoNothing delegate(stream.GetWeakPtr());
 221   stream.SetDelegate(&delegate);
 222
 223   base::MessageLoop::current()->RunUntilIdle();
 224
 225   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
 226
 227   EXPECT_TRUE(spdy_session == NULL);
 228 }
 229
 230 TEST_P(SpdyStreamTest, StreamError) {
 231   GURL url(kStreamUrl);
 232
 233   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 234
 235   scoped_ptr<SpdyFrame> req(
 236       spdy_util_.ConstructSpdyPost(
 237           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 238   AddWrite(*req);
 239
 240   scoped_ptr<SpdyFrame> resp(
 241       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 242   AddRead(*resp);
 243
 244   scoped_ptr<SpdyFrame> msg(
 245       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
 246   AddWrite(*msg);
 247
 248   scoped_ptr<SpdyFrame> echo(
 249       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
 250   AddRead(*echo);
 251
 252   AddReadEOF();
 253
 254   CapturingBoundNetLog log;
 255
 256   OrderedSocketData data(GetReads(), GetNumReads(),
 257                          GetWrites(), GetNumWrites());
 258   MockConnect connect_data(SYNCHRONOUS, OK);
 259   data.set_connect_data(connect_data);
 260
 261   session_deps_.socket_factory->AddSocketDataProvider(&data);
 262
 263   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 264
 265   base::WeakPtr<SpdyStream> stream =
 266       CreateStreamSynchronously(
 267           SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, log.bound());
 268   ASSERT_TRUE(stream.get() != NULL);
 269
 270   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
 271   stream->SetDelegate(&delegate);
 272
 273   EXPECT_FALSE(stream->HasUrlFromHeaders());
 274
 275   scoped_ptr<SpdyHeaderBlock> headers(
 276       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 277   EXPECT_EQ(ERR_IO_PENDING,
 278             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 279   EXPECT_TRUE(stream->HasUrlFromHeaders());
 280   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 281
 282   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 283
 284   const SpdyStreamId stream_id = delegate.stream_id();
 285
 286   EXPECT_TRUE(delegate.send_headers_completed());
 287   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
 288   EXPECT_EQ("HTTP/1.1",
 289             delegate.GetResponseHeaderValue(spdy_util_.GetVersionKey()));
 290   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
 291             delegate.TakeReceivedData());
 292   EXPECT_TRUE(data.at_write_eof());
 293
 294   // Check that the NetLog was filled reasonably.
 295   net::CapturingNetLog::CapturedEntryList entries;
 296   log.GetEntries(&entries);
 297   EXPECT_LT(0u, entries.size());
 298
 299   // Check that we logged SPDY_STREAM_ERROR correctly.
 300   int pos = net::ExpectLogContainsSomewhere(
 301       entries, 0,
 302       net::NetLog::TYPE_SPDY_STREAM_ERROR,
 303       net::NetLog::PHASE_NONE);
 304
 305   int stream_id2;
 306   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &stream_id2));
 307   EXPECT_EQ(static_cast<int>(stream_id), stream_id2);
 308 }
 309
 310 // Make sure that large blocks of data are properly split up into
 311 // frame-sized chunks for a request/response (i.e., an HTTP-like)
 312 // stream.
 313 TEST_P(SpdyStreamTest, SendLargeDataAfterOpenRequestResponse) {
 314   GURL url(kStreamUrl);
 315
 316   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 317
 318   scoped_ptr<SpdyFrame> req(
 319       spdy_util_.ConstructSpdyPost(
 320           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 321   AddWrite(*req);
 322
 323   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
 324   scoped_ptr<SpdyFrame> chunk(
 325       spdy_util_.ConstructSpdyBodyFrame(
 326           1, chunk_data.data(), chunk_data.length(), false));
 327   AddWrite(*chunk);
 328   AddWrite(*chunk);
 329
 330   scoped_ptr<SpdyFrame> last_chunk(
 331       spdy_util_.ConstructSpdyBodyFrame(
 332           1, chunk_data.data(), chunk_data.length(), true));
 333   AddWrite(*last_chunk);
 334
 335   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
 336   AddRead(*resp);
 337
 338   AddReadEOF();
 339
 340   OrderedSocketData data(GetReads(), GetNumReads(),
 341                          GetWrites(), GetNumWrites());
 342   MockConnect connect_data(SYNCHRONOUS, OK);
 343   data.set_connect_data(connect_data);
 344
 345   session_deps_.socket_factory->AddSocketDataProvider(&data);
 346
 347   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 348
 349   base::WeakPtr<SpdyStream> stream =
 350       CreateStreamSynchronously(
 351           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
 352   ASSERT_TRUE(stream.get() != NULL);
 353
 354   std::string body_data(3 * kMaxSpdyFrameChunkSize, 'x');
 355   StreamDelegateWithBody delegate(stream, body_data);
 356   stream->SetDelegate(&delegate);
 357
 358   EXPECT_FALSE(stream->HasUrlFromHeaders());
 359
 360   scoped_ptr<SpdyHeaderBlock> headers(
 361       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 362   EXPECT_EQ(ERR_IO_PENDING,
 363             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 364   EXPECT_TRUE(stream->HasUrlFromHeaders());
 365   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 366
 367   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 368
 369   EXPECT_TRUE(delegate.send_headers_completed());
 370   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
 371   EXPECT_EQ("HTTP/1.1",
 372             delegate.GetResponseHeaderValue(spdy_util_.GetVersionKey()));
 373   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
 374   EXPECT_TRUE(data.at_write_eof());
 375 }
 376
 377 // Make sure that large blocks of data are properly split up into
 378 // frame-sized chunks for a bidirectional (i.e., non-HTTP-like)
 379 // stream.
 380 TEST_P(SpdyStreamTest, SendLargeDataAfterOpenBidirectional) {
 381   GURL url(kStreamUrl);
 382
 383   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 384
 385   scoped_ptr<SpdyFrame> req(
 386       spdy_util_.ConstructSpdyPost(
 387           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 388   AddWrite(*req);
 389
 390   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
 391   AddRead(*resp);
 392
 393   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
 394   scoped_ptr<SpdyFrame> chunk(
 395       spdy_util_.ConstructSpdyBodyFrame(
 396           1, chunk_data.data(), chunk_data.length(), false));
 397   AddWrite(*chunk);
 398   AddWrite(*chunk);
 399   AddWrite(*chunk);
 400
 401   AddReadEOF();
 402
 403   OrderedSocketData data(GetReads(), GetNumReads(),
 404                          GetWrites(), GetNumWrites());
 405   MockConnect connect_data(SYNCHRONOUS, OK);
 406   data.set_connect_data(connect_data);
 407
 408   session_deps_.socket_factory->AddSocketDataProvider(&data);
 409
 410   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 411
 412   base::WeakPtr<SpdyStream> stream =
 413       CreateStreamSynchronously(
 414           SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog());
 415   ASSERT_TRUE(stream.get() != NULL);
 416
 417   std::string body_data(3 * kMaxSpdyFrameChunkSize, 'x');
 418   StreamDelegateSendImmediate delegate(stream, body_data);
 419   stream->SetDelegate(&delegate);
 420
 421   EXPECT_FALSE(stream->HasUrlFromHeaders());
 422
 423   scoped_ptr<SpdyHeaderBlock> headers(
 424       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 425   EXPECT_EQ(ERR_IO_PENDING,
 426             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 427   EXPECT_TRUE(stream->HasUrlFromHeaders());
 428   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 429
 430   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 431
 432   EXPECT_TRUE(delegate.send_headers_completed());
 433   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
 434   EXPECT_EQ("HTTP/1.1",
 435             delegate.GetResponseHeaderValue(spdy_util_.GetVersionKey()));
 436   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
 437   EXPECT_TRUE(data.at_write_eof());
 438 }
 439
 440 // Receiving a header with uppercase ASCII should result in a protocol
 441 // error.
 442 TEST_P(SpdyStreamTest, UpperCaseHeaders) {
 443   GURL url(kStreamUrl);
 444
 445   session_ =
 446       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 447
 448   scoped_ptr<SpdyFrame> syn(
 449       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 450   AddWrite(*syn);
 451
 452   const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
 453   scoped_ptr<SpdyFrame>
 454       reply(spdy_util_.ConstructSpdyGetSynReply(kExtraHeaders, 1, 1));
 455   AddRead(*reply);
 456
 457   scoped_ptr<SpdyFrame> rst(
 458       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
 459   AddWrite(*rst);
 460
 461   AddReadEOF();
 462
 463   DeterministicSocketData data(GetReads(), GetNumReads(),
 464                                GetWrites(), GetNumWrites());
 465   MockConnect connect_data(SYNCHRONOUS, OK);
 466   data.set_connect_data(connect_data);
 467
 468   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 469
 470   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 471
 472   base::WeakPtr<SpdyStream> stream =
 473       CreateStreamSynchronously(
 474           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
 475   ASSERT_TRUE(stream.get() != NULL);
 476
 477   StreamDelegateDoNothing delegate(stream);
 478   stream->SetDelegate(&delegate);
 479
 480   EXPECT_FALSE(stream->HasUrlFromHeaders());
 481
 482   scoped_ptr<SpdyHeaderBlock> headers(
 483       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
 484   EXPECT_EQ(ERR_IO_PENDING,
 485             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
 486   EXPECT_TRUE(stream->HasUrlFromHeaders());
 487   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 488
 489   data.RunFor(4);
 490
 491   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, delegate.WaitForClose());
 492 }
 493
 494 // Receiving a header with uppercase ASCII should result in a protocol
 495 // error even for a push stream.
 496 TEST_P(SpdyStreamTest, UpperCaseHeadersOnPush) {
 497   GURL url(kStreamUrl);
 498
 499   session_ =
 500       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 501
 502   scoped_ptr<SpdyFrame> syn(
 503       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 504   AddWrite(*syn);
 505
 506   scoped_ptr<SpdyFrame>
 507       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 508   AddRead(*reply);
 509
 510   const char* const extra_headers[] = {"X-UpperCase", "yes"};
 511   scoped_ptr<SpdyFrame>
 512       push(spdy_util_.ConstructSpdyPush(extra_headers, 1, 2, 1, kStreamUrl));
 513   AddRead(*push);
 514
 515   scoped_ptr<SpdyFrame> rst(
 516       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
 517   AddWrite(*rst);
 518
 519   AddReadEOF();
 520
 521   DeterministicSocketData data(GetReads(), GetNumReads(),
 522                                GetWrites(), GetNumWrites());
 523   MockConnect connect_data(SYNCHRONOUS, OK);
 524   data.set_connect_data(connect_data);
 525
 526   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 527
 528   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 529
 530   base::WeakPtr<SpdyStream> stream =
 531       CreateStreamSynchronously(
 532           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
 533   ASSERT_TRUE(stream.get() != NULL);
 534
 535   StreamDelegateDoNothing delegate(stream);
 536   stream->SetDelegate(&delegate);
 537
 538   EXPECT_FALSE(stream->HasUrlFromHeaders());
 539
 540   scoped_ptr<SpdyHeaderBlock> headers(
 541       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
 542   EXPECT_EQ(ERR_IO_PENDING,
 543             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
 544   EXPECT_TRUE(stream->HasUrlFromHeaders());
 545   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 546
 547   data.RunFor(4);
 548
 549   base::WeakPtr<SpdyStream> push_stream;
 550   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
 551   EXPECT_FALSE(push_stream);
 552
 553   data.RunFor(1);
 554
 555   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 556 }
 557
 558 // Receiving a header with uppercase ASCII in a HEADERS frame should
 559 // result in a protocol error.
 560 TEST_P(SpdyStreamTest, UpperCaseHeadersInHeadersFrame) {
 561   GURL url(kStreamUrl);
 562
 563   session_ =
 564       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 565
 566   scoped_ptr<SpdyFrame> syn(
 567       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 568   AddWrite(*syn);
 569
 570   scoped_ptr<SpdyFrame>
 571       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 572   AddRead(*reply);
 573
 574   scoped_ptr<SpdyFrame>
 575       push(spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
 576   AddRead(*push);
 577
 578   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
 579   (*late_headers)["X-UpperCase"] = "yes";
 580   scoped_ptr<SpdyFrame> headers_frame(
 581       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
 582                                            false,
 583                                            2,
 584                                            LOWEST,
 585                                            HEADERS,
 586                                            CONTROL_FLAG_NONE,
 587                                            0));
 588   AddRead(*headers_frame);
 589
 590   scoped_ptr<SpdyFrame> rst(
 591       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
 592   AddWrite(*rst);
 593
 594   AddReadEOF();
 595
 596   DeterministicSocketData data(GetReads(), GetNumReads(),
 597                                GetWrites(), GetNumWrites());
 598   MockConnect connect_data(SYNCHRONOUS, OK);
 599   data.set_connect_data(connect_data);
 600
 601   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 602
 603   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 604
 605   base::WeakPtr<SpdyStream> stream =
 606       CreateStreamSynchronously(
 607           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
 608   ASSERT_TRUE(stream.get() != NULL);
 609
 610   StreamDelegateDoNothing delegate(stream);
 611   stream->SetDelegate(&delegate);
 612
 613   EXPECT_FALSE(stream->HasUrlFromHeaders());
 614
 615   scoped_ptr<SpdyHeaderBlock> headers(
 616       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
 617   EXPECT_EQ(ERR_IO_PENDING,
 618             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
 619   EXPECT_TRUE(stream->HasUrlFromHeaders());
 620   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 621
 622   data.RunFor(3);
 623
 624   base::WeakPtr<SpdyStream> push_stream;
 625   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
 626   EXPECT_TRUE(push_stream);
 627
 628   data.RunFor(1);
 629
 630   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
 631   EXPECT_FALSE(push_stream);
 632
 633   data.RunFor(2);
 634
 635   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 636 }
 637
 638 // Receiving a duplicate header in a HEADERS frame should result in a
 639 // protocol error.
 640 TEST_P(SpdyStreamTest, DuplicateHeaders) {
 641   GURL url(kStreamUrl);
 642
 643   session_ =
 644       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 645
 646   scoped_ptr<SpdyFrame> syn(
 647       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 648   AddWrite(*syn);
 649
 650   scoped_ptr<SpdyFrame>
 651       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 652   AddRead(*reply);
 653
 654   scoped_ptr<SpdyFrame>
 655       push(spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
 656   AddRead(*push);
 657
 658   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
 659   (*late_headers)[spdy_util_.GetStatusKey()] = "500 Server Error";
 660   scoped_ptr<SpdyFrame> headers_frame(
 661       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
 662                                            false,
 663                                            2,
 664                                            LOWEST,
 665                                            HEADERS,
 666                                            CONTROL_FLAG_NONE,
 667                                            0));
 668   AddRead(*headers_frame);
 669
 670   scoped_ptr<SpdyFrame> rst(
 671       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
 672   AddWrite(*rst);
 673
 674   AddReadEOF();
 675
 676   DeterministicSocketData data(GetReads(), GetNumReads(),
 677                                GetWrites(), GetNumWrites());
 678   MockConnect connect_data(SYNCHRONOUS, OK);
 679   data.set_connect_data(connect_data);
 680
 681   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 682
 683   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 684
 685   base::WeakPtr<SpdyStream> stream =
 686       CreateStreamSynchronously(
 687           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
 688   ASSERT_TRUE(stream.get() != NULL);
 689
 690   StreamDelegateDoNothing delegate(stream);
 691   stream->SetDelegate(&delegate);
 692
 693   EXPECT_FALSE(stream->HasUrlFromHeaders());
 694
 695   scoped_ptr<SpdyHeaderBlock> headers(
 696       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
 697   EXPECT_EQ(ERR_IO_PENDING,
 698             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
 699   EXPECT_TRUE(stream->HasUrlFromHeaders());
 700   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 701
 702   data.RunFor(3);
 703
 704   base::WeakPtr<SpdyStream> push_stream;
 705   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
 706   EXPECT_TRUE(push_stream);
 707
 708   data.RunFor(1);
 709
 710   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
 711   EXPECT_FALSE(push_stream);
 712
 713   data.RunFor(2);
 714
 715   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 716 }
 717
 718 // The tests below are only for SPDY/3 and above.
 719
 720 // Call IncreaseSendWindowSize on a stream with a large enough delta
 721 // to overflow an int32. The SpdyStream should handle that case
 722 // gracefully.
 723 TEST_P(SpdyStreamTest, IncreaseSendWindowSizeOverflow) {
 724   if (spdy_util_.protocol() < kProtoSPDY3)
 725     return;
 726
 727   session_ =
 728       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 729
 730   scoped_ptr<SpdyFrame> req(
 731       spdy_util_.ConstructSpdyPost(
 732           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 733   AddWrite(*req);
 734
 735   // Triggered by the overflowing call to IncreaseSendWindowSize
 736   // below.
 737   scoped_ptr<SpdyFrame> rst(
 738       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
 739   AddWrite(*rst);
 740
 741   AddReadEOF();
 742
 743   CapturingBoundNetLog log;
 744
 745   DeterministicSocketData data(GetReads(), GetNumReads(),
 746                                GetWrites(), GetNumWrites());
 747   MockConnect connect_data(SYNCHRONOUS, OK);
 748   data.set_connect_data(connect_data);
 749
 750   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 751
 752   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 753   GURL url(kStreamUrl);
 754
 755   base::WeakPtr<SpdyStream> stream =
 756       CreateStreamSynchronously(
 757           SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, log.bound());
 758   ASSERT_TRUE(stream.get() != NULL);
 759   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
 760   stream->SetDelegate(&delegate);
 761
 762   scoped_ptr<SpdyHeaderBlock> headers(
 763       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 764   EXPECT_EQ(ERR_IO_PENDING,
 765             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 766   EXPECT_TRUE(stream->HasUrlFromHeaders());
 767   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 768
 769   data.RunFor(1);
 770
 771   int32 old_send_window_size = stream->send_window_size();
 772   ASSERT_GT(old_send_window_size, 0);
 773   int32 delta_window_size = kint32max - old_send_window_size + 1;
 774   stream->IncreaseSendWindowSize(delta_window_size);
 775   EXPECT_EQ(NULL, stream.get());
 776
 777   data.RunFor(2);
 778
 779   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, delegate.WaitForClose());
 780 }
 781
 782 // Functions used with
 783 // RunResumeAfterUnstall{RequestResponse,Bidirectional}Test().
 784
 785 void StallStream(const base::WeakPtr<SpdyStream>& stream) {
 786   // Reduce the send window size to 0 to stall.
 787   while (stream->send_window_size() > 0) {
 788     stream->DecreaseSendWindowSize(
 789         std::min(kMaxSpdyFrameChunkSize, stream->send_window_size()));
 790   }
 791 }
 792
 793 void IncreaseStreamSendWindowSize(const base::WeakPtr<SpdyStream>& stream,
 794                                   int32 delta_window_size) {
 795   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 796   stream->IncreaseSendWindowSize(delta_window_size);
 797   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 798 }
 799
 800 void AdjustStreamSendWindowSize(const base::WeakPtr<SpdyStream>& stream,
 801                                 int32 delta_window_size) {
 802   // Make sure that negative adjustments are handled properly.
 803   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 804   stream->AdjustSendWindowSize(-delta_window_size);
 805   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 806   stream->AdjustSendWindowSize(+delta_window_size);
 807   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 808   stream->AdjustSendWindowSize(+delta_window_size);
 809   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 810 }
 811
 812 // Given an unstall function, runs a test to make sure that a
 813 // request/response (i.e., an HTTP-like) stream resumes after a stall
 814 // and unstall.
 815 void SpdyStreamTest::RunResumeAfterUnstallRequestResponseTest(
 816     const UnstallFunction& unstall_function) {
 817   GURL url(kStreamUrl);
 818
 819   session_ =
 820       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 821
 822   scoped_ptr<SpdyFrame> req(
 823       spdy_util_.ConstructSpdyPost(
 824           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 825   AddWrite(*req);
 826
 827   scoped_ptr<SpdyFrame> body(
 828       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, true));
 829   AddWrite(*body);
 830
 831   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 832   AddRead(*resp);
 833
 834   AddReadEOF();
 835
 836   DeterministicSocketData data(GetReads(), GetNumReads(),
 837                                GetWrites(), GetNumWrites());
 838   MockConnect connect_data(SYNCHRONOUS, OK);
 839   data.set_connect_data(connect_data);
 840
 841   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 842
 843   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 844
 845   base::WeakPtr<SpdyStream> stream =
 846       CreateStreamSynchronously(
 847           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
 848   ASSERT_TRUE(stream.get() != NULL);
 849
 850   StreamDelegateWithBody delegate(stream, kPostBodyStringPiece);
 851   stream->SetDelegate(&delegate);
 852
 853   EXPECT_FALSE(stream->HasUrlFromHeaders());
 854   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 855
 856   scoped_ptr<SpdyHeaderBlock> headers(
 857       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 858   EXPECT_EQ(ERR_IO_PENDING,
 859             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 860   EXPECT_TRUE(stream->HasUrlFromHeaders());
 861   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 862
 863   StallStream(stream);
 864
 865   data.RunFor(1);
 866
 867   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 868
 869   unstall_function.Run(stream, kPostBodyLength);
 870
 871   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 872
 873   data.RunFor(3);
 874
 875   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 876
 877   EXPECT_TRUE(delegate.send_headers_completed());
 878   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
 879   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
 880   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
 881   EXPECT_TRUE(data.at_write_eof());
 882 }
 883
 884 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseRequestResponse) {
 885   if (spdy_util_.protocol() < kProtoSPDY3)
 886     return;
 887
 888   RunResumeAfterUnstallRequestResponseTest(
 889       base::Bind(&IncreaseStreamSendWindowSize));
 890 }
 891
 892 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustRequestResponse) {
 893   if (spdy_util_.protocol() < kProtoSPDY3)
 894     return;
 895
 896   RunResumeAfterUnstallRequestResponseTest(
 897       base::Bind(&AdjustStreamSendWindowSize));
 898 }
 899
 900 // Given an unstall function, runs a test to make sure that a
 901 // bidirectional (i.e., non-HTTP-like) stream resumes after a stall
 902 // and unstall.
 903 void SpdyStreamTest::RunResumeAfterUnstallBidirectionalTest(
 904     const UnstallFunction& unstall_function) {
 905   GURL url(kStreamUrl);
 906
 907   session_ =
 908       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 909
 910   scoped_ptr<SpdyFrame> req(
 911       spdy_util_.ConstructSpdyPost(
 912           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
 913   AddWrite(*req);
 914
 915   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 916   AddRead(*resp);
 917
 918   scoped_ptr<SpdyFrame> msg(
 919       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
 920   AddWrite(*msg);
 921
 922   scoped_ptr<SpdyFrame> echo(
 923       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
 924   AddRead(*echo);
 925
 926   AddReadEOF();
 927
 928   DeterministicSocketData data(GetReads(), GetNumReads(),
 929                                GetWrites(), GetNumWrites());
 930   MockConnect connect_data(SYNCHRONOUS, OK);
 931   data.set_connect_data(connect_data);
 932
 933   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 934
 935   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
 936
 937   base::WeakPtr<SpdyStream> stream =
 938       CreateStreamSynchronously(
 939           SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog());
 940   ASSERT_TRUE(stream.get() != NULL);
 941
 942   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
 943   stream->SetDelegate(&delegate);
 944
 945   EXPECT_FALSE(stream->HasUrlFromHeaders());
 946
 947   scoped_ptr<SpdyHeaderBlock> headers(
 948       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
 949   EXPECT_EQ(ERR_IO_PENDING,
 950             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
 951   EXPECT_TRUE(stream->HasUrlFromHeaders());
 952   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 953
 954   data.RunFor(1);
 955
 956   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 957
 958   StallStream(stream);
 959
 960   data.RunFor(1);
 961
 962   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 963
 964   unstall_function.Run(stream, kPostBodyLength);
 965
 966   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 967
 968   data.RunFor(3);
 969
 970   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 971
 972   EXPECT_TRUE(delegate.send_headers_completed());
 973   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
 974   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
 975   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
 976             delegate.TakeReceivedData());
 977   EXPECT_TRUE(data.at_write_eof());
 978 }
 979
 980 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseBidirectional) {
 981   if (spdy_util_.protocol() < kProtoSPDY3)
 982     return;
 983
 984   RunResumeAfterUnstallBidirectionalTest(
 985       base::Bind(&IncreaseStreamSendWindowSize));
 986 }
 987
 988 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustBidirectional) {
 989   if (spdy_util_.protocol() < kProtoSPDY3)
 990     return;
 991
 992   RunResumeAfterUnstallBidirectionalTest(
 993       base::Bind(&AdjustStreamSendWindowSize));
 994 }
 995
 996 // Test calculation of amount of bytes received from network.
 997 TEST_P(SpdyStreamTest, ReceivedBytes) {
 998   GURL url(kStreamUrl);
 999
1000   session_ =
1001       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
1002
1003   scoped_ptr<SpdyFrame> syn(
1004       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
1005   AddWrite(*syn);
1006
1007   scoped_ptr<SpdyFrame>
1008       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1009   AddRead(*reply);
1010
1011   scoped_ptr<SpdyFrame> msg(
1012       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
1013   AddRead(*msg);
1014
1015   AddReadEOF();
1016
1017   DeterministicSocketData data(GetReads(), GetNumReads(),
1018                                GetWrites(), GetNumWrites());
1019   MockConnect connect_data(SYNCHRONOUS, OK);
1020   data.set_connect_data(connect_data);
1021
1022   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
1023
1024   base::WeakPtr<SpdySession> session(CreateDefaultSpdySession());
1025
1026   base::WeakPtr<SpdyStream> stream =
1027       CreateStreamSynchronously(
1028           SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
1029   ASSERT_TRUE(stream.get() != NULL);
1030
1031   StreamDelegateDoNothing delegate(stream);
1032   stream->SetDelegate(&delegate);
1033
1034   EXPECT_FALSE(stream->HasUrlFromHeaders());
1035
1036   scoped_ptr<SpdyHeaderBlock> headers(
1037       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
1038   EXPECT_EQ(ERR_IO_PENDING,
1039             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
1040   EXPECT_TRUE(stream->HasUrlFromHeaders());
1041   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
1042
1043   int64 reply_frame_len = reply->size();
1044   int64 data_header_len = spdy_util_.CreateFramer()->GetDataFrameMinimumSize();
1045   int64 data_frame_len = data_header_len + kPostBodyLength;
1046   int64 response_len = reply_frame_len + data_frame_len;
1047
1048   EXPECT_EQ(0, stream->raw_received_bytes());
1049   data.RunFor(1); // SYN
1050   EXPECT_EQ(0, stream->raw_received_bytes());
1051   data.RunFor(1); // REPLY
1052   EXPECT_EQ(reply_frame_len, stream->raw_received_bytes());
1053   data.RunFor(1); // DATA
1054   EXPECT_EQ(response_len, stream->raw_received_bytes());
1055   data.RunFor(1); // FIN
1056
1057   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
1058 }
1059
1060 }  // namespace
1061
1062 }  // namespace test
1063
1064 }  // namespace net