Home | History | Annotate | Download | only in spdy 
      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_session.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/run_loop.h"
     11 #include "net/base/io_buffer.h"
     12 #include "net/base/ip_endpoint.h"
     13 #include "net/base/net_log_unittest.h"
     14 #include "net/base/request_priority.h"
     15 #include "net/base/test_data_directory.h"
     16 #include "net/base/test_data_stream.h"
     17 #include "net/socket/client_socket_pool_manager.h"
     18 #include "net/socket/next_proto.h"
     19 #include "net/socket/socket_test_util.h"
     20 #include "net/spdy/spdy_http_utils.h"
     21 #include "net/spdy/spdy_session_pool.h"
     22 #include "net/spdy/spdy_session_test_util.h"
     23 #include "net/spdy/spdy_stream.h"
     24 #include "net/spdy/spdy_stream_test_util.h"
     25 #include "net/spdy/spdy_test_util_common.h"
     26 #include "net/spdy/spdy_test_utils.h"
     27 #include "net/test/cert_test_util.h"
     28 #include "testing/platform_test.h"
     29 
     30 namespace net {
     31 
     32 namespace {
     33 
     34 static const char kTestUrl[] = "http://www.example.org/";
     35 static const char kTestHost[] = "www.example.org";
     36 static const int kTestPort = 80;
     37 
     38 const char kBodyData[] = "Body data";
     39 const size_t kBodyDataSize = arraysize(kBodyData);
     40 const base::StringPiece kBodyDataStringPiece(kBodyData, kBodyDataSize);
     41 
     42 static base::TimeDelta g_time_delta;
     43 base::TimeTicks TheNearFuture() {
     44   return base::TimeTicks::Now() + g_time_delta;
     45 }
     46 
     47 }  // namespace
     48 
     49 class SpdySessionTest : public PlatformTest,
     50                         public ::testing::WithParamInterface<NextProto> {
     51  public:
     52   // Functions used with RunResumeAfterUnstallTest().
     53 
     54   void StallSessionOnly(SpdySession* session, SpdyStream* stream) {
     55     StallSessionSend(session);
     56   }
     57 
     58   void StallStreamOnly(SpdySession* session, SpdyStream* stream) {
     59     StallStreamSend(stream);
     60   }
     61 
     62   void StallSessionStream(SpdySession* session, SpdyStream* stream) {
     63     StallSessionSend(session);
     64     StallStreamSend(stream);
     65   }
     66 
     67   void StallStreamSession(SpdySession* session, SpdyStream* stream) {
     68     StallStreamSend(stream);
     69     StallSessionSend(session);
     70   }
     71 
     72   void UnstallSessionOnly(SpdySession* session,
     73                           SpdyStream* stream,
     74                           int32 delta_window_size) {
     75     UnstallSessionSend(session, delta_window_size);
     76   }
     77 
     78   void UnstallStreamOnly(SpdySession* session,
     79                          SpdyStream* stream,
     80                          int32 delta_window_size) {
     81     UnstallStreamSend(stream, delta_window_size);
     82   }
     83 
     84   void UnstallSessionStream(SpdySession* session,
     85                             SpdyStream* stream,
     86                             int32 delta_window_size) {
     87     UnstallSessionSend(session, delta_window_size);
     88     UnstallStreamSend(stream, delta_window_size);
     89   }
     90 
     91   void UnstallStreamSession(SpdySession* session,
     92                             SpdyStream* stream,
     93                             int32 delta_window_size) {
     94     UnstallStreamSend(stream, delta_window_size);
     95     UnstallSessionSend(session, delta_window_size);
     96   }
     97 
     98  protected:
     99   SpdySessionTest()
    100       : old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group(
    101             HttpNetworkSession::NORMAL_SOCKET_POOL)),
    102         old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool(
    103             HttpNetworkSession::NORMAL_SOCKET_POOL)),
    104         spdy_util_(GetParam()),
    105         session_deps_(GetParam()),
    106         spdy_session_pool_(NULL),
    107         test_url_(kTestUrl),
    108         test_host_port_pair_(kTestHost, kTestPort),
    109         key_(test_host_port_pair_, ProxyServer::Direct(),
    110              kPrivacyModeDisabled) {
    111   }
    112 
    113   virtual ~SpdySessionTest() {
    114     // Important to restore the per-pool limit first, since the pool limit must
    115     // always be greater than group limit, and the tests reduce both limits.
    116     ClientSocketPoolManager::set_max_sockets_per_pool(
    117         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_);
    118     ClientSocketPoolManager::set_max_sockets_per_group(
    119         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_);
    120   }
    121 
    122   virtual void SetUp() OVERRIDE {
    123     g_time_delta = base::TimeDelta();
    124   }
    125 
    126   void CreateDeterministicNetworkSession() {
    127     http_session_ =
    128         SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
    129     spdy_session_pool_ = http_session_->spdy_session_pool();
    130   }
    131 
    132   void CreateNetworkSession() {
    133     http_session_ =
    134         SpdySessionDependencies::SpdyCreateSession(&session_deps_);
    135     spdy_session_pool_ = http_session_->spdy_session_pool();
    136   }
    137 
    138   void StallSessionSend(SpdySession* session) {
    139     // Reduce the send window size to 0 to stall.
    140     while (session->session_send_window_size_ > 0) {
    141       session->DecreaseSendWindowSize(
    142           std::min(kMaxSpdyFrameChunkSize, session->session_send_window_size_));
    143     }
    144   }
    145 
    146   void UnstallSessionSend(SpdySession* session, int32 delta_window_size) {
    147     session->IncreaseSendWindowSize(delta_window_size);
    148   }
    149 
    150   void StallStreamSend(SpdyStream* stream) {
    151     // Reduce the send window size to 0 to stall.
    152     while (stream->send_window_size() > 0) {
    153       stream->DecreaseSendWindowSize(
    154           std::min(kMaxSpdyFrameChunkSize, stream->send_window_size()));
    155     }
    156   }
    157 
    158   void UnstallStreamSend(SpdyStream* stream, int32 delta_window_size) {
    159     stream->IncreaseSendWindowSize(delta_window_size);
    160   }
    161 
    162   void RunResumeAfterUnstallTest(
    163       const base::Callback<void(SpdySession*, SpdyStream*)>& stall_function,
    164       const base::Callback<void(SpdySession*, SpdyStream*, int32)>&
    165           unstall_function);
    166 
    167   // Original socket limits.  Some tests set these.  Safest to always restore
    168   // them once each test has been run.
    169   int old_max_group_sockets_;
    170   int old_max_pool_sockets_;
    171 
    172   SpdyTestUtil spdy_util_;
    173   SpdySessionDependencies session_deps_;
    174   scoped_refptr<HttpNetworkSession> http_session_;
    175   SpdySessionPool* spdy_session_pool_;
    176   GURL test_url_;
    177   HostPortPair test_host_port_pair_;
    178   SpdySessionKey key_;
    179 };
    180 
    181 INSTANTIATE_TEST_CASE_P(
    182     NextProto,
    183     SpdySessionTest,
    184     testing::Values(kProtoDeprecatedSPDY2,
    185                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2,
    186                     kProtoHTTP2Draft04));
    187 
    188 // Try to create a SPDY session that will fail during
    189 // initialization. Nothing should blow up.
    190 TEST_P(SpdySessionTest, InitialReadError) {
    191   CreateDeterministicNetworkSession();
    192 
    193   TryCreateFakeSpdySessionExpectingFailure(
    194       spdy_session_pool_, key_, ERR_FAILED);
    195 }
    196 
    197 namespace {
    198 
    199 // A helper class that vends a callback that, when fired, destroys a
    200 // given SpdyStreamRequest.
    201 class StreamRequestDestroyingCallback : public TestCompletionCallbackBase {
    202  public:
    203   StreamRequestDestroyingCallback() {}
    204 
    205   virtual ~StreamRequestDestroyingCallback() {}
    206 
    207   void SetRequestToDestroy(scoped_ptr<SpdyStreamRequest> request) {
    208     request_ = request.Pass();
    209   }
    210 
    211   CompletionCallback MakeCallback() {
    212     return base::Bind(&StreamRequestDestroyingCallback::OnComplete,
    213                       base::Unretained(this));
    214   }
    215 
    216  private:
    217   void OnComplete(int result) {
    218     request_.reset();
    219     SetResult(result);
    220   }
    221 
    222   scoped_ptr<SpdyStreamRequest> request_;
    223 };
    224 
    225 }  // namespace
    226 
    227 // Request kInitialMaxConcurrentStreams streams.  Request two more
    228 // streams, but have the callback for one destroy the second stream
    229 // request. Close the session. Nothing should blow up. This is a
    230 // regression test for http://crbug.com/250841 .
    231 TEST_P(SpdySessionTest, PendingStreamCancellingAnother) {
    232   session_deps_.host_resolver->set_synchronous_mode(true);
    233 
    234   MockRead reads[] = {MockRead(ASYNC, 0, 0), };
    235 
    236   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
    237   MockConnect connect_data(SYNCHRONOUS, OK);
    238   data.set_connect_data(connect_data);
    239   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    240 
    241   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    242   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    243 
    244   CreateDeterministicNetworkSession();
    245 
    246   base::WeakPtr<SpdySession> session =
    247       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    248 
    249   // Create the maximum number of concurrent streams.
    250   for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) {
    251     base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
    252         SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
    253     ASSERT_TRUE(spdy_stream != NULL);
    254   }
    255 
    256   SpdyStreamRequest request1;
    257   scoped_ptr<SpdyStreamRequest> request2(new SpdyStreamRequest);
    258 
    259   StreamRequestDestroyingCallback callback1;
    260   ASSERT_EQ(ERR_IO_PENDING,
    261             request1.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
    262                                   session,
    263                                   test_url_,
    264                                   MEDIUM,
    265                                   BoundNetLog(),
    266                                   callback1.MakeCallback()));
    267 
    268   // |callback2| is never called.
    269   TestCompletionCallback callback2;
    270   ASSERT_EQ(ERR_IO_PENDING,
    271             request2->StartRequest(SPDY_BIDIRECTIONAL_STREAM,
    272                                    session,
    273                                    test_url_,
    274                                    MEDIUM,
    275                                    BoundNetLog(),
    276                                    callback2.callback()));
    277 
    278   callback1.SetRequestToDestroy(request2.Pass());
    279 
    280   session->CloseSessionOnError(ERR_ABORTED, "Aborting session");
    281 
    282   EXPECT_EQ(ERR_ABORTED, callback1.WaitForResult());
    283 
    284   data.RunFor(1);
    285 }
    286 
    287 // A session receiving a GOAWAY frame with no active streams should
    288 // immediately close.
    289 TEST_P(SpdySessionTest, GoAwayWithNoActiveStreams) {
    290   session_deps_.host_resolver->set_synchronous_mode(true);
    291 
    292   MockConnect connect_data(SYNCHRONOUS, OK);
    293   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
    294   MockRead reads[] = {
    295     CreateMockRead(*goaway, 0),
    296   };
    297   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
    298   data.set_connect_data(connect_data);
    299   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    300 
    301   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    302   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    303 
    304   CreateDeterministicNetworkSession();
    305 
    306   base::WeakPtr<SpdySession> session =
    307       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    308 
    309   EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
    310 
    311   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    312 
    313   // Read and process the GOAWAY frame.
    314   data.RunFor(1);
    315 
    316   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    317 
    318   EXPECT_TRUE(session == NULL);
    319 }
    320 
    321 // A session receiving a GOAWAY frame immediately with no active
    322 // streams should then close.
    323 TEST_P(SpdySessionTest, GoAwayImmediatelyWithNoActiveStreams) {
    324   session_deps_.host_resolver->set_synchronous_mode(true);
    325 
    326   MockConnect connect_data(SYNCHRONOUS, OK);
    327   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
    328   MockRead reads[] = {
    329     CreateMockRead(*goaway, 0, SYNCHRONOUS),
    330   };
    331   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
    332   data.set_connect_data(connect_data);
    333   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    334 
    335   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    336   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    337 
    338   CreateDeterministicNetworkSession();
    339 
    340   data.StopAfter(1);
    341 
    342   TryCreateInsecureSpdySessionExpectingFailure(
    343       http_session_, key_, ERR_CONNECTION_CLOSED, BoundNetLog());
    344 
    345   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    346 }
    347 
    348 // A session receiving a GOAWAY frame with active streams should close
    349 // when the last active stream is closed.
    350 TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
    351   session_deps_.host_resolver->set_synchronous_mode(true);
    352 
    353   MockConnect connect_data(SYNCHRONOUS, OK);
    354   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
    355   MockRead reads[] = {
    356     CreateMockRead(*goaway, 2),
    357     MockRead(ASYNC, 0, 3)  // EOF
    358   };
    359   scoped_ptr<SpdyFrame> req1(
    360       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
    361   scoped_ptr<SpdyFrame> req2(
    362       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
    363   MockWrite writes[] = {
    364     CreateMockWrite(*req1, 0),
    365     CreateMockWrite(*req2, 1),
    366   };
    367   DeterministicSocketData data(reads, arraysize(reads),
    368                                writes, arraysize(writes));
    369   data.set_connect_data(connect_data);
    370   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    371 
    372   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    373   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    374 
    375   CreateDeterministicNetworkSession();
    376 
    377   base::WeakPtr<SpdySession> session =
    378       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    379 
    380   EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
    381 
    382   GURL url("http://www.google.com");
    383   base::WeakPtr<SpdyStream> spdy_stream1 =
    384       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    385                                 session, url, MEDIUM, BoundNetLog());
    386   test::StreamDelegateDoNothing delegate1(spdy_stream1);
    387   spdy_stream1->SetDelegate(&delegate1);
    388 
    389   base::WeakPtr<SpdyStream> spdy_stream2 =
    390       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    391                                 session, url, MEDIUM, BoundNetLog());
    392   test::StreamDelegateDoNothing delegate2(spdy_stream2);
    393   spdy_stream2->SetDelegate(&delegate2);
    394 
    395   scoped_ptr<SpdyHeaderBlock> headers(
    396       spdy_util_.ConstructGetHeaderBlock(url.spec()));
    397   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock(*headers));
    398 
    399   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
    400   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
    401   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
    402   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
    403 
    404   data.RunFor(2);
    405 
    406   EXPECT_EQ(1u, spdy_stream1->stream_id());
    407   EXPECT_EQ(3u, spdy_stream2->stream_id());
    408 
    409   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    410 
    411   // Read and process the GOAWAY frame.
    412   data.RunFor(1);
    413 
    414   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    415 
    416   EXPECT_FALSE(session->IsStreamActive(3));
    417   EXPECT_EQ(NULL, spdy_stream2.get());
    418   EXPECT_TRUE(session->IsStreamActive(1));
    419 
    420   EXPECT_FALSE(session->IsClosed());
    421 
    422   // Should close the session.
    423   spdy_stream1->Close();
    424   EXPECT_EQ(NULL, spdy_stream1.get());
    425 
    426   EXPECT_TRUE(session == NULL);
    427 }
    428 
    429 // Have a session receive two GOAWAY frames, with the last one causing
    430 // the last active stream to be closed. The session should then be
    431 // closed after the second GOAWAY frame.
    432 TEST_P(SpdySessionTest, GoAwayTwice) {
    433   session_deps_.host_resolver->set_synchronous_mode(true);
    434 
    435   MockConnect connect_data(SYNCHRONOUS, OK);
    436   scoped_ptr<SpdyFrame> goaway1(spdy_util_.ConstructSpdyGoAway(1));
    437   scoped_ptr<SpdyFrame> goaway2(spdy_util_.ConstructSpdyGoAway(0));
    438   MockRead reads[] = {
    439     CreateMockRead(*goaway1, 2),
    440     CreateMockRead(*goaway2, 3),
    441     MockRead(ASYNC, 0, 4)  // EOF
    442   };
    443   scoped_ptr<SpdyFrame> req1(
    444       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
    445   scoped_ptr<SpdyFrame> req2(
    446       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
    447   MockWrite writes[] = {
    448     CreateMockWrite(*req1, 0),
    449     CreateMockWrite(*req2, 1),
    450   };
    451   DeterministicSocketData data(reads, arraysize(reads),
    452                                writes, arraysize(writes));
    453   data.set_connect_data(connect_data);
    454   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    455 
    456   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    457   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    458 
    459   CreateDeterministicNetworkSession();
    460 
    461   base::WeakPtr<SpdySession> session =
    462       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    463 
    464   EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
    465 
    466   GURL url("http://www.google.com");
    467   base::WeakPtr<SpdyStream> spdy_stream1 =
    468       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    469                                 session, url, MEDIUM, BoundNetLog());
    470   test::StreamDelegateDoNothing delegate1(spdy_stream1);
    471   spdy_stream1->SetDelegate(&delegate1);
    472 
    473   base::WeakPtr<SpdyStream> spdy_stream2 =
    474       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    475                                 session, url, MEDIUM, BoundNetLog());
    476   test::StreamDelegateDoNothing delegate2(spdy_stream2);
    477   spdy_stream2->SetDelegate(&delegate2);
    478 
    479   scoped_ptr<SpdyHeaderBlock> headers(
    480       spdy_util_.ConstructGetHeaderBlock(url.spec()));
    481   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock(*headers));
    482 
    483   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
    484   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
    485   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
    486   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
    487 
    488   data.RunFor(2);
    489 
    490   EXPECT_EQ(1u, spdy_stream1->stream_id());
    491   EXPECT_EQ(3u, spdy_stream2->stream_id());
    492 
    493   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    494 
    495   // Read and process the first GOAWAY frame.
    496   data.RunFor(1);
    497 
    498   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    499 
    500   EXPECT_FALSE(session->IsStreamActive(3));
    501   EXPECT_EQ(NULL, spdy_stream2.get());
    502   EXPECT_TRUE(session->IsStreamActive(1));
    503 
    504   EXPECT_FALSE(session->IsClosed());
    505 
    506   // Read and process the second GOAWAY frame, which should close the
    507   // session.
    508   data.RunFor(1);
    509 
    510   EXPECT_TRUE(session == NULL);
    511 }
    512 
    513 // Have a session with active streams receive a GOAWAY frame and then
    514 // close it. It should handle the close properly (i.e., not try to
    515 // make itself unavailable in its pool twice).
    516 TEST_P(SpdySessionTest, GoAwayWithActiveStreamsThenClose) {
    517   session_deps_.host_resolver->set_synchronous_mode(true);
    518 
    519   MockConnect connect_data(SYNCHRONOUS, OK);
    520   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
    521   MockRead reads[] = {
    522     CreateMockRead(*goaway, 2),
    523     MockRead(ASYNC, 0, 3)  // EOF
    524   };
    525   scoped_ptr<SpdyFrame> req1(
    526       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
    527   scoped_ptr<SpdyFrame> req2(
    528       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
    529   MockWrite writes[] = {
    530     CreateMockWrite(*req1, 0),
    531     CreateMockWrite(*req2, 1),
    532   };
    533   DeterministicSocketData data(reads, arraysize(reads),
    534                                writes, arraysize(writes));
    535   data.set_connect_data(connect_data);
    536   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    537 
    538   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    539   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    540 
    541   CreateDeterministicNetworkSession();
    542 
    543   base::WeakPtr<SpdySession> session =
    544       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    545 
    546   EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
    547 
    548   GURL url("http://www.google.com");
    549   base::WeakPtr<SpdyStream> spdy_stream1 =
    550       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    551                                 session, url, MEDIUM, BoundNetLog());
    552   test::StreamDelegateDoNothing delegate1(spdy_stream1);
    553   spdy_stream1->SetDelegate(&delegate1);
    554 
    555   base::WeakPtr<SpdyStream> spdy_stream2 =
    556       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    557                                 session, url, MEDIUM, BoundNetLog());
    558   test::StreamDelegateDoNothing delegate2(spdy_stream2);
    559   spdy_stream2->SetDelegate(&delegate2);
    560 
    561   scoped_ptr<SpdyHeaderBlock> headers(
    562       spdy_util_.ConstructGetHeaderBlock(url.spec()));
    563   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock(*headers));
    564 
    565   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
    566   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
    567   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
    568   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
    569 
    570   data.RunFor(2);
    571 
    572   EXPECT_EQ(1u, spdy_stream1->stream_id());
    573   EXPECT_EQ(3u, spdy_stream2->stream_id());
    574 
    575   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    576 
    577   // Read and process the GOAWAY frame.
    578   data.RunFor(1);
    579 
    580   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    581 
    582   EXPECT_FALSE(session->IsStreamActive(3));
    583   EXPECT_EQ(NULL, spdy_stream2.get());
    584   EXPECT_TRUE(session->IsStreamActive(1));
    585 
    586   EXPECT_FALSE(session->IsClosed());
    587 
    588   session->CloseSessionOnError(ERR_ABORTED, "Aborting session");
    589 
    590   EXPECT_EQ(NULL, spdy_stream1.get());
    591   EXPECT_TRUE(session == NULL);
    592 }
    593 
    594 // Try to create a stream after receiving a GOAWAY frame. It should
    595 // fail.
    596 TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
    597   const char kStreamUrl[] = "http://www.google.com";
    598   session_deps_.host_resolver->set_synchronous_mode(true);
    599 
    600   MockConnect connect_data(SYNCHRONOUS, OK);
    601   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
    602   MockRead reads[] = {
    603     CreateMockRead(*goaway, 1),
    604     MockRead(ASYNC, 0, 2)  // EOF
    605   };
    606   scoped_ptr<SpdyFrame> req(
    607       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
    608   MockWrite writes[] = {
    609     CreateMockWrite(*req, 0),
    610   };
    611   DeterministicSocketData data(reads, arraysize(reads),
    612                                writes, arraysize(writes));
    613   data.set_connect_data(connect_data);
    614   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    615 
    616   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    617   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    618 
    619   CreateDeterministicNetworkSession();
    620 
    621   base::WeakPtr<SpdySession> session =
    622       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    623 
    624   EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
    625 
    626   GURL url(kStreamUrl);
    627   base::WeakPtr<SpdyStream> spdy_stream =
    628       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    629                                 session, url, MEDIUM, BoundNetLog());
    630   test::StreamDelegateDoNothing delegate(spdy_stream);
    631   spdy_stream->SetDelegate(&delegate);
    632 
    633   scoped_ptr<SpdyHeaderBlock> headers(
    634       spdy_util_.ConstructGetHeaderBlock(url.spec()));
    635   spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
    636   EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
    637 
    638   data.RunFor(1);
    639 
    640   EXPECT_EQ(1u, spdy_stream->stream_id());
    641 
    642   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    643 
    644   // Read and process the GOAWAY frame.
    645   data.RunFor(1);
    646 
    647   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    648   EXPECT_TRUE(session->IsStreamActive(1));
    649 
    650   SpdyStreamRequest stream_request;
    651   int rv = stream_request.StartRequest(
    652       SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog(),
    653       CompletionCallback());
    654   EXPECT_EQ(ERR_FAILED, rv);
    655 
    656   // Read and process EOF.
    657   data.RunFor(1);
    658 
    659   EXPECT_TRUE(session == NULL);
    660 }
    661 
    662 // Receiving a SYN_STREAM frame after a GOAWAY frame should result in
    663 // the stream being refused.
    664 TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
    665   const char kStreamUrl[] = "http://www.google.com";
    666   session_deps_.host_resolver->set_synchronous_mode(true);
    667 
    668   MockConnect connect_data(SYNCHRONOUS, OK);
    669   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
    670   scoped_ptr<SpdyFrame>
    671       push(spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
    672   MockRead reads[] = {
    673     CreateMockRead(*goaway, 1),
    674     CreateMockRead(*push, 2),
    675     MockRead(ASYNC, 0, 4)  // EOF
    676   };
    677   scoped_ptr<SpdyFrame> req(
    678       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
    679   scoped_ptr<SpdyFrame> rst(
    680       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
    681   MockWrite writes[] = {
    682     CreateMockWrite(*req, 0),
    683     CreateMockWrite(*rst, 3)
    684   };
    685   DeterministicSocketData data(reads, arraysize(reads),
    686                                writes, arraysize(writes));
    687   data.set_connect_data(connect_data);
    688   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    689 
    690   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    691   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    692 
    693   CreateDeterministicNetworkSession();
    694 
    695   base::WeakPtr<SpdySession> session =
    696       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    697 
    698   EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
    699 
    700   GURL url(kStreamUrl);
    701   base::WeakPtr<SpdyStream> spdy_stream =
    702       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    703                                 session, url, MEDIUM, BoundNetLog());
    704   test::StreamDelegateDoNothing delegate(spdy_stream);
    705   spdy_stream->SetDelegate(&delegate);
    706 
    707   scoped_ptr<SpdyHeaderBlock> headers(
    708       spdy_util_.ConstructGetHeaderBlock(url.spec()));
    709   spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
    710   EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
    711 
    712   data.RunFor(1);
    713 
    714   EXPECT_EQ(1u, spdy_stream->stream_id());
    715 
    716   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    717 
    718   // Read and process the GOAWAY frame.
    719   data.RunFor(1);
    720 
    721   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    722   EXPECT_TRUE(session->IsStreamActive(1));
    723 
    724   // Read and process the SYN_STREAM frame, the subsequent RST_STREAM,
    725   // and EOF.
    726   data.RunFor(3);
    727 
    728   EXPECT_TRUE(session == NULL);
    729 }
    730 
    731 TEST_P(SpdySessionTest, ClientPing) {
    732   session_deps_.enable_ping = true;
    733   session_deps_.host_resolver->set_synchronous_mode(true);
    734 
    735   MockConnect connect_data(SYNCHRONOUS, OK);
    736   scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(1));
    737   MockRead reads[] = {
    738     CreateMockRead(*read_ping, 1),
    739     MockRead(ASYNC, 0, 0, 2)  // EOF
    740   };
    741   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1));
    742   MockWrite writes[] = {
    743     CreateMockWrite(*write_ping, 0),
    744   };
    745   DeterministicSocketData data(
    746       reads, arraysize(reads), writes, arraysize(writes));
    747   data.set_connect_data(connect_data);
    748   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    749 
    750   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    751   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    752 
    753   CreateDeterministicNetworkSession();
    754 
    755   base::WeakPtr<SpdySession> session =
    756       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    757 
    758   base::WeakPtr<SpdyStream> spdy_stream1 =
    759       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
    760                                 session, test_url_, MEDIUM, BoundNetLog());
    761   ASSERT_TRUE(spdy_stream1.get() != NULL);
    762   test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
    763   spdy_stream1->SetDelegate(&delegate);
    764 
    765   base::TimeTicks before_ping_time = base::TimeTicks::Now();
    766 
    767   session->set_connection_at_risk_of_loss_time(
    768       base::TimeDelta::FromSeconds(-1));
    769   session->set_hung_interval(base::TimeDelta::FromMilliseconds(50));
    770 
    771   session->SendPrefacePingIfNoneInFlight();
    772 
    773   data.RunFor(2);
    774 
    775   session->CheckPingStatus(before_ping_time);
    776 
    777   EXPECT_EQ(0, session->pings_in_flight());
    778   EXPECT_GE(session->next_ping_id(), static_cast<uint32>(1));
    779   EXPECT_FALSE(session->check_ping_status_pending());
    780   EXPECT_GE(session->last_activity_time(), before_ping_time);
    781 
    782   data.RunFor(1);
    783 
    784   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
    785 
    786   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    787   EXPECT_TRUE(session == NULL);
    788 }
    789 
    790 TEST_P(SpdySessionTest, ServerPing) {
    791   session_deps_.host_resolver->set_synchronous_mode(true);
    792 
    793   MockConnect connect_data(SYNCHRONOUS, OK);
    794   scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(2));
    795   MockRead reads[] = {
    796     CreateMockRead(*read_ping),
    797     MockRead(SYNCHRONOUS, 0, 0)  // EOF
    798   };
    799   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(2));
    800   MockWrite writes[] = {
    801     CreateMockWrite(*write_ping),
    802   };
    803   StaticSocketDataProvider data(
    804       reads, arraysize(reads), writes, arraysize(writes));
    805   data.set_connect_data(connect_data);
    806   session_deps_.socket_factory->AddSocketDataProvider(&data);
    807 
    808   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    809   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
    810 
    811   CreateNetworkSession();
    812 
    813   base::WeakPtr<SpdySession> session =
    814       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    815 
    816   base::WeakPtr<SpdyStream> spdy_stream1 =
    817       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
    818                                 session, test_url_, MEDIUM, BoundNetLog());
    819   ASSERT_TRUE(spdy_stream1.get() != NULL);
    820   test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
    821   spdy_stream1->SetDelegate(&delegate);
    822 
    823   // Flush the read completion task.
    824   base::MessageLoop::current()->RunUntilIdle();
    825 
    826   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    827 
    828   EXPECT_TRUE(session == NULL);
    829   EXPECT_EQ(NULL, spdy_stream1.get());
    830 }
    831 
    832 // Cause a ping to be sent out while producing a write. The write loop
    833 // should handle this properly, i.e. another DoWriteLoop task should
    834 // not be posted. This is a regression test for
    835 // http://crbug.com/261043 .
    836 TEST_P(SpdySessionTest, PingAndWriteLoop) {
    837   session_deps_.enable_ping = true;
    838   session_deps_.time_func = TheNearFuture;
    839 
    840   MockConnect connect_data(SYNCHRONOUS, OK);
    841   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1));
    842   scoped_ptr<SpdyFrame> req(
    843       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
    844   MockWrite writes[] = {
    845     CreateMockWrite(*req, 0),
    846     CreateMockWrite(*write_ping, 1),
    847   };
    848 
    849   MockRead reads[] = {
    850     MockRead(ASYNC, 0, 2)  // EOF
    851   };
    852 
    853   session_deps_.host_resolver->set_synchronous_mode(true);
    854 
    855   DeterministicSocketData data(reads, arraysize(reads),
    856                                writes, arraysize(writes));
    857   data.set_connect_data(connect_data);
    858   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    859 
    860   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    861   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    862 
    863   CreateDeterministicNetworkSession();
    864 
    865   base::WeakPtr<SpdySession> session =
    866       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    867 
    868   GURL url("http://www.google.com");
    869   base::WeakPtr<SpdyStream> spdy_stream =
    870       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
    871                                 session, url, LOWEST, BoundNetLog());
    872   test::StreamDelegateDoNothing delegate(spdy_stream);
    873   spdy_stream->SetDelegate(&delegate);
    874 
    875   scoped_ptr<SpdyHeaderBlock> headers(
    876       spdy_util_.ConstructGetHeaderBlock(url.spec()));
    877   spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
    878 
    879   // Shift time so that a ping will be sent out.
    880   g_time_delta = base::TimeDelta::FromSeconds(11);
    881 
    882   data.RunFor(2);
    883 
    884   session->CloseSessionOnError(ERR_ABORTED, "Aborting");
    885 }
    886 
    887 TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
    888   session_deps_.host_resolver->set_synchronous_mode(true);
    889 
    890   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    891   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
    892   session_deps_.time_func = TheNearFuture;
    893 
    894   CreateNetworkSession();
    895 
    896   base::WeakPtr<SpdySession> session =
    897       CreateFakeSpdySession(spdy_session_pool_, key_);
    898 
    899   session->buffered_spdy_framer_.reset(
    900       new BufferedSpdyFramer(spdy_util_.spdy_version(), false));
    901 
    902   // Create the associated stream and add to active streams.
    903   scoped_ptr<SpdyHeaderBlock> request_headers(
    904       spdy_util_.ConstructGetHeaderBlock("http://www.google.com/"));
    905 
    906   scoped_ptr<SpdyStream> stream(new SpdyStream(SPDY_REQUEST_RESPONSE_STREAM,
    907                                                session,
    908                                                GURL(),
    909                                                DEFAULT_PRIORITY,
    910                                                kSpdyStreamInitialWindowSize,
    911                                                kSpdyStreamInitialWindowSize,
    912                                                session->net_log_));
    913   stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
    914   SpdyStream* stream_ptr = stream.get();
    915   session->InsertCreatedStream(stream.Pass());
    916   stream = session->ActivateCreatedStream(stream_ptr);
    917   session->InsertActivatedStream(stream.Pass());
    918 
    919   SpdyHeaderBlock headers;
    920   spdy_util_.AddUrlToHeaderBlock("http://www.google.com/a.dat", &headers);
    921 
    922   // OnSynStream() expects |in_io_loop_| to be true.
    923   session->in_io_loop_ = true;
    924   session->OnSynStream(2, 1, 0, 0, true, false, headers);
    925   session->in_io_loop_ = false;
    926 
    927   // Verify that there is one unclaimed push stream.
    928   EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
    929   SpdySession::PushedStreamMap::iterator iter =
    930       session->unclaimed_pushed_streams_.find(
    931           GURL("http://www.google.com/a.dat"));
    932   EXPECT_TRUE(session->unclaimed_pushed_streams_.end() != iter);
    933 
    934   // Shift time to expire the push stream.
    935   g_time_delta = base::TimeDelta::FromSeconds(301);
    936 
    937   spdy_util_.AddUrlToHeaderBlock("http://www.google.com/b.dat", &headers);
    938   session->in_io_loop_ = true;
    939   session->OnSynStream(4, 1, 0, 0, true, false, headers);
    940   session->in_io_loop_ = false;
    941 
    942   // Verify that the second pushed stream evicted the first pushed stream.
    943   EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
    944   iter = session->unclaimed_pushed_streams_.find(
    945       GURL("http://www.google.com/b.dat"));
    946   EXPECT_TRUE(session->unclaimed_pushed_streams_.end() != iter);
    947 }
    948 
    949 TEST_P(SpdySessionTest, FailedPing) {
    950   session_deps_.host_resolver->set_synchronous_mode(true);
    951 
    952   MockConnect connect_data(SYNCHRONOUS, OK);
    953   MockRead reads[] = {
    954     MockRead(ASYNC, 0, 0, 0)  // EOF
    955   };
    956   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1));
    957   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
    958   data.set_connect_data(connect_data);
    959   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
    960 
    961   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
    962   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
    963 
    964   CreateDeterministicNetworkSession();
    965 
    966   base::WeakPtr<SpdySession> session =
    967       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
    968 
    969   base::WeakPtr<SpdyStream> spdy_stream1 =
    970       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
    971                                 session, test_url_, MEDIUM, BoundNetLog());
    972   ASSERT_TRUE(spdy_stream1.get() != NULL);
    973   test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
    974   spdy_stream1->SetDelegate(&delegate);
    975 
    976   session->set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(0));
    977   session->set_hung_interval(base::TimeDelta::FromSeconds(0));
    978 
    979   // Send a PING frame.
    980   session->WritePingFrame(1);
    981   EXPECT_LT(0, session->pings_in_flight());
    982   EXPECT_GE(session->next_ping_id(), static_cast<uint32>(1));
    983   EXPECT_TRUE(session->check_ping_status_pending());
    984 
    985   // Assert session is not closed.
    986   EXPECT_FALSE(session->IsClosed());
    987   EXPECT_LT(0u, session->num_active_streams() + session->num_created_streams());
    988   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
    989 
    990   // We set last time we have received any data in 1 sec less than now.
    991   // CheckPingStatus will trigger timeout because hung interval is zero.
    992   base::TimeTicks now = base::TimeTicks::Now();
    993   session->last_activity_time_ = now - base::TimeDelta::FromSeconds(1);
    994   session->CheckPingStatus(now);
    995 
    996   EXPECT_TRUE(session == NULL);
    997   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
    998 
    999   data.RunFor(1);
   1000   EXPECT_EQ(NULL, spdy_stream1.get());
   1001 }
   1002 
   1003 // Request kInitialMaxConcurrentStreams + 1 streams.  Receive a
   1004 // settings frame increasing the max concurrent streams by 1.  Make
   1005 // sure nothing blows up. This is a regression test for
   1006 // http://crbug.com/57331 .
   1007 TEST_P(SpdySessionTest, OnSettings) {
   1008   session_deps_.host_resolver->set_synchronous_mode(true);
   1009 
   1010   const SpdySettingsIds kSpdySettingsIds = SETTINGS_MAX_CONCURRENT_STREAMS;
   1011 
   1012   SettingsMap new_settings;
   1013   const uint32 max_concurrent_streams = kInitialMaxConcurrentStreams + 1;
   1014   new_settings[kSpdySettingsIds] =
   1015       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   1016   scoped_ptr<SpdyFrame> settings_frame(
   1017       spdy_util_.ConstructSpdySettings(new_settings));
   1018   MockRead reads[] = {
   1019     CreateMockRead(*settings_frame, 0),
   1020     MockRead(ASYNC, 0, 1),
   1021   };
   1022 
   1023   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
   1024   MockConnect connect_data(SYNCHRONOUS, OK);
   1025   data.set_connect_data(connect_data);
   1026   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1027 
   1028   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1029   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1030 
   1031   CreateDeterministicNetworkSession();
   1032 
   1033   base::WeakPtr<SpdySession> session =
   1034       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1035 
   1036   // Create the maximum number of concurrent streams.
   1037   for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) {
   1038     base::WeakPtr<SpdyStream> spdy_stream =
   1039         CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1040                                   session, test_url_, MEDIUM, BoundNetLog());
   1041     ASSERT_TRUE(spdy_stream != NULL);
   1042   }
   1043 
   1044   StreamReleaserCallback stream_releaser;
   1045   SpdyStreamRequest request;
   1046   ASSERT_EQ(ERR_IO_PENDING,
   1047             request.StartRequest(
   1048                 SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
   1049                 BoundNetLog(),
   1050                 stream_releaser.MakeCallback(&request)));
   1051 
   1052   data.RunFor(1);
   1053 
   1054   EXPECT_EQ(OK, stream_releaser.WaitForResult());
   1055 
   1056   data.RunFor(1);
   1057   EXPECT_TRUE(session == NULL);
   1058 }
   1059 
   1060 // Start with a persisted value for max concurrent streams. Receive a
   1061 // settings frame increasing the max concurrent streams by 1 and which
   1062 // also clears the persisted data. Verify that persisted data is
   1063 // correct.
   1064 TEST_P(SpdySessionTest, ClearSettings) {
   1065   session_deps_.host_resolver->set_synchronous_mode(true);
   1066 
   1067   SettingsMap new_settings;
   1068   const uint32 max_concurrent_streams = kInitialMaxConcurrentStreams + 1;
   1069   new_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
   1070       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   1071   scoped_ptr<SpdyFrame> settings_frame(
   1072       spdy_util_.ConstructSpdySettings(new_settings));
   1073   uint8 flags = SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
   1074   test::SetFrameFlags(settings_frame.get(), flags, spdy_util_.spdy_version());
   1075   MockRead reads[] = {
   1076     CreateMockRead(*settings_frame, 0),
   1077     MockRead(ASYNC, 0, 1),
   1078   };
   1079 
   1080   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
   1081   MockConnect connect_data(SYNCHRONOUS, OK);
   1082   data.set_connect_data(connect_data);
   1083   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1084 
   1085   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1086   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1087 
   1088   CreateDeterministicNetworkSession();
   1089 
   1090   // Initialize the SpdySetting with the default.
   1091   spdy_session_pool_->http_server_properties()->SetSpdySetting(
   1092       test_host_port_pair_,
   1093       SETTINGS_MAX_CONCURRENT_STREAMS,
   1094       SETTINGS_FLAG_PLEASE_PERSIST,
   1095       kInitialMaxConcurrentStreams);
   1096 
   1097   EXPECT_FALSE(
   1098       spdy_session_pool_->http_server_properties()->GetSpdySettings(
   1099           test_host_port_pair_).empty());
   1100 
   1101   base::WeakPtr<SpdySession> session =
   1102       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1103 
   1104   // Create the maximum number of concurrent streams.
   1105   for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) {
   1106     base::WeakPtr<SpdyStream> spdy_stream =
   1107         CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1108                                   session, test_url_, MEDIUM, BoundNetLog());
   1109     ASSERT_TRUE(spdy_stream != NULL);
   1110   }
   1111 
   1112   StreamReleaserCallback stream_releaser;
   1113 
   1114   SpdyStreamRequest request;
   1115   ASSERT_EQ(ERR_IO_PENDING,
   1116             request.StartRequest(
   1117                 SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
   1118                 BoundNetLog(),
   1119                 stream_releaser.MakeCallback(&request)));
   1120 
   1121   data.RunFor(1);
   1122 
   1123   EXPECT_EQ(OK, stream_releaser.WaitForResult());
   1124 
   1125   // Make sure that persisted data is cleared.
   1126   EXPECT_TRUE(
   1127       spdy_session_pool_->http_server_properties()->GetSpdySettings(
   1128           test_host_port_pair_).empty());
   1129 
   1130   // Make sure session's max_concurrent_streams is correct.
   1131   EXPECT_EQ(kInitialMaxConcurrentStreams + 1,
   1132             session->max_concurrent_streams());
   1133 
   1134   data.RunFor(1);
   1135   EXPECT_TRUE(session == NULL);
   1136 }
   1137 
   1138 // Start with max concurrent streams set to 1.  Request two streams.
   1139 // When the first completes, have the callback close its stream, which
   1140 // should trigger the second stream creation.  Then cancel that one
   1141 // immediately.  Don't crash.  This is a regression test for
   1142 // http://crbug.com/63532 .
   1143 TEST_P(SpdySessionTest, CancelPendingCreateStream) {
   1144   session_deps_.host_resolver->set_synchronous_mode(true);
   1145 
   1146   MockRead reads[] = {
   1147     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   1148   };
   1149 
   1150   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   1151   MockConnect connect_data(SYNCHRONOUS, OK);
   1152 
   1153   data.set_connect_data(connect_data);
   1154   session_deps_.socket_factory->AddSocketDataProvider(&data);
   1155 
   1156   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1157   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   1158 
   1159   CreateNetworkSession();
   1160 
   1161   // Initialize the SpdySetting with 1 max concurrent streams.
   1162   spdy_session_pool_->http_server_properties()->SetSpdySetting(
   1163       test_host_port_pair_,
   1164       SETTINGS_MAX_CONCURRENT_STREAMS,
   1165       SETTINGS_FLAG_PLEASE_PERSIST,
   1166       1);
   1167 
   1168   base::WeakPtr<SpdySession> session =
   1169       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1170 
   1171   // Leave room for only one more stream to be created.
   1172   for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) {
   1173     base::WeakPtr<SpdyStream> spdy_stream =
   1174         CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1175                                   session, test_url_, MEDIUM, BoundNetLog());
   1176     ASSERT_TRUE(spdy_stream != NULL);
   1177   }
   1178 
   1179   // Create 2 more streams.  First will succeed.  Second will be pending.
   1180   base::WeakPtr<SpdyStream> spdy_stream1 =
   1181       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1182                                 session, test_url_, MEDIUM, BoundNetLog());
   1183   ASSERT_TRUE(spdy_stream1.get() != NULL);
   1184 
   1185   // Use scoped_ptr to let us invalidate the memory when we want to, to trigger
   1186   // a valgrind error if the callback is invoked when it's not supposed to be.
   1187   scoped_ptr<TestCompletionCallback> callback(new TestCompletionCallback);
   1188 
   1189   SpdyStreamRequest request;
   1190   ASSERT_EQ(ERR_IO_PENDING,
   1191             request.StartRequest(
   1192                 SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
   1193                 BoundNetLog(),
   1194                 callback->callback()));
   1195 
   1196   // Release the first one, this will allow the second to be created.
   1197   spdy_stream1->Cancel();
   1198   EXPECT_EQ(NULL, spdy_stream1.get());
   1199 
   1200   request.CancelRequest();
   1201   callback.reset();
   1202 
   1203   // Should not crash when running the pending callback.
   1204   base::MessageLoop::current()->RunUntilIdle();
   1205 }
   1206 
   1207 TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
   1208   session_deps_.host_resolver->set_synchronous_mode(true);
   1209 
   1210   MockRead reads[] = {
   1211     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   1212   };
   1213 
   1214   SettingsMap settings;
   1215   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   1216   const SpdySettingsIds kSpdySettingsIds2 = SETTINGS_INITIAL_WINDOW_SIZE;
   1217   const uint32 kInitialRecvWindowSize = 10 * 1024 * 1024;
   1218   settings[kSpdySettingsIds1] =
   1219       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
   1220   if (spdy_util_.spdy_version() >= SPDY3) {
   1221     settings[kSpdySettingsIds2] =
   1222         SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kInitialRecvWindowSize);
   1223   }
   1224   MockConnect connect_data(SYNCHRONOUS, OK);
   1225   scoped_ptr<SpdyFrame> settings_frame(
   1226       spdy_util_.ConstructSpdySettings(settings));
   1227   scoped_ptr<SpdyFrame> initial_window_update(
   1228       spdy_util_.ConstructSpdyWindowUpdate(
   1229           kSessionFlowControlStreamId,
   1230           kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   1231   std::vector<MockWrite> writes;
   1232   if (GetParam() == kProtoHTTP2Draft04) {
   1233     writes.push_back(
   1234         MockWrite(ASYNC,
   1235                   kHttp2ConnectionHeaderPrefix,
   1236                   kHttp2ConnectionHeaderPrefixSize));
   1237   }
   1238   writes.push_back(CreateMockWrite(*settings_frame));
   1239   if (GetParam() >= kProtoSPDY31) {
   1240     writes.push_back(CreateMockWrite(*initial_window_update));
   1241   };
   1242 
   1243   SettingsMap server_settings;
   1244   const uint32 initial_max_concurrent_streams = 1;
   1245   server_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
   1246       SettingsFlagsAndValue(SETTINGS_FLAG_PERSISTED,
   1247                             initial_max_concurrent_streams);
   1248   scoped_ptr<SpdyFrame> server_settings_frame(
   1249       spdy_util_.ConstructSpdySettings(server_settings));
   1250   writes.push_back(CreateMockWrite(*server_settings_frame));
   1251 
   1252   session_deps_.stream_initial_recv_window_size = kInitialRecvWindowSize;
   1253 
   1254   StaticSocketDataProvider data(reads, arraysize(reads),
   1255                                 vector_as_array(&writes), writes.size());
   1256   data.set_connect_data(connect_data);
   1257   session_deps_.socket_factory->AddSocketDataProvider(&data);
   1258 
   1259   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1260   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   1261 
   1262   CreateNetworkSession();
   1263 
   1264   spdy_session_pool_->http_server_properties()->SetSpdySetting(
   1265       test_host_port_pair_,
   1266       SETTINGS_MAX_CONCURRENT_STREAMS,
   1267       SETTINGS_FLAG_PLEASE_PERSIST,
   1268       initial_max_concurrent_streams);
   1269 
   1270   SpdySessionPoolPeer pool_peer(spdy_session_pool_);
   1271   pool_peer.SetEnableSendingInitialData(true);
   1272 
   1273   base::WeakPtr<SpdySession> session =
   1274       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1275 
   1276   base::MessageLoop::current()->RunUntilIdle();
   1277   EXPECT_TRUE(data.at_write_eof());
   1278 }
   1279 
   1280 TEST_P(SpdySessionTest, ClearSettingsStorageOnIPAddressChanged) {
   1281   CreateNetworkSession();
   1282 
   1283   base::WeakPtr<HttpServerProperties> test_http_server_properties =
   1284       spdy_session_pool_->http_server_properties();
   1285   SettingsFlagsAndValue flags_and_value1(SETTINGS_FLAG_PLEASE_PERSIST, 2);
   1286   test_http_server_properties->SetSpdySetting(
   1287       test_host_port_pair_,
   1288       SETTINGS_MAX_CONCURRENT_STREAMS,
   1289       SETTINGS_FLAG_PLEASE_PERSIST,
   1290       2);
   1291   EXPECT_NE(0u, test_http_server_properties->GetSpdySettings(
   1292       test_host_port_pair_).size());
   1293   spdy_session_pool_->OnIPAddressChanged();
   1294   EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
   1295       test_host_port_pair_).size());
   1296 }
   1297 
   1298 TEST_P(SpdySessionTest, Initialize) {
   1299   CapturingBoundNetLog log;
   1300   session_deps_.net_log = log.bound().net_log();
   1301   session_deps_.host_resolver->set_synchronous_mode(true);
   1302 
   1303   MockConnect connect_data(SYNCHRONOUS, OK);
   1304   MockRead reads[] = {
   1305     MockRead(ASYNC, 0, 0)  // EOF
   1306   };
   1307 
   1308   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   1309   data.set_connect_data(connect_data);
   1310   session_deps_.socket_factory->AddSocketDataProvider(&data);
   1311 
   1312   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1313   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   1314 
   1315   CreateNetworkSession();
   1316 
   1317   base::WeakPtr<SpdySession> session =
   1318       CreateInsecureSpdySession(http_session_, key_, log.bound());
   1319   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
   1320 
   1321   // Flush the read completion task.
   1322   base::MessageLoop::current()->RunUntilIdle();
   1323 
   1324   net::CapturingNetLog::CapturedEntryList entries;
   1325   log.GetEntries(&entries);
   1326   EXPECT_LT(0u, entries.size());
   1327 
   1328   // Check that we logged TYPE_SPDY_SESSION_INITIALIZED correctly.
   1329   int pos = net::ExpectLogContainsSomewhere(
   1330       entries, 0,
   1331       net::NetLog::TYPE_SPDY_SESSION_INITIALIZED,
   1332       net::NetLog::PHASE_NONE);
   1333   EXPECT_LT(0, pos);
   1334 
   1335   CapturingNetLog::CapturedEntry entry = entries[pos];
   1336   NetLog::Source socket_source;
   1337   EXPECT_TRUE(NetLog::Source::FromEventParameters(entry.params.get(),
   1338                                                   &socket_source));
   1339   EXPECT_TRUE(socket_source.IsValid());
   1340   EXPECT_NE(log.bound().source().id, socket_source.id);
   1341 }
   1342 
   1343 TEST_P(SpdySessionTest, CloseSessionOnError) {
   1344   session_deps_.host_resolver->set_synchronous_mode(true);
   1345 
   1346   MockConnect connect_data(SYNCHRONOUS, OK);
   1347   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
   1348   MockRead reads[] = {
   1349     CreateMockRead(*goaway),
   1350     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   1351   };
   1352 
   1353   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   1354   data.set_connect_data(connect_data);
   1355   session_deps_.socket_factory->AddSocketDataProvider(&data);
   1356 
   1357   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1358   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   1359 
   1360   CreateNetworkSession();
   1361 
   1362   CapturingBoundNetLog log;
   1363   base::WeakPtr<SpdySession> session =
   1364       CreateInsecureSpdySession(http_session_, key_, log.bound());
   1365   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
   1366 
   1367   // Flush the read completion task.
   1368   base::MessageLoop::current()->RunUntilIdle();
   1369 
   1370   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
   1371   EXPECT_TRUE(session == NULL);
   1372 
   1373   // Check that the NetLog was filled reasonably.
   1374   net::CapturingNetLog::CapturedEntryList entries;
   1375   log.GetEntries(&entries);
   1376   EXPECT_LT(0u, entries.size());
   1377 
   1378   // Check that we logged SPDY_SESSION_CLOSE correctly.
   1379   int pos = net::ExpectLogContainsSomewhere(
   1380       entries, 0,
   1381       net::NetLog::TYPE_SPDY_SESSION_CLOSE,
   1382       net::NetLog::PHASE_NONE);
   1383 
   1384   if (pos < static_cast<int>(entries.size())) {
   1385     CapturingNetLog::CapturedEntry entry = entries[pos];
   1386     int error_code = 0;
   1387     ASSERT_TRUE(entry.GetNetErrorCode(&error_code));
   1388     EXPECT_EQ(ERR_CONNECTION_CLOSED, error_code);
   1389   } else {
   1390     ADD_FAILURE();
   1391   }
   1392 }
   1393 
   1394 // Queue up a low-priority SYN_STREAM followed by a high-priority
   1395 // one. The high priority one should still send first and receive
   1396 // first.
   1397 TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
   1398   // Construct the request.
   1399   MockConnect connect_data(SYNCHRONOUS, OK);
   1400   scoped_ptr<SpdyFrame> req_highest(
   1401       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, HIGHEST, true));
   1402   scoped_ptr<SpdyFrame> req_lowest(
   1403       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   1404   MockWrite writes[] = {
   1405     CreateMockWrite(*req_highest, 0),
   1406     CreateMockWrite(*req_lowest, 1),
   1407   };
   1408 
   1409   scoped_ptr<SpdyFrame> resp_highest(
   1410       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   1411   scoped_ptr<SpdyFrame> body_highest(
   1412       spdy_util_.ConstructSpdyBodyFrame(1, true));
   1413   scoped_ptr<SpdyFrame> resp_lowest(
   1414       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   1415   scoped_ptr<SpdyFrame> body_lowest(
   1416       spdy_util_.ConstructSpdyBodyFrame(3, true));
   1417   MockRead reads[] = {
   1418     CreateMockRead(*resp_highest, 2),
   1419     CreateMockRead(*body_highest, 3),
   1420     CreateMockRead(*resp_lowest, 4),
   1421     CreateMockRead(*body_lowest, 5),
   1422     MockRead(ASYNC, 0, 6)  // EOF
   1423   };
   1424 
   1425   session_deps_.host_resolver->set_synchronous_mode(true);
   1426 
   1427   DeterministicSocketData data(reads, arraysize(reads),
   1428                                writes, arraysize(writes));
   1429   data.set_connect_data(connect_data);
   1430   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1431 
   1432   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1433   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1434 
   1435   CreateDeterministicNetworkSession();
   1436 
   1437   base::WeakPtr<SpdySession> session =
   1438       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1439 
   1440   GURL url("http://www.google.com");
   1441 
   1442   base::WeakPtr<SpdyStream> spdy_stream_lowest =
   1443       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1444                                 session, url, LOWEST, BoundNetLog());
   1445   ASSERT_TRUE(spdy_stream_lowest);
   1446   EXPECT_EQ(0u, spdy_stream_lowest->stream_id());
   1447   test::StreamDelegateDoNothing delegate_lowest(spdy_stream_lowest);
   1448   spdy_stream_lowest->SetDelegate(&delegate_lowest);
   1449 
   1450   base::WeakPtr<SpdyStream> spdy_stream_highest =
   1451       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1452                                 session, url, HIGHEST, BoundNetLog());
   1453   ASSERT_TRUE(spdy_stream_highest);
   1454   EXPECT_EQ(0u, spdy_stream_highest->stream_id());
   1455   test::StreamDelegateDoNothing delegate_highest(spdy_stream_highest);
   1456   spdy_stream_highest->SetDelegate(&delegate_highest);
   1457 
   1458   // Queue the lower priority one first.
   1459 
   1460   scoped_ptr<SpdyHeaderBlock> headers_lowest(
   1461       spdy_util_.ConstructGetHeaderBlock(url.spec()));
   1462   spdy_stream_lowest->SendRequestHeaders(
   1463       headers_lowest.Pass(), NO_MORE_DATA_TO_SEND);
   1464   EXPECT_TRUE(spdy_stream_lowest->HasUrlFromHeaders());
   1465 
   1466   scoped_ptr<SpdyHeaderBlock> headers_highest(
   1467       spdy_util_.ConstructGetHeaderBlock(url.spec()));
   1468   spdy_stream_highest->SendRequestHeaders(
   1469       headers_highest.Pass(), NO_MORE_DATA_TO_SEND);
   1470   EXPECT_TRUE(spdy_stream_highest->HasUrlFromHeaders());
   1471 
   1472   data.RunFor(7);
   1473 
   1474   EXPECT_FALSE(spdy_stream_lowest);
   1475   EXPECT_FALSE(spdy_stream_highest);
   1476   EXPECT_EQ(3u, delegate_lowest.stream_id());
   1477   EXPECT_EQ(1u, delegate_highest.stream_id());
   1478 }
   1479 
   1480 TEST_P(SpdySessionTest, CancelStream) {
   1481   MockConnect connect_data(SYNCHRONOUS, OK);
   1482   // Request 1, at HIGHEST priority, will be cancelled before it writes data.
   1483   // Request 2, at LOWEST priority, will be a full request and will be id 1.
   1484   scoped_ptr<SpdyFrame> req2(
   1485       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   1486   MockWrite writes[] = {
   1487     CreateMockWrite(*req2, 0),
   1488   };
   1489 
   1490   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   1491   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
   1492   MockRead reads[] = {
   1493     CreateMockRead(*resp2, 1),
   1494     CreateMockRead(*body2, 2),
   1495     MockRead(ASYNC, 0, 3)  // EOF
   1496   };
   1497 
   1498   session_deps_.host_resolver->set_synchronous_mode(true);
   1499 
   1500   DeterministicSocketData data(reads, arraysize(reads),
   1501                                writes, arraysize(writes));
   1502   data.set_connect_data(connect_data);
   1503   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1504 
   1505   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1506   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1507 
   1508   CreateDeterministicNetworkSession();
   1509 
   1510   base::WeakPtr<SpdySession> session =
   1511       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1512 
   1513   GURL url1("http://www.google.com");
   1514   base::WeakPtr<SpdyStream> spdy_stream1 =
   1515       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1516                                 session, url1, HIGHEST, BoundNetLog());
   1517   ASSERT_TRUE(spdy_stream1.get() != NULL);
   1518   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1519   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   1520   spdy_stream1->SetDelegate(&delegate1);
   1521 
   1522   GURL url2("http://www.google.com");
   1523   base::WeakPtr<SpdyStream> spdy_stream2 =
   1524       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1525                                 session, url2, LOWEST, BoundNetLog());
   1526   ASSERT_TRUE(spdy_stream2.get() != NULL);
   1527   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1528   test::StreamDelegateDoNothing delegate2(spdy_stream2);
   1529   spdy_stream2->SetDelegate(&delegate2);
   1530 
   1531   scoped_ptr<SpdyHeaderBlock> headers(
   1532       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   1533   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   1534   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   1535 
   1536   scoped_ptr<SpdyHeaderBlock> headers2(
   1537       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
   1538   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   1539   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
   1540 
   1541   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1542 
   1543   spdy_stream1->Cancel();
   1544   EXPECT_EQ(NULL, spdy_stream1.get());
   1545 
   1546   EXPECT_EQ(0u, delegate1.stream_id());
   1547 
   1548   data.RunFor(1);
   1549 
   1550   EXPECT_EQ(0u, delegate1.stream_id());
   1551   EXPECT_EQ(1u, delegate2.stream_id());
   1552 
   1553   spdy_stream2->Cancel();
   1554   EXPECT_EQ(NULL, spdy_stream2.get());
   1555 }
   1556 
   1557 // Create two streams that are set to re-close themselves on close,
   1558 // and then close the session. Nothing should blow up. Also a
   1559 // regression test for http://crbug.com/139518 .
   1560 TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
   1561   session_deps_.host_resolver->set_synchronous_mode(true);
   1562 
   1563   MockConnect connect_data(SYNCHRONOUS, OK);
   1564 
   1565   // No actual data will be sent.
   1566   MockWrite writes[] = {
   1567     MockWrite(ASYNC, 0, 1)  // EOF
   1568   };
   1569 
   1570   MockRead reads[] = {
   1571     MockRead(ASYNC, 0, 0)  // EOF
   1572   };
   1573   DeterministicSocketData data(reads, arraysize(reads),
   1574                                writes, arraysize(writes));
   1575   data.set_connect_data(connect_data);
   1576   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1577 
   1578   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1579   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1580 
   1581   CreateDeterministicNetworkSession();
   1582 
   1583   base::WeakPtr<SpdySession> session =
   1584       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1585 
   1586   GURL url1("http://www.google.com");
   1587   base::WeakPtr<SpdyStream> spdy_stream1 =
   1588       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1589                                 session, url1, HIGHEST, BoundNetLog());
   1590   ASSERT_TRUE(spdy_stream1.get() != NULL);
   1591   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1592 
   1593   GURL url2("http://www.google.com");
   1594   base::WeakPtr<SpdyStream> spdy_stream2 =
   1595       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1596                                 session, url2, LOWEST, BoundNetLog());
   1597   ASSERT_TRUE(spdy_stream2.get() != NULL);
   1598   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1599 
   1600   test::ClosingDelegate delegate1(spdy_stream1);
   1601   spdy_stream1->SetDelegate(&delegate1);
   1602 
   1603   test::ClosingDelegate delegate2(spdy_stream2);
   1604   spdy_stream2->SetDelegate(&delegate2);
   1605 
   1606   scoped_ptr<SpdyHeaderBlock> headers(
   1607       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   1608   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   1609   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   1610 
   1611   scoped_ptr<SpdyHeaderBlock> headers2(
   1612       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
   1613   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   1614   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
   1615 
   1616   // Ensure that the streams have not yet been activated and assigned an id.
   1617   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1618   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1619 
   1620   // Ensure we don't crash while closing the session.
   1621   session->CloseSessionOnError(ERR_ABORTED, std::string());
   1622 
   1623   EXPECT_EQ(NULL, spdy_stream1.get());
   1624   EXPECT_EQ(NULL, spdy_stream2.get());
   1625 
   1626   EXPECT_TRUE(delegate1.StreamIsClosed());
   1627   EXPECT_TRUE(delegate2.StreamIsClosed());
   1628 
   1629   EXPECT_TRUE(session == NULL);
   1630 }
   1631 
   1632 // Create two streams that are set to close each other on close, and
   1633 // then close the session. Nothing should blow up.
   1634 TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
   1635   session_deps_.host_resolver->set_synchronous_mode(true);
   1636 
   1637   MockConnect connect_data(SYNCHRONOUS, OK);
   1638 
   1639   // No actual data will be sent.
   1640   MockWrite writes[] = {
   1641     MockWrite(ASYNC, 0, 1)  // EOF
   1642   };
   1643 
   1644   MockRead reads[] = {
   1645     MockRead(ASYNC, 0, 0)  // EOF
   1646   };
   1647   DeterministicSocketData data(reads, arraysize(reads),
   1648                                writes, arraysize(writes));
   1649   data.set_connect_data(connect_data);
   1650   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1651 
   1652   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1653   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1654 
   1655   CreateDeterministicNetworkSession();
   1656 
   1657   base::WeakPtr<SpdySession> session =
   1658       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1659 
   1660   GURL url1("http://www.google.com");
   1661   base::WeakPtr<SpdyStream> spdy_stream1 =
   1662       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1663                                 session, url1, HIGHEST, BoundNetLog());
   1664   ASSERT_TRUE(spdy_stream1.get() != NULL);
   1665   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1666 
   1667   GURL url2("http://www.google.com");
   1668   base::WeakPtr<SpdyStream> spdy_stream2 =
   1669       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   1670                                 session, url2, LOWEST, BoundNetLog());
   1671   ASSERT_TRUE(spdy_stream2.get() != NULL);
   1672   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1673 
   1674   // Make |spdy_stream1| close |spdy_stream2|.
   1675   test::ClosingDelegate delegate1(spdy_stream2);
   1676   spdy_stream1->SetDelegate(&delegate1);
   1677 
   1678   // Make |spdy_stream2| close |spdy_stream1|.
   1679   test::ClosingDelegate delegate2(spdy_stream1);
   1680   spdy_stream2->SetDelegate(&delegate2);
   1681 
   1682   scoped_ptr<SpdyHeaderBlock> headers(
   1683       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   1684   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   1685   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   1686 
   1687   scoped_ptr<SpdyHeaderBlock> headers2(
   1688       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
   1689   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   1690   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
   1691 
   1692   // Ensure that the streams have not yet been activated and assigned an id.
   1693   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1694   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1695 
   1696   // Ensure we don't crash while closing the session.
   1697   session->CloseSessionOnError(ERR_ABORTED, std::string());
   1698 
   1699   EXPECT_EQ(NULL, spdy_stream1.get());
   1700   EXPECT_EQ(NULL, spdy_stream2.get());
   1701 
   1702   EXPECT_TRUE(delegate1.StreamIsClosed());
   1703   EXPECT_TRUE(delegate2.StreamIsClosed());
   1704 
   1705   EXPECT_TRUE(session == NULL);
   1706 }
   1707 
   1708 // Create two streams that are set to re-close themselves on close,
   1709 // activate them, and then close the session. Nothing should blow up.
   1710 TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
   1711   session_deps_.host_resolver->set_synchronous_mode(true);
   1712 
   1713   MockConnect connect_data(SYNCHRONOUS, OK);
   1714 
   1715   scoped_ptr<SpdyFrame> req1(
   1716       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   1717   scoped_ptr<SpdyFrame> req2(
   1718       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
   1719   MockWrite writes[] = {
   1720     CreateMockWrite(*req1, 0),
   1721     CreateMockWrite(*req2, 1),
   1722   };
   1723 
   1724   MockRead reads[] = {
   1725     MockRead(ASYNC, 0, 2)  // EOF
   1726   };
   1727 
   1728   DeterministicSocketData data(reads, arraysize(reads),
   1729                                writes, arraysize(writes));
   1730   data.set_connect_data(connect_data);
   1731   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1732 
   1733   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1734   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1735 
   1736   CreateDeterministicNetworkSession();
   1737 
   1738   base::WeakPtr<SpdySession> session =
   1739       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1740 
   1741   GURL url1("http://www.google.com");
   1742   base::WeakPtr<SpdyStream> spdy_stream1 =
   1743       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1744                                 session, url1, MEDIUM, BoundNetLog());
   1745   ASSERT_TRUE(spdy_stream1.get() != NULL);
   1746   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1747 
   1748   GURL url2("http://www.google.com");
   1749   base::WeakPtr<SpdyStream> spdy_stream2 =
   1750       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1751                                 session, url2, MEDIUM, BoundNetLog());
   1752   ASSERT_TRUE(spdy_stream2.get() != NULL);
   1753   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1754 
   1755   test::ClosingDelegate delegate1(spdy_stream1);
   1756   spdy_stream1->SetDelegate(&delegate1);
   1757 
   1758   test::ClosingDelegate delegate2(spdy_stream2);
   1759   spdy_stream2->SetDelegate(&delegate2);
   1760 
   1761   scoped_ptr<SpdyHeaderBlock> headers(
   1762       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   1763   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   1764   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   1765 
   1766   scoped_ptr<SpdyHeaderBlock> headers2(
   1767       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
   1768   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   1769   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
   1770 
   1771   // Ensure that the streams have not yet been activated and assigned an id.
   1772   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1773   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1774 
   1775   data.RunFor(2);
   1776 
   1777   EXPECT_EQ(1u, spdy_stream1->stream_id());
   1778   EXPECT_EQ(3u, spdy_stream2->stream_id());
   1779 
   1780   // Ensure we don't crash while closing the session.
   1781   session->CloseSessionOnError(ERR_ABORTED, std::string());
   1782 
   1783   EXPECT_EQ(NULL, spdy_stream1.get());
   1784   EXPECT_EQ(NULL, spdy_stream2.get());
   1785 
   1786   EXPECT_TRUE(delegate1.StreamIsClosed());
   1787   EXPECT_TRUE(delegate2.StreamIsClosed());
   1788 
   1789   EXPECT_TRUE(session == NULL);
   1790 }
   1791 
   1792 // Create two streams that are set to close each other on close,
   1793 // activate them, and then close the session. Nothing should blow up.
   1794 TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
   1795   session_deps_.host_resolver->set_synchronous_mode(true);
   1796 
   1797   MockConnect connect_data(SYNCHRONOUS, OK);
   1798 
   1799   scoped_ptr<SpdyFrame> req1(
   1800       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   1801   scoped_ptr<SpdyFrame> req2(
   1802       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
   1803   MockWrite writes[] = {
   1804     CreateMockWrite(*req1, 0),
   1805     CreateMockWrite(*req2, 1),
   1806   };
   1807 
   1808   MockRead reads[] = {
   1809     MockRead(ASYNC, 0, 2)  // EOF
   1810   };
   1811 
   1812   DeterministicSocketData data(reads, arraysize(reads),
   1813                                writes, arraysize(writes));
   1814   data.set_connect_data(connect_data);
   1815   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1816 
   1817   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1818   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1819 
   1820   CreateDeterministicNetworkSession();
   1821 
   1822   base::WeakPtr<SpdySession> session =
   1823       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1824 
   1825   GURL url1("http://www.google.com");
   1826   base::WeakPtr<SpdyStream> spdy_stream1 =
   1827       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1828                                 session, url1, MEDIUM, BoundNetLog());
   1829   ASSERT_TRUE(spdy_stream1.get() != NULL);
   1830   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1831 
   1832   GURL url2("http://www.google.com");
   1833   base::WeakPtr<SpdyStream> spdy_stream2 =
   1834       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1835                                 session, url2, MEDIUM, BoundNetLog());
   1836   ASSERT_TRUE(spdy_stream2.get() != NULL);
   1837   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1838 
   1839   // Make |spdy_stream1| close |spdy_stream2|.
   1840   test::ClosingDelegate delegate1(spdy_stream2);
   1841   spdy_stream1->SetDelegate(&delegate1);
   1842 
   1843   // Make |spdy_stream2| close |spdy_stream1|.
   1844   test::ClosingDelegate delegate2(spdy_stream1);
   1845   spdy_stream2->SetDelegate(&delegate2);
   1846 
   1847   scoped_ptr<SpdyHeaderBlock> headers(
   1848       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   1849   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   1850   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   1851 
   1852   scoped_ptr<SpdyHeaderBlock> headers2(
   1853       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
   1854   spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   1855   EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
   1856 
   1857   // Ensure that the streams have not yet been activated and assigned an id.
   1858   EXPECT_EQ(0u, spdy_stream1->stream_id());
   1859   EXPECT_EQ(0u, spdy_stream2->stream_id());
   1860 
   1861   data.RunFor(2);
   1862 
   1863   EXPECT_EQ(1u, spdy_stream1->stream_id());
   1864   EXPECT_EQ(3u, spdy_stream2->stream_id());
   1865 
   1866   // Ensure we don't crash while closing the session.
   1867   session->CloseSessionOnError(ERR_ABORTED, std::string());
   1868 
   1869   EXPECT_EQ(NULL, spdy_stream1.get());
   1870   EXPECT_EQ(NULL, spdy_stream2.get());
   1871 
   1872   EXPECT_TRUE(delegate1.StreamIsClosed());
   1873   EXPECT_TRUE(delegate2.StreamIsClosed());
   1874 
   1875   EXPECT_TRUE(session == NULL);
   1876 }
   1877 
   1878 // Delegate that closes a given session when the stream is closed.
   1879 class SessionClosingDelegate : public test::StreamDelegateDoNothing {
   1880  public:
   1881   SessionClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
   1882                          const base::WeakPtr<SpdySession>& session_to_close)
   1883       : StreamDelegateDoNothing(stream),
   1884         session_to_close_(session_to_close) {}
   1885 
   1886   virtual ~SessionClosingDelegate() {}
   1887 
   1888   virtual void OnClose(int status) OVERRIDE {
   1889     session_to_close_->CloseSessionOnError(ERR_ABORTED, "Aborted");
   1890   }
   1891 
   1892  private:
   1893   base::WeakPtr<SpdySession> session_to_close_;
   1894 };
   1895 
   1896 // Close an activated stream that closes its session. Nothing should
   1897 // blow up. This is a regression test for http://crbug.com/263691 .
   1898 TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
   1899   session_deps_.host_resolver->set_synchronous_mode(true);
   1900 
   1901   MockConnect connect_data(SYNCHRONOUS, OK);
   1902 
   1903   scoped_ptr<SpdyFrame> req(
   1904       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   1905   MockWrite writes[] = {
   1906     CreateMockWrite(*req, 0),
   1907   };
   1908 
   1909   MockRead reads[] = {
   1910     MockRead(ASYNC, 0, 1)  // EOF
   1911   };
   1912   DeterministicSocketData data(reads, arraysize(reads),
   1913                                writes, arraysize(writes));
   1914   data.set_connect_data(connect_data);
   1915   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1916 
   1917   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1918   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1919 
   1920   CreateDeterministicNetworkSession();
   1921 
   1922   base::WeakPtr<SpdySession> session =
   1923       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   1924 
   1925   GURL url("http://www.google.com");
   1926   base::WeakPtr<SpdyStream> spdy_stream =
   1927       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   1928                                 session, url, MEDIUM, BoundNetLog());
   1929   ASSERT_TRUE(spdy_stream.get() != NULL);
   1930   EXPECT_EQ(0u, spdy_stream->stream_id());
   1931 
   1932   SessionClosingDelegate delegate(spdy_stream, session);
   1933   spdy_stream->SetDelegate(&delegate);
   1934 
   1935   scoped_ptr<SpdyHeaderBlock> headers(
   1936       spdy_util_.ConstructGetHeaderBlock(url.spec()));
   1937   spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   1938   EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
   1939 
   1940   EXPECT_EQ(0u, spdy_stream->stream_id());
   1941 
   1942   data.RunFor(1);
   1943 
   1944   EXPECT_EQ(1u, spdy_stream->stream_id());
   1945 
   1946   // Ensure we don't crash while closing the stream (which closes the
   1947   // session).
   1948   spdy_stream->Cancel();
   1949 
   1950   EXPECT_EQ(NULL, spdy_stream.get());
   1951   EXPECT_TRUE(delegate.StreamIsClosed());
   1952   EXPECT_TRUE(session == NULL);
   1953 }
   1954 
   1955 TEST_P(SpdySessionTest, VerifyDomainAuthentication) {
   1956   session_deps_.host_resolver->set_synchronous_mode(true);
   1957 
   1958   MockConnect connect_data(SYNCHRONOUS, OK);
   1959 
   1960   // No actual data will be sent.
   1961   MockWrite writes[] = {
   1962     MockWrite(ASYNC, 0, 1)  // EOF
   1963   };
   1964 
   1965   MockRead reads[] = {
   1966     MockRead(ASYNC, 0, 0)  // EOF
   1967   };
   1968   DeterministicSocketData data(reads, arraysize(reads),
   1969                                writes, arraysize(writes));
   1970   data.set_connect_data(connect_data);
   1971   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   1972 
   1973   // Load a cert that is valid for:
   1974   //   www.example.org
   1975   //   mail.example.org
   1976   //   www.example.com
   1977   base::FilePath certs_dir = GetTestCertsDirectory();
   1978   scoped_refptr<X509Certificate> test_cert(
   1979       ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
   1980   ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert);
   1981 
   1982   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   1983   ssl.cert = test_cert;
   1984   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   1985 
   1986   CreateDeterministicNetworkSession();
   1987 
   1988   base::WeakPtr<SpdySession> session =
   1989       CreateSecureSpdySession(http_session_, key_, BoundNetLog());
   1990 
   1991   EXPECT_TRUE(session->VerifyDomainAuthentication("www.example.org"));
   1992   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.org"));
   1993   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.com"));
   1994   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.google.com"));
   1995 }
   1996 
   1997 TEST_P(SpdySessionTest, ConnectionPooledWithTlsChannelId) {
   1998   session_deps_.host_resolver->set_synchronous_mode(true);
   1999 
   2000   MockConnect connect_data(SYNCHRONOUS, OK);
   2001 
   2002   // No actual data will be sent.
   2003   MockWrite writes[] = {
   2004     MockWrite(ASYNC, 0, 1)  // EOF
   2005   };
   2006 
   2007   MockRead reads[] = {
   2008     MockRead(ASYNC, 0, 0)  // EOF
   2009   };
   2010   DeterministicSocketData data(reads, arraysize(reads),
   2011                                writes, arraysize(writes));
   2012   data.set_connect_data(connect_data);
   2013   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   2014 
   2015   // Load a cert that is valid for:
   2016   //   www.example.org
   2017   //   mail.example.org
   2018   //   www.example.com
   2019   base::FilePath certs_dir = GetTestCertsDirectory();
   2020   scoped_refptr<X509Certificate> test_cert(
   2021       ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
   2022   ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert);
   2023 
   2024   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2025   ssl.channel_id_sent = true;
   2026   ssl.cert = test_cert;
   2027   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   2028 
   2029   CreateDeterministicNetworkSession();
   2030 
   2031   base::WeakPtr<SpdySession> session =
   2032       CreateSecureSpdySession(http_session_, key_, BoundNetLog());
   2033 
   2034   EXPECT_TRUE(session->VerifyDomainAuthentication("www.example.org"));
   2035   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.org"));
   2036   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.example.com"));
   2037   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.google.com"));
   2038 }
   2039 
   2040 TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
   2041   // TODO(rtenneti): Define a helper class/methods and move the common code in
   2042   // this file.
   2043   MockConnect connect_data(SYNCHRONOUS, OK);
   2044 
   2045   SettingsMap new_settings;
   2046   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   2047   const uint32 max_concurrent_streams = 1;
   2048   new_settings[kSpdySettingsIds1] =
   2049       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   2050 
   2051   scoped_ptr<SpdyFrame> req1(
   2052       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   2053   scoped_ptr<SpdyFrame> req2(
   2054       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   2055   scoped_ptr<SpdyFrame> req3(
   2056       spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, LOWEST, true));
   2057   MockWrite writes[] = {
   2058     CreateMockWrite(*req1, 1),
   2059     CreateMockWrite(*req2, 4),
   2060     CreateMockWrite(*req3, 7),
   2061   };
   2062 
   2063   // Set up the socket so we read a SETTINGS frame that sets max concurrent
   2064   // streams to 1.
   2065   scoped_ptr<SpdyFrame> settings_frame(
   2066       spdy_util_.ConstructSpdySettings(new_settings));
   2067 
   2068   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   2069   scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
   2070 
   2071   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   2072   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true));
   2073 
   2074   scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
   2075   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, true));
   2076 
   2077   MockRead reads[] = {
   2078     CreateMockRead(*settings_frame),
   2079     CreateMockRead(*resp1, 2),
   2080     CreateMockRead(*body1, 3),
   2081     CreateMockRead(*resp2, 5),
   2082     CreateMockRead(*body2, 6),
   2083     CreateMockRead(*resp3, 8),
   2084     CreateMockRead(*body3, 9),
   2085     MockRead(ASYNC, 0, 10)  // EOF
   2086   };
   2087 
   2088   DeterministicSocketData data(reads, arraysize(reads),
   2089                                writes, arraysize(writes));
   2090   data.set_connect_data(connect_data);
   2091   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   2092 
   2093   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2094   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   2095 
   2096   CreateDeterministicNetworkSession();
   2097 
   2098   base::WeakPtr<SpdySession> session =
   2099       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   2100 
   2101   // Read the settings frame.
   2102   data.RunFor(1);
   2103 
   2104   GURL url1("http://www.google.com");
   2105   base::WeakPtr<SpdyStream> spdy_stream1 =
   2106       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2107                                 session, url1, LOWEST, BoundNetLog());
   2108   ASSERT_TRUE(spdy_stream1.get() != NULL);
   2109   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2110   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   2111   spdy_stream1->SetDelegate(&delegate1);
   2112 
   2113   TestCompletionCallback callback2;
   2114   GURL url2("http://www.google.com");
   2115   SpdyStreamRequest request2;
   2116   ASSERT_EQ(ERR_IO_PENDING,
   2117             request2.StartRequest(
   2118                 SPDY_REQUEST_RESPONSE_STREAM,
   2119                 session, url2, LOWEST, BoundNetLog(), callback2.callback()));
   2120 
   2121   TestCompletionCallback callback3;
   2122   GURL url3("http://www.google.com");
   2123   SpdyStreamRequest request3;
   2124   ASSERT_EQ(ERR_IO_PENDING,
   2125             request3.StartRequest(
   2126                 SPDY_REQUEST_RESPONSE_STREAM,
   2127                 session, url3, LOWEST, BoundNetLog(), callback3.callback()));
   2128 
   2129   EXPECT_EQ(0u, session->num_active_streams());
   2130   EXPECT_EQ(1u, session->num_created_streams());
   2131   EXPECT_EQ(2u, session->pending_create_stream_queue_size(LOWEST));
   2132 
   2133   scoped_ptr<SpdyHeaderBlock> headers(
   2134       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   2135   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   2136   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   2137 
   2138   // Run until 1st stream is activated and then closed.
   2139   EXPECT_EQ(0u, delegate1.stream_id());
   2140   data.RunFor(3);
   2141   EXPECT_EQ(NULL, spdy_stream1.get());
   2142   EXPECT_EQ(1u, delegate1.stream_id());
   2143 
   2144   EXPECT_EQ(0u, session->num_active_streams());
   2145   EXPECT_EQ(0u, session->num_created_streams());
   2146   EXPECT_EQ(1u, session->pending_create_stream_queue_size(LOWEST));
   2147 
   2148   // Pump loop for SpdySession::ProcessPendingStreamRequests() to
   2149   // create the 2nd stream.
   2150   base::MessageLoop::current()->RunUntilIdle();
   2151 
   2152   EXPECT_EQ(0u, session->num_active_streams());
   2153   EXPECT_EQ(1u, session->num_created_streams());
   2154   EXPECT_EQ(1u, session->pending_create_stream_queue_size(LOWEST));
   2155 
   2156   base::WeakPtr<SpdyStream> stream2 = request2.ReleaseStream();
   2157   test::StreamDelegateDoNothing delegate2(stream2);
   2158   stream2->SetDelegate(&delegate2);
   2159   scoped_ptr<SpdyHeaderBlock> headers2(
   2160       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
   2161   stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   2162   EXPECT_TRUE(stream2->HasUrlFromHeaders());
   2163 
   2164   // Run until 2nd stream is activated and then closed.
   2165   EXPECT_EQ(0u, delegate2.stream_id());
   2166   data.RunFor(3);
   2167   EXPECT_EQ(NULL, stream2.get());
   2168   EXPECT_EQ(3u, delegate2.stream_id());
   2169 
   2170   EXPECT_EQ(0u, session->num_active_streams());
   2171   EXPECT_EQ(0u, session->num_created_streams());
   2172   EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
   2173 
   2174   // Pump loop for SpdySession::ProcessPendingStreamRequests() to
   2175   // create the 3rd stream.
   2176   base::MessageLoop::current()->RunUntilIdle();
   2177 
   2178   EXPECT_EQ(0u, session->num_active_streams());
   2179   EXPECT_EQ(1u, session->num_created_streams());
   2180   EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
   2181 
   2182   base::WeakPtr<SpdyStream> stream3 = request3.ReleaseStream();
   2183   test::StreamDelegateDoNothing delegate3(stream3);
   2184   stream3->SetDelegate(&delegate3);
   2185   scoped_ptr<SpdyHeaderBlock> headers3(
   2186       spdy_util_.ConstructGetHeaderBlock(url3.spec()));
   2187   stream3->SendRequestHeaders(headers3.Pass(), NO_MORE_DATA_TO_SEND);
   2188   EXPECT_TRUE(stream3->HasUrlFromHeaders());
   2189 
   2190   // Run until 2nd stream is activated and then closed.
   2191   EXPECT_EQ(0u, delegate3.stream_id());
   2192   data.RunFor(3);
   2193   EXPECT_EQ(NULL, stream3.get());
   2194   EXPECT_EQ(5u, delegate3.stream_id());
   2195 
   2196   EXPECT_EQ(0u, session->num_active_streams());
   2197   EXPECT_EQ(0u, session->num_created_streams());
   2198   EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
   2199 
   2200   data.RunFor(1);
   2201 }
   2202 
   2203 TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
   2204   session_deps_.host_resolver->set_synchronous_mode(true);
   2205 
   2206   MockRead reads[] = {
   2207     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   2208   };
   2209 
   2210   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   2211   MockConnect connect_data(SYNCHRONOUS, OK);
   2212 
   2213   data.set_connect_data(connect_data);
   2214   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2215 
   2216   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2217   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   2218 
   2219   CreateNetworkSession();
   2220 
   2221   base::WeakPtr<SpdySession> session =
   2222       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   2223 
   2224   // Leave room for only one more stream to be created.
   2225   for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) {
   2226     base::WeakPtr<SpdyStream> spdy_stream =
   2227         CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   2228                                   session, test_url_, MEDIUM, BoundNetLog());
   2229     ASSERT_TRUE(spdy_stream != NULL);
   2230   }
   2231 
   2232   GURL url1("http://www.google.com");
   2233   base::WeakPtr<SpdyStream> spdy_stream1 =
   2234       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   2235                                 session, url1, LOWEST, BoundNetLog());
   2236   ASSERT_TRUE(spdy_stream1.get() != NULL);
   2237   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2238 
   2239   TestCompletionCallback callback2;
   2240   GURL url2("http://www.google.com");
   2241   SpdyStreamRequest request2;
   2242   ASSERT_EQ(ERR_IO_PENDING,
   2243             request2.StartRequest(
   2244                 SPDY_BIDIRECTIONAL_STREAM, session, url2, LOWEST, BoundNetLog(),
   2245                 callback2.callback()));
   2246 
   2247   TestCompletionCallback callback3;
   2248   GURL url3("http://www.google.com");
   2249   SpdyStreamRequest request3;
   2250   ASSERT_EQ(ERR_IO_PENDING,
   2251             request3.StartRequest(
   2252                 SPDY_BIDIRECTIONAL_STREAM, session, url3, LOWEST, BoundNetLog(),
   2253                 callback3.callback()));
   2254 
   2255   EXPECT_EQ(0u, session->num_active_streams());
   2256   EXPECT_EQ(kInitialMaxConcurrentStreams, session->num_created_streams());
   2257   EXPECT_EQ(2u, session->pending_create_stream_queue_size(LOWEST));
   2258 
   2259   // Cancel the first stream; this will allow the second stream to be created.
   2260   EXPECT_TRUE(spdy_stream1.get() != NULL);
   2261   spdy_stream1->Cancel();
   2262   EXPECT_EQ(NULL, spdy_stream1.get());
   2263 
   2264   EXPECT_EQ(OK, callback2.WaitForResult());
   2265   EXPECT_EQ(0u, session->num_active_streams());
   2266   EXPECT_EQ(kInitialMaxConcurrentStreams, session->num_created_streams());
   2267   EXPECT_EQ(1u, session->pending_create_stream_queue_size(LOWEST));
   2268 
   2269   // Cancel the second stream; this will allow the third stream to be created.
   2270   base::WeakPtr<SpdyStream> spdy_stream2 = request2.ReleaseStream();
   2271   spdy_stream2->Cancel();
   2272   EXPECT_EQ(NULL, spdy_stream2.get());
   2273 
   2274   EXPECT_EQ(OK, callback3.WaitForResult());
   2275   EXPECT_EQ(0u, session->num_active_streams());
   2276   EXPECT_EQ(kInitialMaxConcurrentStreams, session->num_created_streams());
   2277   EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
   2278 
   2279   // Cancel the third stream.
   2280   base::WeakPtr<SpdyStream> spdy_stream3 = request3.ReleaseStream();
   2281   spdy_stream3->Cancel();
   2282   EXPECT_EQ(NULL, spdy_stream3.get());
   2283   EXPECT_EQ(0u, session->num_active_streams());
   2284   EXPECT_EQ(kInitialMaxConcurrentStreams - 1, session->num_created_streams());
   2285   EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
   2286 }
   2287 
   2288 // Test that SpdySession::DoReadLoop reads data from the socket
   2289 // without yielding.  This test makes 32k - 1 bytes of data available
   2290 // on the socket for reading. It then verifies that it has read all
   2291 // the available data without yielding.
   2292 TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
   2293   MockConnect connect_data(SYNCHRONOUS, OK);
   2294   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   2295 
   2296   scoped_ptr<SpdyFrame> req1(
   2297       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   2298   MockWrite writes[] = {
   2299     CreateMockWrite(*req1, 0),
   2300   };
   2301 
   2302   // Build buffer of size kMaxReadBytesWithoutYielding / 4
   2303   // (-spdy_data_frame_size).
   2304   ASSERT_EQ(32 * 1024, kMaxReadBytesWithoutYielding);
   2305   const int kPayloadSize =
   2306       kMaxReadBytesWithoutYielding / 4 - framer.GetControlFrameHeaderSize();
   2307   TestDataStream test_stream;
   2308   scoped_refptr<net::IOBuffer> payload(new net::IOBuffer(kPayloadSize));
   2309   char* payload_data = payload->data();
   2310   test_stream.GetBytes(payload_data, kPayloadSize);
   2311 
   2312   scoped_ptr<SpdyFrame> partial_data_frame(
   2313       framer.CreateDataFrame(1, payload_data, kPayloadSize, DATA_FLAG_NONE));
   2314   scoped_ptr<SpdyFrame> finish_data_frame(
   2315       framer.CreateDataFrame(1, payload_data, kPayloadSize - 1, DATA_FLAG_FIN));
   2316 
   2317   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   2318 
   2319   // Write 1 byte less than kMaxReadBytes to check that DoRead reads up to 32k
   2320   // bytes.
   2321   MockRead reads[] = {
   2322     CreateMockRead(*resp1, 1),
   2323     CreateMockRead(*partial_data_frame, 2),
   2324     CreateMockRead(*partial_data_frame, 3, SYNCHRONOUS),
   2325     CreateMockRead(*partial_data_frame, 4, SYNCHRONOUS),
   2326     CreateMockRead(*finish_data_frame, 5, SYNCHRONOUS),
   2327     MockRead(ASYNC, 0, 6)  // EOF
   2328   };
   2329 
   2330   // Create SpdySession and SpdyStream and send the request.
   2331   DeterministicSocketData data(reads, arraysize(reads),
   2332                                writes, arraysize(writes));
   2333   data.set_connect_data(connect_data);
   2334   session_deps_.host_resolver->set_synchronous_mode(true);
   2335   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   2336 
   2337   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2338   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   2339 
   2340   CreateDeterministicNetworkSession();
   2341 
   2342   base::WeakPtr<SpdySession> session =
   2343       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   2344 
   2345   GURL url1("http://www.google.com");
   2346   base::WeakPtr<SpdyStream> spdy_stream1 =
   2347       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2348                                 session, url1, MEDIUM, BoundNetLog());
   2349   ASSERT_TRUE(spdy_stream1.get() != NULL);
   2350   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2351   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   2352   spdy_stream1->SetDelegate(&delegate1);
   2353 
   2354   scoped_ptr<SpdyHeaderBlock> headers1(
   2355       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   2356   spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   2357   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   2358 
   2359   // Set up the TaskObserver to verify SpdySession::DoReadLoop doesn't
   2360   // post a task.
   2361   SpdySessionTestTaskObserver observer("spdy_session.cc", "DoReadLoop");
   2362 
   2363   // Run until 1st read.
   2364   EXPECT_EQ(0u, delegate1.stream_id());
   2365   data.RunFor(2);
   2366   EXPECT_EQ(1u, delegate1.stream_id());
   2367   EXPECT_EQ(0u, observer.executed_count());
   2368 
   2369   // Read all the data and verify SpdySession::DoReadLoop has not
   2370   // posted a task.
   2371   data.RunFor(4);
   2372   EXPECT_EQ(NULL, spdy_stream1.get());
   2373 
   2374   // Verify task observer's executed_count is zero, which indicates DoRead read
   2375   // all the available data.
   2376   EXPECT_EQ(0u, observer.executed_count());
   2377   EXPECT_TRUE(data.at_write_eof());
   2378   EXPECT_TRUE(data.at_read_eof());
   2379 }
   2380 
   2381 // Test that SpdySession::DoReadLoop yields while reading the
   2382 // data. This test makes 32k + 1 bytes of data available on the socket
   2383 // for reading. It then verifies that DoRead has yielded even though
   2384 // there is data available for it to read (i.e, socket()->Read didn't
   2385 // return ERR_IO_PENDING during socket reads).
   2386 TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
   2387   MockConnect connect_data(SYNCHRONOUS, OK);
   2388   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   2389 
   2390   scoped_ptr<SpdyFrame> req1(
   2391       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   2392   MockWrite writes[] = {
   2393     CreateMockWrite(*req1, 0),
   2394   };
   2395 
   2396   // Build buffer of size kMaxReadBytesWithoutYielding / 4
   2397   // (-spdy_data_frame_size).
   2398   ASSERT_EQ(32 * 1024, kMaxReadBytesWithoutYielding);
   2399   const int kPayloadSize =
   2400       kMaxReadBytesWithoutYielding / 4 - framer.GetControlFrameHeaderSize();
   2401   TestDataStream test_stream;
   2402   scoped_refptr<net::IOBuffer> payload(new net::IOBuffer(kPayloadSize));
   2403   char* payload_data = payload->data();
   2404   test_stream.GetBytes(payload_data, kPayloadSize);
   2405 
   2406   scoped_ptr<SpdyFrame> partial_data_frame(
   2407       framer.CreateDataFrame(1, payload_data, kPayloadSize, DATA_FLAG_NONE));
   2408   scoped_ptr<SpdyFrame> finish_data_frame(
   2409       framer.CreateDataFrame(1, "h", 1, DATA_FLAG_FIN));
   2410 
   2411   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   2412 
   2413   // Write 1 byte more than kMaxReadBytes to check that DoRead yields.
   2414   MockRead reads[] = {
   2415     CreateMockRead(*resp1, 1),
   2416     CreateMockRead(*partial_data_frame, 2),
   2417     CreateMockRead(*partial_data_frame, 3, SYNCHRONOUS),
   2418     CreateMockRead(*partial_data_frame, 4, SYNCHRONOUS),
   2419     CreateMockRead(*partial_data_frame, 5, SYNCHRONOUS),
   2420     CreateMockRead(*finish_data_frame, 6, SYNCHRONOUS),
   2421     MockRead(ASYNC, 0, 7)  // EOF
   2422   };
   2423 
   2424   // Create SpdySession and SpdyStream and send the request.
   2425   DeterministicSocketData data(reads, arraysize(reads),
   2426                                writes, arraysize(writes));
   2427   data.set_connect_data(connect_data);
   2428   session_deps_.host_resolver->set_synchronous_mode(true);
   2429   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   2430 
   2431   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2432   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   2433 
   2434   CreateDeterministicNetworkSession();
   2435 
   2436   base::WeakPtr<SpdySession> session =
   2437       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   2438 
   2439   GURL url1("http://www.google.com");
   2440   base::WeakPtr<SpdyStream> spdy_stream1 =
   2441       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2442                                 session, url1, MEDIUM, BoundNetLog());
   2443   ASSERT_TRUE(spdy_stream1.get() != NULL);
   2444   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2445   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   2446   spdy_stream1->SetDelegate(&delegate1);
   2447 
   2448   scoped_ptr<SpdyHeaderBlock> headers1(
   2449       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   2450   spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   2451   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   2452 
   2453   // Set up the TaskObserver to verify SpdySession::DoReadLoop posts a
   2454   // task.
   2455   SpdySessionTestTaskObserver observer("spdy_session.cc", "DoReadLoop");
   2456 
   2457   // Run until 1st read.
   2458   EXPECT_EQ(0u, delegate1.stream_id());
   2459   data.RunFor(2);
   2460   EXPECT_EQ(1u, delegate1.stream_id());
   2461   EXPECT_EQ(0u, observer.executed_count());
   2462 
   2463   // Read all the data and verify SpdySession::DoReadLoop has posted a
   2464   // task.
   2465   data.RunFor(6);
   2466   EXPECT_EQ(NULL, spdy_stream1.get());
   2467 
   2468   // Verify task observer's executed_count is 1, which indicates DoRead has
   2469   // posted only one task and thus yielded though there is data available for it
   2470   // to read.
   2471   EXPECT_EQ(1u, observer.executed_count());
   2472   EXPECT_TRUE(data.at_write_eof());
   2473   EXPECT_TRUE(data.at_read_eof());
   2474 }
   2475 
   2476 // Test that SpdySession::DoReadLoop() tests interactions of yielding
   2477 // + async, by doing the following MockReads.
   2478 //
   2479 // MockRead of SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 2K
   2480 // ASYNC 8K, SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 2K.
   2481 //
   2482 // The above reads 26K synchronously. Since that is less that 32K, we
   2483 // will attempt to read again. However, that DoRead() will return
   2484 // ERR_IO_PENDING (because of async read), so DoReadLoop() will
   2485 // yield. When we come back, DoRead() will read the results from the
   2486 // async read, and rest of the data synchronously.
   2487 TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
   2488   MockConnect connect_data(SYNCHRONOUS, OK);
   2489   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   2490 
   2491   scoped_ptr<SpdyFrame> req1(
   2492       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   2493   MockWrite writes[] = {
   2494     CreateMockWrite(*req1, 0),
   2495   };
   2496 
   2497   // Build buffer of size kMaxReadBytesWithoutYielding / 4
   2498   // (-spdy_data_frame_size).
   2499   ASSERT_EQ(32 * 1024, kMaxReadBytesWithoutYielding);
   2500   TestDataStream test_stream;
   2501   const int kEightKPayloadSize =
   2502       kMaxReadBytesWithoutYielding / 4 - framer.GetControlFrameHeaderSize();
   2503   scoped_refptr<net::IOBuffer> eightk_payload(
   2504       new net::IOBuffer(kEightKPayloadSize));
   2505   char* eightk_payload_data = eightk_payload->data();
   2506   test_stream.GetBytes(eightk_payload_data, kEightKPayloadSize);
   2507 
   2508   // Build buffer of 2k size.
   2509   TestDataStream test_stream2;
   2510   const int kTwoKPayloadSize = kEightKPayloadSize - 6 * 1024;
   2511   scoped_refptr<net::IOBuffer> twok_payload(
   2512       new net::IOBuffer(kTwoKPayloadSize));
   2513   char* twok_payload_data = twok_payload->data();
   2514   test_stream2.GetBytes(twok_payload_data, kTwoKPayloadSize);
   2515 
   2516   scoped_ptr<SpdyFrame> eightk_data_frame(framer.CreateDataFrame(
   2517       1, eightk_payload_data, kEightKPayloadSize, DATA_FLAG_NONE));
   2518   scoped_ptr<SpdyFrame> twok_data_frame(framer.CreateDataFrame(
   2519       1, twok_payload_data, kTwoKPayloadSize, DATA_FLAG_NONE));
   2520   scoped_ptr<SpdyFrame> finish_data_frame(framer.CreateDataFrame(
   2521       1, "h", 1, DATA_FLAG_FIN));
   2522 
   2523   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   2524 
   2525   MockRead reads[] = {
   2526     CreateMockRead(*resp1, 1),
   2527     CreateMockRead(*eightk_data_frame, 2),
   2528     CreateMockRead(*eightk_data_frame, 3, SYNCHRONOUS),
   2529     CreateMockRead(*eightk_data_frame, 4, SYNCHRONOUS),
   2530     CreateMockRead(*twok_data_frame, 5, SYNCHRONOUS),
   2531     CreateMockRead(*eightk_data_frame, 6, ASYNC),
   2532     CreateMockRead(*eightk_data_frame, 7, SYNCHRONOUS),
   2533     CreateMockRead(*eightk_data_frame, 8, SYNCHRONOUS),
   2534     CreateMockRead(*eightk_data_frame, 9, SYNCHRONOUS),
   2535     CreateMockRead(*twok_data_frame, 10, SYNCHRONOUS),
   2536     CreateMockRead(*finish_data_frame, 11, SYNCHRONOUS),
   2537     MockRead(ASYNC, 0, 12)  // EOF
   2538   };
   2539 
   2540   // Create SpdySession and SpdyStream and send the request.
   2541   DeterministicSocketData data(reads, arraysize(reads),
   2542                                writes, arraysize(writes));
   2543   data.set_connect_data(connect_data);
   2544   session_deps_.host_resolver->set_synchronous_mode(true);
   2545   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   2546 
   2547   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2548   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   2549 
   2550   CreateDeterministicNetworkSession();
   2551 
   2552   base::WeakPtr<SpdySession> session =
   2553       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   2554 
   2555   GURL url1("http://www.google.com");
   2556   base::WeakPtr<SpdyStream> spdy_stream1 =
   2557       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2558                                 session, url1, MEDIUM, BoundNetLog());
   2559   ASSERT_TRUE(spdy_stream1.get() != NULL);
   2560   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2561   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   2562   spdy_stream1->SetDelegate(&delegate1);
   2563 
   2564   scoped_ptr<SpdyHeaderBlock> headers1(
   2565       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   2566   spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   2567   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   2568 
   2569   // Set up the TaskObserver to monitor SpdySession::DoReadLoop
   2570   // posting of tasks.
   2571   SpdySessionTestTaskObserver observer("spdy_session.cc", "DoReadLoop");
   2572 
   2573   // Run until 1st read.
   2574   EXPECT_EQ(0u, delegate1.stream_id());
   2575   data.RunFor(2);
   2576   EXPECT_EQ(1u, delegate1.stream_id());
   2577   EXPECT_EQ(0u, observer.executed_count());
   2578 
   2579   // Read all the data and verify SpdySession::DoReadLoop has posted a
   2580   // task.
   2581   data.RunFor(12);
   2582   EXPECT_EQ(NULL, spdy_stream1.get());
   2583 
   2584   // Verify task observer's executed_count is 1, which indicates DoRead has
   2585   // posted only one task and thus yielded though there is data available for
   2586   // it to read.
   2587   EXPECT_EQ(1u, observer.executed_count());
   2588   EXPECT_TRUE(data.at_write_eof());
   2589   EXPECT_TRUE(data.at_read_eof());
   2590 }
   2591 
   2592 // Send a GoAway frame when SpdySession is in DoReadLoop. Make sure
   2593 // nothing blows up.
   2594 TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
   2595   MockConnect connect_data(SYNCHRONOUS, OK);
   2596   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   2597 
   2598   scoped_ptr<SpdyFrame> req1(
   2599       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   2600   MockWrite writes[] = {
   2601     CreateMockWrite(*req1, 0),
   2602   };
   2603 
   2604   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   2605   scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
   2606   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
   2607 
   2608   MockRead reads[] = {
   2609     CreateMockRead(*resp1, 1),
   2610     CreateMockRead(*body1, 2),
   2611     CreateMockRead(*goaway, 3),
   2612   };
   2613 
   2614   // Create SpdySession and SpdyStream and send the request.
   2615   DeterministicSocketData data(reads, arraysize(reads),
   2616                                writes, arraysize(writes));
   2617   data.set_connect_data(connect_data);
   2618   session_deps_.host_resolver->set_synchronous_mode(true);
   2619   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   2620 
   2621   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   2622   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   2623 
   2624   CreateDeterministicNetworkSession();
   2625 
   2626   base::WeakPtr<SpdySession> session =
   2627       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   2628 
   2629   GURL url1("http://www.google.com");
   2630   base::WeakPtr<SpdyStream> spdy_stream1 =
   2631       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2632                                 session, url1, MEDIUM, BoundNetLog());
   2633   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   2634   spdy_stream1->SetDelegate(&delegate1);
   2635   ASSERT_TRUE(spdy_stream1.get() != NULL);
   2636   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2637 
   2638   scoped_ptr<SpdyHeaderBlock> headers1(
   2639       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   2640   spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   2641   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   2642 
   2643   // Run until 1st read.
   2644   EXPECT_EQ(0u, spdy_stream1->stream_id());
   2645   data.RunFor(1);
   2646   EXPECT_EQ(1u, spdy_stream1->stream_id());
   2647 
   2648   // Run until GoAway.
   2649   data.RunFor(3);
   2650   EXPECT_EQ(NULL, spdy_stream1.get());
   2651   EXPECT_TRUE(data.at_write_eof());
   2652   EXPECT_TRUE(data.at_read_eof());
   2653   EXPECT_TRUE(session == NULL);
   2654 }
   2655 
   2656 // Within this framework, a SpdySession should be initialized with
   2657 // flow control disabled for protocol version 2, with flow control
   2658 // enabled only for streams for protocol version 3, and with flow
   2659 // control enabled for streams and sessions for higher versions.
   2660 TEST_P(SpdySessionTest, ProtocolNegotiation) {
   2661   session_deps_.host_resolver->set_synchronous_mode(true);
   2662 
   2663   MockConnect connect_data(SYNCHRONOUS, OK);
   2664   MockRead reads[] = {
   2665     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   2666   };
   2667   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   2668   data.set_connect_data(connect_data);
   2669   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2670 
   2671   CreateNetworkSession();
   2672   base::WeakPtr<SpdySession> session =
   2673       CreateFakeSpdySession(spdy_session_pool_, key_);
   2674 
   2675   EXPECT_EQ(spdy_util_.spdy_version(),
   2676             session->buffered_spdy_framer_->protocol_version());
   2677   if (GetParam() == kProtoDeprecatedSPDY2) {
   2678     EXPECT_EQ(SpdySession::FLOW_CONTROL_NONE, session->flow_control_state());
   2679     EXPECT_EQ(0, session->session_send_window_size_);
   2680     EXPECT_EQ(0, session->session_recv_window_size_);
   2681   } else if (GetParam() == kProtoSPDY3) {
   2682     EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM, session->flow_control_state());
   2683     EXPECT_EQ(0, session->session_send_window_size_);
   2684     EXPECT_EQ(0, session->session_recv_window_size_);
   2685   } else {
   2686     EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   2687               session->flow_control_state());
   2688     EXPECT_EQ(kSpdySessionInitialWindowSize,
   2689               session->session_send_window_size_);
   2690     EXPECT_EQ(kSpdySessionInitialWindowSize,
   2691               session->session_recv_window_size_);
   2692   }
   2693   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   2694 }
   2695 
   2696 // Tests the case of a non-SPDY request closing an idle SPDY session when no
   2697 // pointers to the idle session are currently held.
   2698 TEST_P(SpdySessionTest, CloseOneIdleConnection) {
   2699   ClientSocketPoolManager::set_max_sockets_per_group(
   2700       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   2701   ClientSocketPoolManager::set_max_sockets_per_pool(
   2702       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   2703 
   2704   MockConnect connect_data(SYNCHRONOUS, OK);
   2705   MockRead reads[] = {
   2706     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   2707   };
   2708   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   2709   data.set_connect_data(connect_data);
   2710   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2711   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2712 
   2713   CreateNetworkSession();
   2714 
   2715   TransportClientSocketPool* pool =
   2716       http_session_->GetTransportSocketPool(
   2717           HttpNetworkSession::NORMAL_SOCKET_POOL);
   2718 
   2719   // Create an idle SPDY session.
   2720   SpdySessionKey key1(HostPortPair("1.com", 80), ProxyServer::Direct(),
   2721                       kPrivacyModeDisabled);
   2722   base::WeakPtr<SpdySession> session1 =
   2723       CreateInsecureSpdySession(http_session_, key1, BoundNetLog());
   2724   EXPECT_FALSE(pool->IsStalled());
   2725 
   2726   // Trying to create a new connection should cause the pool to be stalled, and
   2727   // post a task asynchronously to try and close the session.
   2728   TestCompletionCallback callback2;
   2729   HostPortPair host_port2("2.com", 80);
   2730   scoped_refptr<TransportSocketParams> params2(
   2731       new TransportSocketParams(host_port2, false, false,
   2732                                 OnHostResolutionCallback()));
   2733   scoped_ptr<ClientSocketHandle> connection2(new ClientSocketHandle);
   2734   EXPECT_EQ(ERR_IO_PENDING,
   2735             connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY,
   2736                               callback2.callback(), pool, BoundNetLog()));
   2737   EXPECT_TRUE(pool->IsStalled());
   2738 
   2739   // The socket pool should close the connection asynchronously and establish a
   2740   // new connection.
   2741   EXPECT_EQ(OK, callback2.WaitForResult());
   2742   EXPECT_FALSE(pool->IsStalled());
   2743   EXPECT_TRUE(session1 == NULL);
   2744 }
   2745 
   2746 // Tests the case of a non-SPDY request closing an idle SPDY session when no
   2747 // pointers to the idle session are currently held, in the case the SPDY session
   2748 // has an alias.
   2749 TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
   2750   ClientSocketPoolManager::set_max_sockets_per_group(
   2751       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   2752   ClientSocketPoolManager::set_max_sockets_per_pool(
   2753       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   2754 
   2755   MockConnect connect_data(SYNCHRONOUS, OK);
   2756   MockRead reads[] = {
   2757     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   2758   };
   2759   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   2760   data.set_connect_data(connect_data);
   2761   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2762   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2763 
   2764   session_deps_.host_resolver->set_synchronous_mode(true);
   2765   session_deps_.host_resolver->rules()->AddIPLiteralRule(
   2766       "1.com", "192.168.0.2", std::string());
   2767   session_deps_.host_resolver->rules()->AddIPLiteralRule(
   2768       "2.com", "192.168.0.2", std::string());
   2769   // Not strictly needed.
   2770   session_deps_.host_resolver->rules()->AddIPLiteralRule(
   2771       "3.com", "192.168.0.3", std::string());
   2772 
   2773   CreateNetworkSession();
   2774 
   2775   TransportClientSocketPool* pool =
   2776       http_session_->GetTransportSocketPool(
   2777           HttpNetworkSession::NORMAL_SOCKET_POOL);
   2778 
   2779   // Create an idle SPDY session.
   2780   SpdySessionKey key1(HostPortPair("1.com", 80), ProxyServer::Direct(),
   2781                       kPrivacyModeDisabled);
   2782   base::WeakPtr<SpdySession> session1 =
   2783       CreateInsecureSpdySession(http_session_, key1, BoundNetLog());
   2784   EXPECT_FALSE(pool->IsStalled());
   2785 
   2786   // Set up an alias for the idle SPDY session, increasing its ref count to 2.
   2787   SpdySessionKey key2(HostPortPair("2.com", 80), ProxyServer::Direct(),
   2788                       kPrivacyModeDisabled);
   2789   HostResolver::RequestInfo info(key2.host_port_pair());
   2790   AddressList addresses;
   2791   // Pre-populate the DNS cache, since a synchronous resolution is required in
   2792   // order to create the alias.
   2793   session_deps_.host_resolver->Resolve(info,
   2794                                        DEFAULT_PRIORITY,
   2795                                        &addresses,
   2796                                        CompletionCallback(),
   2797                                        NULL,
   2798                                        BoundNetLog());
   2799   // Get a session for |key2|, which should return the session created earlier.
   2800   base::WeakPtr<SpdySession> session2 =
   2801       spdy_session_pool_->FindAvailableSession(key2, BoundNetLog());
   2802   ASSERT_EQ(session1.get(), session2.get());
   2803   EXPECT_FALSE(pool->IsStalled());
   2804 
   2805   // Trying to create a new connection should cause the pool to be stalled, and
   2806   // post a task asynchronously to try and close the session.
   2807   TestCompletionCallback callback3;
   2808   HostPortPair host_port3("3.com", 80);
   2809   scoped_refptr<TransportSocketParams> params3(
   2810       new TransportSocketParams(host_port3, false, false,
   2811                                 OnHostResolutionCallback()));
   2812   scoped_ptr<ClientSocketHandle> connection3(new ClientSocketHandle);
   2813   EXPECT_EQ(ERR_IO_PENDING,
   2814             connection3->Init(host_port3.ToString(), params3, DEFAULT_PRIORITY,
   2815                               callback3.callback(), pool, BoundNetLog()));
   2816   EXPECT_TRUE(pool->IsStalled());
   2817 
   2818   // The socket pool should close the connection asynchronously and establish a
   2819   // new connection.
   2820   EXPECT_EQ(OK, callback3.WaitForResult());
   2821   EXPECT_FALSE(pool->IsStalled());
   2822   EXPECT_TRUE(session1 == NULL);
   2823   EXPECT_TRUE(session2 == NULL);
   2824 }
   2825 
   2826 // Tests that when a SPDY session becomes idle, it closes itself if there is
   2827 // a lower layer pool stalled on the per-pool socket limit.
   2828 TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
   2829   ClientSocketPoolManager::set_max_sockets_per_group(
   2830       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   2831   ClientSocketPoolManager::set_max_sockets_per_pool(
   2832       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   2833 
   2834   MockConnect connect_data(SYNCHRONOUS, OK);
   2835   MockRead reads[] = {
   2836     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   2837   };
   2838   scoped_ptr<SpdyFrame> req1(
   2839       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   2840   scoped_ptr<SpdyFrame> cancel1(
   2841       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   2842   MockWrite writes[] = {
   2843     CreateMockWrite(*req1, 1),
   2844     CreateMockWrite(*cancel1, 1),
   2845   };
   2846   StaticSocketDataProvider data(reads, arraysize(reads),
   2847                                 writes, arraysize(writes));
   2848   data.set_connect_data(connect_data);
   2849   session_deps_.socket_factory->AddSocketDataProvider(&data);
   2850 
   2851   MockRead http_reads[] = {
   2852     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   2853   };
   2854   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
   2855                                      NULL, 0);
   2856   http_data.set_connect_data(connect_data);
   2857   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
   2858 
   2859 
   2860   CreateNetworkSession();
   2861 
   2862   TransportClientSocketPool* pool =
   2863       http_session_->GetTransportSocketPool(
   2864           HttpNetworkSession::NORMAL_SOCKET_POOL);
   2865 
   2866   // Create a SPDY session.
   2867   GURL url1("http://www.google.com");
   2868   SpdySessionKey key1(HostPortPair(url1.host(), 80),
   2869                       ProxyServer::Direct(), kPrivacyModeDisabled);
   2870   base::WeakPtr<SpdySession> session1 =
   2871       CreateInsecureSpdySession(http_session_, key1, BoundNetLog());
   2872   EXPECT_FALSE(pool->IsStalled());
   2873 
   2874   // Create a stream using the session, and send a request.
   2875 
   2876   TestCompletionCallback callback1;
   2877   base::WeakPtr<SpdyStream> spdy_stream1 =
   2878       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2879                                 session1, url1, DEFAULT_PRIORITY,
   2880                                 BoundNetLog());
   2881   ASSERT_TRUE(spdy_stream1.get());
   2882   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   2883   spdy_stream1->SetDelegate(&delegate1);
   2884 
   2885   scoped_ptr<SpdyHeaderBlock> headers1(
   2886       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   2887   EXPECT_EQ(ERR_IO_PENDING,
   2888             spdy_stream1->SendRequestHeaders(
   2889                 headers1.Pass(), NO_MORE_DATA_TO_SEND));
   2890   EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
   2891 
   2892   base::MessageLoop::current()->RunUntilIdle();
   2893 
   2894   // Trying to create a new connection should cause the pool to be stalled, and
   2895   // post a task asynchronously to try and close the session.
   2896   TestCompletionCallback callback2;
   2897   HostPortPair host_port2("2.com", 80);
   2898   scoped_refptr<TransportSocketParams> params2(
   2899       new TransportSocketParams(host_port2, false, false,
   2900                                 OnHostResolutionCallback()));
   2901   scoped_ptr<ClientSocketHandle> connection2(new ClientSocketHandle);
   2902   EXPECT_EQ(ERR_IO_PENDING,
   2903             connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY,
   2904                               callback2.callback(), pool, BoundNetLog()));
   2905   EXPECT_TRUE(pool->IsStalled());
   2906 
   2907   // Running the message loop should cause the socket pool to ask the SPDY
   2908   // session to close an idle socket, but since the socket is in use, nothing
   2909   // happens.
   2910   base::RunLoop().RunUntilIdle();
   2911   EXPECT_TRUE(pool->IsStalled());
   2912   EXPECT_FALSE(callback2.have_result());
   2913 
   2914   // Cancelling the request should result in the session's socket being
   2915   // closed, since the pool is stalled.
   2916   ASSERT_TRUE(spdy_stream1.get());
   2917   spdy_stream1->Cancel();
   2918   base::RunLoop().RunUntilIdle();
   2919   ASSERT_FALSE(pool->IsStalled());
   2920   EXPECT_EQ(OK, callback2.WaitForResult());
   2921 }
   2922 
   2923 // Verify that SpdySessionKey and therefore SpdySession is different when
   2924 // privacy mode is enabled or disabled.
   2925 TEST_P(SpdySessionTest, SpdySessionKeyPrivacyMode) {
   2926   CreateDeterministicNetworkSession();
   2927 
   2928   HostPortPair host_port_pair("www.google.com", 443);
   2929   SpdySessionKey key_privacy_enabled(host_port_pair, ProxyServer::Direct(),
   2930                                      kPrivacyModeEnabled);
   2931   SpdySessionKey key_privacy_disabled(host_port_pair, ProxyServer::Direct(),
   2932                                      kPrivacyModeDisabled);
   2933 
   2934   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_enabled));
   2935   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_disabled));
   2936 
   2937   // Add SpdySession with PrivacyMode Enabled to the pool.
   2938   base::WeakPtr<SpdySession> session_privacy_enabled =
   2939       CreateFakeSpdySession(spdy_session_pool_, key_privacy_enabled);
   2940 
   2941   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_privacy_enabled));
   2942   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_disabled));
   2943 
   2944   // Add SpdySession with PrivacyMode Disabled to the pool.
   2945   base::WeakPtr<SpdySession> session_privacy_disabled =
   2946       CreateFakeSpdySession(spdy_session_pool_, key_privacy_disabled);
   2947 
   2948   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_privacy_enabled));
   2949   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_privacy_disabled));
   2950 
   2951   session_privacy_enabled->CloseSessionOnError(ERR_ABORTED, std::string());
   2952   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_enabled));
   2953   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_privacy_disabled));
   2954 
   2955   session_privacy_disabled->CloseSessionOnError(ERR_ABORTED, std::string());
   2956   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_enabled));
   2957   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_disabled));
   2958 }
   2959 
   2960 // Delegate that creates another stream when its stream is closed.
   2961 class StreamCreatingDelegate : public test::StreamDelegateDoNothing {
   2962  public:
   2963   StreamCreatingDelegate(const base::WeakPtr<SpdyStream>& stream,
   2964                          const base::WeakPtr<SpdySession>& session)
   2965       : StreamDelegateDoNothing(stream),
   2966         session_(session) {}
   2967 
   2968   virtual ~StreamCreatingDelegate() {}
   2969 
   2970   virtual void OnClose(int status) OVERRIDE {
   2971     GURL url("http://www.google.com");
   2972     ignore_result(
   2973         CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   2974                                   session_, url, MEDIUM, BoundNetLog()));
   2975   }
   2976 
   2977  private:
   2978   const base::WeakPtr<SpdySession> session_;
   2979 };
   2980 
   2981 // Create another stream in response to a stream being reset. Nothing
   2982 // should blow up. This is a regression test for
   2983 // http://crbug.com/263690 .
   2984 TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
   2985   session_deps_.host_resolver->set_synchronous_mode(true);
   2986 
   2987   MockConnect connect_data(SYNCHRONOUS, OK);
   2988 
   2989   scoped_ptr<SpdyFrame> req(
   2990       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   2991   MockWrite writes[] = {
   2992     CreateMockWrite(*req, 0),
   2993   };
   2994 
   2995   scoped_ptr<SpdyFrame> rst(
   2996       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM));
   2997   MockRead reads[] = {
   2998     CreateMockRead(*rst, 1),
   2999     MockRead(ASYNC, 0, 2)  // EOF
   3000   };
   3001   DeterministicSocketData data(reads, arraysize(reads),
   3002                                writes, arraysize(writes));
   3003   data.set_connect_data(connect_data);
   3004   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3005 
   3006   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3007   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   3008 
   3009   CreateDeterministicNetworkSession();
   3010 
   3011   base::WeakPtr<SpdySession> session =
   3012       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3013 
   3014   GURL url("http://www.google.com");
   3015   base::WeakPtr<SpdyStream> spdy_stream =
   3016       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3017                                 session, url, MEDIUM, BoundNetLog());
   3018   ASSERT_TRUE(spdy_stream.get() != NULL);
   3019   EXPECT_EQ(0u, spdy_stream->stream_id());
   3020 
   3021   StreamCreatingDelegate delegate(spdy_stream, session);
   3022   spdy_stream->SetDelegate(&delegate);
   3023 
   3024   scoped_ptr<SpdyHeaderBlock> headers(
   3025       spdy_util_.ConstructGetHeaderBlock(url.spec()));
   3026   spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   3027   EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
   3028 
   3029   EXPECT_EQ(0u, spdy_stream->stream_id());
   3030 
   3031   data.RunFor(1);
   3032 
   3033   EXPECT_EQ(1u, spdy_stream->stream_id());
   3034 
   3035   // Cause the stream to be reset, which should cause another stream
   3036   // to be created.
   3037   data.RunFor(1);
   3038 
   3039   EXPECT_EQ(NULL, spdy_stream.get());
   3040   EXPECT_TRUE(delegate.StreamIsClosed());
   3041   EXPECT_EQ(0u, session->num_active_streams());
   3042   EXPECT_EQ(1u, session->num_created_streams());
   3043 }
   3044 
   3045 // The tests below are only for SPDY/3 and above.
   3046 
   3047 TEST_P(SpdySessionTest, UpdateStreamsSendWindowSize) {
   3048   if (GetParam() < kProtoSPDY3)
   3049     return;
   3050 
   3051   // Set SETTINGS_INITIAL_WINDOW_SIZE to a small number so that WINDOW_UPDATE
   3052   // gets sent.
   3053   SettingsMap new_settings;
   3054   int32 window_size = 1;
   3055   new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
   3056       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, window_size);
   3057 
   3058   // Set up the socket so we read a SETTINGS frame that sets
   3059   // INITIAL_WINDOW_SIZE.
   3060   MockConnect connect_data(SYNCHRONOUS, OK);
   3061   scoped_ptr<SpdyFrame> settings_frame(
   3062       spdy_util_.ConstructSpdySettings(new_settings));
   3063   MockRead reads[] = {
   3064     CreateMockRead(*settings_frame, 0),
   3065     MockRead(ASYNC, 0, 1)  // EOF
   3066   };
   3067 
   3068   session_deps_.host_resolver->set_synchronous_mode(true);
   3069 
   3070   scoped_ptr<DeterministicSocketData> data(
   3071       new DeterministicSocketData(reads, arraysize(reads), NULL, 0));
   3072   data->set_connect_data(connect_data);
   3073   session_deps_.deterministic_socket_factory->AddSocketDataProvider(data.get());
   3074 
   3075   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3076   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   3077 
   3078   CreateDeterministicNetworkSession();
   3079 
   3080   base::WeakPtr<SpdySession> session =
   3081       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3082   base::WeakPtr<SpdyStream> spdy_stream1 =
   3083       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   3084                                 session, test_url_, MEDIUM, BoundNetLog());
   3085   ASSERT_TRUE(spdy_stream1.get() != NULL);
   3086   TestCompletionCallback callback1;
   3087   EXPECT_NE(spdy_stream1->send_window_size(), window_size);
   3088 
   3089   data->RunFor(1);  // Process the SETTINGS frame, but not the EOF
   3090   base::MessageLoop::current()->RunUntilIdle();
   3091   EXPECT_EQ(session->stream_initial_send_window_size(), window_size);
   3092   EXPECT_EQ(spdy_stream1->send_window_size(), window_size);
   3093 
   3094   // Release the first one, this will allow the second to be created.
   3095   spdy_stream1->Cancel();
   3096   EXPECT_EQ(NULL, spdy_stream1.get());
   3097 
   3098   base::WeakPtr<SpdyStream> spdy_stream2 =
   3099       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   3100                                 session, test_url_, MEDIUM, BoundNetLog());
   3101   ASSERT_TRUE(spdy_stream2.get() != NULL);
   3102   EXPECT_EQ(spdy_stream2->send_window_size(), window_size);
   3103   spdy_stream2->Cancel();
   3104   EXPECT_EQ(NULL, spdy_stream2.get());
   3105 }
   3106 
   3107 // The tests below are only for SPDY/3.1 and above.
   3108 
   3109 // SpdySession::{Increase,Decrease}RecvWindowSize should properly
   3110 // adjust the session receive window size for SPDY 3.1 and higher. In
   3111 // addition, SpdySession::IncreaseRecvWindowSize should trigger
   3112 // sending a WINDOW_UPDATE frame for a large enough delta.
   3113 TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
   3114   if (GetParam() < kProtoSPDY31)
   3115     return;
   3116 
   3117   session_deps_.host_resolver->set_synchronous_mode(true);
   3118 
   3119   const int32 delta_window_size = 100;
   3120 
   3121   MockConnect connect_data(SYNCHRONOUS, OK);
   3122   MockRead reads[] = {
   3123     MockRead(ASYNC, 0, 1)  // EOF
   3124   };
   3125   scoped_ptr<SpdyFrame> window_update(
   3126       spdy_util_.ConstructSpdyWindowUpdate(
   3127           kSessionFlowControlStreamId,
   3128           kSpdySessionInitialWindowSize + delta_window_size));
   3129   MockWrite writes[] = {
   3130     CreateMockWrite(*window_update, 0),
   3131   };
   3132   DeterministicSocketData data(reads, arraysize(reads),
   3133                                writes, arraysize(writes));
   3134   data.set_connect_data(connect_data);
   3135   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3136 
   3137   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3138   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   3139 
   3140   CreateDeterministicNetworkSession();
   3141   base::WeakPtr<SpdySession> session =
   3142       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3143   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   3144             session->flow_control_state());
   3145 
   3146   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3147   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3148 
   3149   session->IncreaseRecvWindowSize(delta_window_size);
   3150   EXPECT_EQ(kSpdySessionInitialWindowSize + delta_window_size,
   3151             session->session_recv_window_size_);
   3152   EXPECT_EQ(delta_window_size, session->session_unacked_recv_window_bytes_);
   3153 
   3154   // Should trigger sending a WINDOW_UPDATE frame.
   3155   session->IncreaseRecvWindowSize(kSpdySessionInitialWindowSize);
   3156   EXPECT_EQ(kSpdySessionInitialWindowSize + delta_window_size +
   3157             kSpdySessionInitialWindowSize,
   3158             session->session_recv_window_size_);
   3159   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3160 
   3161   data.RunFor(1);
   3162 
   3163   // DecreaseRecvWindowSize() expects |in_io_loop_| to be true.
   3164   session->in_io_loop_ = true;
   3165   session->DecreaseRecvWindowSize(
   3166       kSpdySessionInitialWindowSize + delta_window_size +
   3167       kSpdySessionInitialWindowSize);
   3168   session->in_io_loop_ = false;
   3169   EXPECT_EQ(0, session->session_recv_window_size_);
   3170   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3171 }
   3172 
   3173 // SpdySession::{Increase,Decrease}SendWindowSize should properly
   3174 // adjust the session send window size when the "enable_spdy_31" flag
   3175 // is set.
   3176 TEST_P(SpdySessionTest, AdjustSendWindowSize) {
   3177   if (GetParam() < kProtoSPDY31)
   3178     return;
   3179 
   3180   session_deps_.host_resolver->set_synchronous_mode(true);
   3181 
   3182   MockConnect connect_data(SYNCHRONOUS, OK);
   3183   MockRead reads[] = {
   3184     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   3185   };
   3186   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   3187   data.set_connect_data(connect_data);
   3188   session_deps_.socket_factory->AddSocketDataProvider(&data);
   3189 
   3190   CreateNetworkSession();
   3191   base::WeakPtr<SpdySession> session =
   3192       CreateFakeSpdySession(spdy_session_pool_, key_);
   3193   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   3194             session->flow_control_state());
   3195 
   3196   const int32 delta_window_size = 100;
   3197 
   3198   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3199 
   3200   session->IncreaseSendWindowSize(delta_window_size);
   3201   EXPECT_EQ(kSpdySessionInitialWindowSize + delta_window_size,
   3202             session->session_send_window_size_);
   3203 
   3204   session->DecreaseSendWindowSize(delta_window_size);
   3205   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3206 }
   3207 
   3208 // Incoming data for an inactive stream should not cause the session
   3209 // receive window size to decrease, but it should cause the unacked
   3210 // bytes to increase.
   3211 TEST_P(SpdySessionTest, SessionFlowControlInactiveStream) {
   3212   if (GetParam() < kProtoSPDY31)
   3213     return;
   3214 
   3215   session_deps_.host_resolver->set_synchronous_mode(true);
   3216 
   3217   MockConnect connect_data(SYNCHRONOUS, OK);
   3218   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyBodyFrame(1, false));
   3219   MockRead reads[] = {
   3220     CreateMockRead(*resp, 0),
   3221     MockRead(ASYNC, 0, 1)  // EOF
   3222   };
   3223   DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
   3224   data.set_connect_data(connect_data);
   3225   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3226 
   3227   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3228   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   3229 
   3230   CreateDeterministicNetworkSession();
   3231   base::WeakPtr<SpdySession> session =
   3232       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3233   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   3234             session->flow_control_state());
   3235 
   3236   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3237   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3238 
   3239   data.RunFor(1);
   3240 
   3241   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3242   EXPECT_EQ(kUploadDataSize, session->session_unacked_recv_window_bytes_);
   3243 
   3244   data.RunFor(1);
   3245 }
   3246 
   3247 // A delegate that drops any received data.
   3248 class DropReceivedDataDelegate : public test::StreamDelegateSendImmediate {
   3249  public:
   3250   DropReceivedDataDelegate(const base::WeakPtr<SpdyStream>& stream,
   3251                            base::StringPiece data)
   3252       : StreamDelegateSendImmediate(stream, data) {}
   3253 
   3254   virtual ~DropReceivedDataDelegate() {}
   3255 
   3256   // Drop any received data.
   3257   virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE {}
   3258 };
   3259 
   3260 // Send data back and forth but use a delegate that drops its received
   3261 // data. The receive window should still increase to its original
   3262 // value, i.e. we shouldn't "leak" receive window bytes.
   3263 TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
   3264   if (GetParam() < kProtoSPDY31)
   3265     return;
   3266 
   3267   const char kStreamUrl[] = "http://www.google.com/";
   3268 
   3269   const int32 msg_data_size = 100;
   3270   const std::string msg_data(msg_data_size, 'a');
   3271 
   3272   MockConnect connect_data(SYNCHRONOUS, OK);
   3273 
   3274   scoped_ptr<SpdyFrame> req(
   3275       spdy_util_.ConstructSpdyPost(
   3276           kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
   3277   scoped_ptr<SpdyFrame> msg(
   3278       spdy_util_.ConstructSpdyBodyFrame(
   3279           1, msg_data.data(), msg_data_size, false));
   3280   MockWrite writes[] = {
   3281     CreateMockWrite(*req, 0),
   3282     CreateMockWrite(*msg, 2),
   3283   };
   3284 
   3285   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   3286   scoped_ptr<SpdyFrame> echo(
   3287       spdy_util_.ConstructSpdyBodyFrame(
   3288           1, msg_data.data(), msg_data_size, false));
   3289   scoped_ptr<SpdyFrame> window_update(
   3290       spdy_util_.ConstructSpdyWindowUpdate(
   3291           kSessionFlowControlStreamId, msg_data_size));
   3292   MockRead reads[] = {
   3293     CreateMockRead(*resp, 1),
   3294     CreateMockRead(*echo, 3),
   3295     MockRead(ASYNC, 0, 4)  // EOF
   3296   };
   3297 
   3298   // Create SpdySession and SpdyStream and send the request.
   3299   DeterministicSocketData data(reads, arraysize(reads),
   3300                                writes, arraysize(writes));
   3301   data.set_connect_data(connect_data);
   3302   session_deps_.host_resolver->set_synchronous_mode(true);
   3303   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3304 
   3305   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3306   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   3307 
   3308   CreateDeterministicNetworkSession();
   3309 
   3310   base::WeakPtr<SpdySession> session =
   3311       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3312 
   3313   GURL url(kStreamUrl);
   3314   base::WeakPtr<SpdyStream> stream =
   3315       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   3316                                 session, url, MEDIUM, BoundNetLog());
   3317   ASSERT_TRUE(stream.get() != NULL);
   3318   EXPECT_EQ(0u, stream->stream_id());
   3319 
   3320   DropReceivedDataDelegate delegate(stream, msg_data);
   3321   stream->SetDelegate(&delegate);
   3322 
   3323   scoped_ptr<SpdyHeaderBlock> headers(
   3324       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
   3325   EXPECT_EQ(ERR_IO_PENDING,
   3326             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   3327   EXPECT_TRUE(stream->HasUrlFromHeaders());
   3328 
   3329   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3330   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3331 
   3332   data.RunFor(4);
   3333 
   3334   EXPECT_TRUE(data.at_write_eof());
   3335   EXPECT_TRUE(data.at_read_eof());
   3336 
   3337   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3338   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
   3339 
   3340   stream->Close();
   3341   EXPECT_EQ(NULL, stream.get());
   3342 
   3343   EXPECT_EQ(OK, delegate.WaitForClose());
   3344 
   3345   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3346   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
   3347 }
   3348 
   3349 // Send data back and forth but close the stream before its data frame
   3350 // can be written to the socket. The send window should then increase
   3351 // to its original value, i.e. we shouldn't "leak" send window bytes.
   3352 TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
   3353   if (GetParam() < kProtoSPDY31)
   3354     return;
   3355 
   3356   const char kStreamUrl[] = "http://www.google.com/";
   3357 
   3358   const int32 msg_data_size = 100;
   3359   const std::string msg_data(msg_data_size, 'a');
   3360 
   3361   MockConnect connect_data(SYNCHRONOUS, OK);
   3362 
   3363   scoped_ptr<SpdyFrame> req(
   3364       spdy_util_.ConstructSpdyPost(
   3365           kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
   3366   MockWrite writes[] = {
   3367     CreateMockWrite(*req, 0),
   3368   };
   3369 
   3370   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   3371   MockRead reads[] = {
   3372     CreateMockRead(*resp, 1),
   3373     MockRead(ASYNC, 0, 2)  // EOF
   3374   };
   3375 
   3376   // Create SpdySession and SpdyStream and send the request.
   3377   DeterministicSocketData data(reads, arraysize(reads),
   3378                                writes, arraysize(writes));
   3379   data.set_connect_data(connect_data);
   3380   session_deps_.host_resolver->set_synchronous_mode(true);
   3381   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3382 
   3383   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3384   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   3385 
   3386   CreateDeterministicNetworkSession();
   3387 
   3388   base::WeakPtr<SpdySession> session =
   3389       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3390 
   3391   GURL url(kStreamUrl);
   3392   base::WeakPtr<SpdyStream> stream =
   3393       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   3394                                 session, url, MEDIUM, BoundNetLog());
   3395   ASSERT_TRUE(stream.get() != NULL);
   3396   EXPECT_EQ(0u, stream->stream_id());
   3397 
   3398   test::StreamDelegateSendImmediate delegate(stream, msg_data);
   3399   stream->SetDelegate(&delegate);
   3400 
   3401   scoped_ptr<SpdyHeaderBlock> headers(
   3402       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
   3403   EXPECT_EQ(ERR_IO_PENDING,
   3404             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   3405   EXPECT_TRUE(stream->HasUrlFromHeaders());
   3406 
   3407   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3408 
   3409   data.RunFor(1);
   3410 
   3411   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3412 
   3413   data.RunFor(1);
   3414 
   3415   EXPECT_TRUE(data.at_write_eof());
   3416   EXPECT_TRUE(data.at_read_eof());
   3417 
   3418   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
   3419             session->session_send_window_size_);
   3420 
   3421   // Closing the stream should increase the session's send window.
   3422   stream->Close();
   3423   EXPECT_EQ(NULL, stream.get());
   3424 
   3425   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3426 
   3427   EXPECT_EQ(OK, delegate.WaitForClose());
   3428 }
   3429 
   3430 // Send data back and forth; the send and receive windows should
   3431 // change appropriately.
   3432 TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
   3433   if (GetParam() < kProtoSPDY31)
   3434     return;
   3435 
   3436   const char kStreamUrl[] = "http://www.google.com/";
   3437 
   3438   const int32 msg_data_size = 100;
   3439   const std::string msg_data(msg_data_size, 'a');
   3440 
   3441   MockConnect connect_data(SYNCHRONOUS, OK);
   3442 
   3443   scoped_ptr<SpdyFrame> req(
   3444       spdy_util_.ConstructSpdyPost(
   3445           kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
   3446   scoped_ptr<SpdyFrame> msg(
   3447       spdy_util_.ConstructSpdyBodyFrame(
   3448           1, msg_data.data(), msg_data_size, false));
   3449   MockWrite writes[] = {
   3450     CreateMockWrite(*req, 0),
   3451     CreateMockWrite(*msg, 2),
   3452   };
   3453 
   3454   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   3455   scoped_ptr<SpdyFrame> echo(
   3456       spdy_util_.ConstructSpdyBodyFrame(
   3457           1, msg_data.data(), msg_data_size, false));
   3458   scoped_ptr<SpdyFrame> window_update(
   3459       spdy_util_.ConstructSpdyWindowUpdate(
   3460           kSessionFlowControlStreamId, msg_data_size));
   3461   MockRead reads[] = {
   3462     CreateMockRead(*resp, 1),
   3463     CreateMockRead(*echo, 3),
   3464     CreateMockRead(*window_update, 4),
   3465     MockRead(ASYNC, 0, 5)  // EOF
   3466   };
   3467 
   3468   // Create SpdySession and SpdyStream and send the request.
   3469   DeterministicSocketData data(reads, arraysize(reads),
   3470                                writes, arraysize(writes));
   3471   data.set_connect_data(connect_data);
   3472   session_deps_.host_resolver->set_synchronous_mode(true);
   3473   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3474 
   3475   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   3476   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   3477 
   3478   CreateDeterministicNetworkSession();
   3479 
   3480   base::WeakPtr<SpdySession> session =
   3481       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3482 
   3483   GURL url(kStreamUrl);
   3484   base::WeakPtr<SpdyStream> stream =
   3485       CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
   3486                                 session, url, MEDIUM, BoundNetLog());
   3487   ASSERT_TRUE(stream.get() != NULL);
   3488   EXPECT_EQ(0u, stream->stream_id());
   3489 
   3490   test::StreamDelegateSendImmediate delegate(stream, msg_data);
   3491   stream->SetDelegate(&delegate);
   3492 
   3493   scoped_ptr<SpdyHeaderBlock> headers(
   3494       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
   3495   EXPECT_EQ(ERR_IO_PENDING,
   3496             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   3497   EXPECT_TRUE(stream->HasUrlFromHeaders());
   3498 
   3499   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3500   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3501   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3502 
   3503   data.RunFor(1);
   3504 
   3505   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3506   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3507   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3508 
   3509   data.RunFor(1);
   3510 
   3511   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
   3512             session->session_send_window_size_);
   3513   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3514   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3515 
   3516   data.RunFor(1);
   3517 
   3518   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
   3519             session->session_send_window_size_);
   3520   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3521   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3522 
   3523   data.RunFor(1);
   3524 
   3525   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
   3526             session->session_send_window_size_);
   3527   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
   3528             session->session_recv_window_size_);
   3529   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3530 
   3531   data.RunFor(1);
   3532 
   3533   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3534   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
   3535             session->session_recv_window_size_);
   3536   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
   3537 
   3538   EXPECT_TRUE(data.at_write_eof());
   3539   EXPECT_TRUE(data.at_read_eof());
   3540 
   3541   EXPECT_EQ(msg_data, delegate.TakeReceivedData());
   3542 
   3543   // Draining the delegate's read queue should increase the session's
   3544   // receive window.
   3545   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3546   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3547   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
   3548 
   3549   stream->Close();
   3550   EXPECT_EQ(NULL, stream.get());
   3551 
   3552   EXPECT_EQ(OK, delegate.WaitForClose());
   3553 
   3554   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   3555   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   3556   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
   3557 }
   3558 
   3559 // Given a stall function and an unstall function, runs a test to make
   3560 // sure that a stream resumes after unstall.
   3561 void SpdySessionTest::RunResumeAfterUnstallTest(
   3562     const base::Callback<void(SpdySession*, SpdyStream*)>& stall_function,
   3563     const base::Callback<void(SpdySession*, SpdyStream*, int32)>&
   3564         unstall_function) {
   3565   const char kStreamUrl[] = "http://www.google.com/";
   3566   GURL url(kStreamUrl);
   3567 
   3568   session_deps_.host_resolver->set_synchronous_mode(true);
   3569 
   3570   scoped_ptr<SpdyFrame> req(
   3571       spdy_util_.ConstructSpdyPost(
   3572           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   3573   scoped_ptr<SpdyFrame> body(
   3574       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
   3575   MockWrite writes[] = {
   3576     CreateMockWrite(*req, 0),
   3577     CreateMockWrite(*body, 1),
   3578   };
   3579 
   3580   scoped_ptr<SpdyFrame> resp(
   3581       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   3582   scoped_ptr<SpdyFrame> echo(
   3583       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
   3584   MockRead reads[] = {
   3585     CreateMockRead(*resp, 2),
   3586     MockRead(ASYNC, 0, 0, 3), // EOF
   3587   };
   3588 
   3589   DeterministicSocketData data(reads, arraysize(reads),
   3590                                writes, arraysize(writes));
   3591   MockConnect connect_data(SYNCHRONOUS, OK);
   3592   data.set_connect_data(connect_data);
   3593 
   3594   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3595 
   3596   CreateDeterministicNetworkSession();
   3597   base::WeakPtr<SpdySession> session =
   3598       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3599   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   3600             session->flow_control_state());
   3601 
   3602   base::WeakPtr<SpdyStream> stream =
   3603       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3604                                 session, url, LOWEST, BoundNetLog());
   3605   ASSERT_TRUE(stream.get() != NULL);
   3606 
   3607   test::StreamDelegateWithBody delegate(stream, kBodyDataStringPiece);
   3608   stream->SetDelegate(&delegate);
   3609 
   3610   EXPECT_FALSE(stream->HasUrlFromHeaders());
   3611   EXPECT_FALSE(stream->send_stalled_by_flow_control());
   3612 
   3613   scoped_ptr<SpdyHeaderBlock> headers(
   3614       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   3615   EXPECT_EQ(ERR_IO_PENDING,
   3616             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   3617   EXPECT_TRUE(stream->HasUrlFromHeaders());
   3618   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
   3619 
   3620   stall_function.Run(session.get(), stream.get());
   3621 
   3622   data.RunFor(1);
   3623 
   3624   EXPECT_TRUE(stream->send_stalled_by_flow_control());
   3625 
   3626   unstall_function.Run(session.get(), stream.get(), kBodyDataSize);
   3627 
   3628   EXPECT_FALSE(stream->send_stalled_by_flow_control());
   3629 
   3630   data.RunFor(3);
   3631 
   3632   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
   3633 
   3634   EXPECT_TRUE(delegate.send_headers_completed());
   3635   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   3636   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
   3637   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
   3638   EXPECT_TRUE(data.at_write_eof());
   3639 }
   3640 
   3641 // Run the resume-after-unstall test with all possible stall and
   3642 // unstall sequences.
   3643 
   3644 TEST_P(SpdySessionTest, ResumeAfterUnstallSession) {
   3645   if (GetParam() < kProtoSPDY31)
   3646     return;
   3647 
   3648   RunResumeAfterUnstallTest(
   3649       base::Bind(&SpdySessionTest::StallSessionOnly,
   3650                  base::Unretained(this)),
   3651       base::Bind(&SpdySessionTest::UnstallSessionOnly,
   3652                  base::Unretained(this)));
   3653 }
   3654 
   3655 // Equivalent to
   3656 // SpdyStreamTest.ResumeAfterSendWindowSizeIncrease.
   3657 TEST_P(SpdySessionTest, ResumeAfterUnstallStream) {
   3658   if (GetParam() < kProtoSPDY31)
   3659     return;
   3660 
   3661   RunResumeAfterUnstallTest(
   3662       base::Bind(&SpdySessionTest::StallStreamOnly,
   3663                  base::Unretained(this)),
   3664       base::Bind(&SpdySessionTest::UnstallStreamOnly,
   3665                  base::Unretained(this)));
   3666 }
   3667 
   3668 TEST_P(SpdySessionTest, StallSessionStreamResumeAfterUnstallSessionStream) {
   3669   if (GetParam() < kProtoSPDY31)
   3670     return;
   3671 
   3672   RunResumeAfterUnstallTest(
   3673       base::Bind(&SpdySessionTest::StallSessionStream,
   3674                  base::Unretained(this)),
   3675       base::Bind(&SpdySessionTest::UnstallSessionStream,
   3676                  base::Unretained(this)));
   3677 }
   3678 
   3679 TEST_P(SpdySessionTest, StallStreamSessionResumeAfterUnstallSessionStream) {
   3680   if (GetParam() < kProtoSPDY31)
   3681     return;
   3682 
   3683   RunResumeAfterUnstallTest(
   3684       base::Bind(&SpdySessionTest::StallStreamSession,
   3685                  base::Unretained(this)),
   3686       base::Bind(&SpdySessionTest::UnstallSessionStream,
   3687                  base::Unretained(this)));
   3688 }
   3689 
   3690 TEST_P(SpdySessionTest, StallStreamSessionResumeAfterUnstallStreamSession) {
   3691   if (GetParam() < kProtoSPDY31)
   3692     return;
   3693 
   3694   RunResumeAfterUnstallTest(
   3695       base::Bind(&SpdySessionTest::StallStreamSession,
   3696                  base::Unretained(this)),
   3697       base::Bind(&SpdySessionTest::UnstallStreamSession,
   3698                  base::Unretained(this)));
   3699 }
   3700 
   3701 TEST_P(SpdySessionTest, StallSessionStreamResumeAfterUnstallStreamSession) {
   3702   if (GetParam() < kProtoSPDY31)
   3703     return;
   3704 
   3705   RunResumeAfterUnstallTest(
   3706       base::Bind(&SpdySessionTest::StallSessionStream,
   3707                  base::Unretained(this)),
   3708       base::Bind(&SpdySessionTest::UnstallStreamSession,
   3709                  base::Unretained(this)));
   3710 }
   3711 
   3712 // Cause a stall by reducing the flow control send window to 0. The
   3713 // streams should resume in priority order when that window is then
   3714 // increased.
   3715 TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
   3716   if (GetParam() < kProtoSPDY31)
   3717     return;
   3718 
   3719   const char kStreamUrl[] = "http://www.google.com/";
   3720   GURL url(kStreamUrl);
   3721 
   3722   session_deps_.host_resolver->set_synchronous_mode(true);
   3723 
   3724   scoped_ptr<SpdyFrame> req1(
   3725       spdy_util_.ConstructSpdyPost(
   3726           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   3727   scoped_ptr<SpdyFrame> req2(
   3728       spdy_util_.ConstructSpdyPost(
   3729           kStreamUrl, 3, kBodyDataSize, MEDIUM, NULL, 0));
   3730   scoped_ptr<SpdyFrame> body1(
   3731       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
   3732   scoped_ptr<SpdyFrame> body2(
   3733       spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
   3734   MockWrite writes[] = {
   3735     CreateMockWrite(*req1, 0),
   3736     CreateMockWrite(*req2, 1),
   3737     CreateMockWrite(*body2, 2),
   3738     CreateMockWrite(*body1, 3),
   3739   };
   3740 
   3741   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   3742   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   3743   MockRead reads[] = {
   3744     CreateMockRead(*resp1, 4),
   3745     CreateMockRead(*resp2, 5),
   3746     MockRead(ASYNC, 0, 0, 6), // EOF
   3747   };
   3748 
   3749   DeterministicSocketData data(reads, arraysize(reads),
   3750                                writes, arraysize(writes));
   3751   MockConnect connect_data(SYNCHRONOUS, OK);
   3752   data.set_connect_data(connect_data);
   3753 
   3754   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3755 
   3756   CreateDeterministicNetworkSession();
   3757   base::WeakPtr<SpdySession> session =
   3758       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3759   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   3760             session->flow_control_state());
   3761 
   3762   base::WeakPtr<SpdyStream> stream1 =
   3763       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3764                                 session, url, LOWEST, BoundNetLog());
   3765   ASSERT_TRUE(stream1.get() != NULL);
   3766 
   3767   test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
   3768   stream1->SetDelegate(&delegate1);
   3769 
   3770   EXPECT_FALSE(stream1->HasUrlFromHeaders());
   3771 
   3772   base::WeakPtr<SpdyStream> stream2 =
   3773       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3774                                 session, url, MEDIUM, BoundNetLog());
   3775   ASSERT_TRUE(stream2.get() != NULL);
   3776 
   3777   test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
   3778   stream2->SetDelegate(&delegate2);
   3779 
   3780   EXPECT_FALSE(stream2->HasUrlFromHeaders());
   3781 
   3782   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   3783   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   3784 
   3785   StallSessionSend(session.get());
   3786 
   3787   scoped_ptr<SpdyHeaderBlock> headers1(
   3788       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   3789   EXPECT_EQ(ERR_IO_PENDING,
   3790             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   3791   EXPECT_TRUE(stream1->HasUrlFromHeaders());
   3792   EXPECT_EQ(kStreamUrl, stream1->GetUrlFromHeaders().spec());
   3793 
   3794   data.RunFor(1);
   3795   EXPECT_EQ(1u, stream1->stream_id());
   3796   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   3797 
   3798   scoped_ptr<SpdyHeaderBlock> headers2(
   3799       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   3800   EXPECT_EQ(ERR_IO_PENDING,
   3801             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   3802   EXPECT_TRUE(stream2->HasUrlFromHeaders());
   3803   EXPECT_EQ(kStreamUrl, stream2->GetUrlFromHeaders().spec());
   3804 
   3805   data.RunFor(1);
   3806   EXPECT_EQ(3u, stream2->stream_id());
   3807   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
   3808 
   3809   // This should unstall only stream2.
   3810   UnstallSessionSend(session.get(), kBodyDataSize);
   3811 
   3812   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   3813   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   3814 
   3815   data.RunFor(1);
   3816 
   3817   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   3818   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   3819 
   3820   // This should then unstall stream1.
   3821   UnstallSessionSend(session.get(), kBodyDataSize);
   3822 
   3823   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   3824   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   3825 
   3826   data.RunFor(4);
   3827 
   3828   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   3829   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
   3830 
   3831   EXPECT_TRUE(delegate1.send_headers_completed());
   3832   EXPECT_EQ("200", delegate1.GetResponseHeaderValue(":status"));
   3833   EXPECT_EQ("HTTP/1.1", delegate1.GetResponseHeaderValue(":version"));
   3834   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
   3835 
   3836   EXPECT_TRUE(delegate2.send_headers_completed());
   3837   EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
   3838   EXPECT_EQ("HTTP/1.1", delegate2.GetResponseHeaderValue(":version"));
   3839   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
   3840 
   3841   EXPECT_TRUE(data.at_write_eof());
   3842 }
   3843 
   3844 // Delegate that closes a given stream after sending its body.
   3845 class StreamClosingDelegate : public test::StreamDelegateWithBody {
   3846  public:
   3847   StreamClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
   3848                         base::StringPiece data)
   3849       : StreamDelegateWithBody(stream, data) {}
   3850 
   3851   virtual ~StreamClosingDelegate() {}
   3852 
   3853   void set_stream_to_close(const base::WeakPtr<SpdyStream>& stream_to_close) {
   3854     stream_to_close_ = stream_to_close;
   3855   }
   3856 
   3857   virtual void OnDataSent() OVERRIDE {
   3858     test::StreamDelegateWithBody::OnDataSent();
   3859     if (stream_to_close_.get()) {
   3860       stream_to_close_->Close();
   3861       EXPECT_EQ(NULL, stream_to_close_.get());
   3862     }
   3863   }
   3864 
   3865  private:
   3866   base::WeakPtr<SpdyStream> stream_to_close_;
   3867 };
   3868 
   3869 // Cause a stall by reducing the flow control send window to
   3870 // 0. Unstalling the session should properly handle deleted streams.
   3871 TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
   3872   if (GetParam() < kProtoSPDY31)
   3873     return;
   3874 
   3875   const char kStreamUrl[] = "http://www.google.com/";
   3876   GURL url(kStreamUrl);
   3877 
   3878   session_deps_.host_resolver->set_synchronous_mode(true);
   3879 
   3880   scoped_ptr<SpdyFrame> req1(
   3881       spdy_util_.ConstructSpdyPost(
   3882           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   3883   scoped_ptr<SpdyFrame> req2(
   3884       spdy_util_.ConstructSpdyPost(
   3885           kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
   3886   scoped_ptr<SpdyFrame> req3(
   3887       spdy_util_.ConstructSpdyPost(
   3888           kStreamUrl, 5, kBodyDataSize, LOWEST, NULL, 0));
   3889   scoped_ptr<SpdyFrame> body2(
   3890       spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
   3891   MockWrite writes[] = {
   3892     CreateMockWrite(*req1, 0),
   3893     CreateMockWrite(*req2, 1),
   3894     CreateMockWrite(*req3, 2),
   3895     CreateMockWrite(*body2, 3),
   3896   };
   3897 
   3898   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   3899   MockRead reads[] = {
   3900     CreateMockRead(*resp2, 4),
   3901     MockRead(ASYNC, 0, 0, 5), // EOF
   3902   };
   3903 
   3904   DeterministicSocketData data(reads, arraysize(reads),
   3905                                writes, arraysize(writes));
   3906   MockConnect connect_data(SYNCHRONOUS, OK);
   3907   data.set_connect_data(connect_data);
   3908 
   3909   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   3910 
   3911   CreateDeterministicNetworkSession();
   3912   base::WeakPtr<SpdySession> session =
   3913       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   3914   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   3915             session->flow_control_state());
   3916 
   3917   base::WeakPtr<SpdyStream> stream1 =
   3918       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3919                                 session, url, LOWEST, BoundNetLog());
   3920   ASSERT_TRUE(stream1.get() != NULL);
   3921 
   3922   test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
   3923   stream1->SetDelegate(&delegate1);
   3924 
   3925   EXPECT_FALSE(stream1->HasUrlFromHeaders());
   3926 
   3927   base::WeakPtr<SpdyStream> stream2 =
   3928       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3929                                 session, url, LOWEST, BoundNetLog());
   3930   ASSERT_TRUE(stream2.get() != NULL);
   3931 
   3932   StreamClosingDelegate delegate2(stream2, kBodyDataStringPiece);
   3933   stream2->SetDelegate(&delegate2);
   3934 
   3935   EXPECT_FALSE(stream2->HasUrlFromHeaders());
   3936 
   3937   base::WeakPtr<SpdyStream> stream3 =
   3938       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   3939                                 session, url, LOWEST, BoundNetLog());
   3940   ASSERT_TRUE(stream3.get() != NULL);
   3941 
   3942   test::StreamDelegateWithBody delegate3(stream3, kBodyDataStringPiece);
   3943   stream3->SetDelegate(&delegate3);
   3944 
   3945   EXPECT_FALSE(stream3->HasUrlFromHeaders());
   3946 
   3947   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   3948   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   3949   EXPECT_FALSE(stream3->send_stalled_by_flow_control());
   3950 
   3951   StallSessionSend(session.get());
   3952 
   3953   scoped_ptr<SpdyHeaderBlock> headers1(
   3954       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   3955   EXPECT_EQ(ERR_IO_PENDING,
   3956             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   3957   EXPECT_TRUE(stream1->HasUrlFromHeaders());
   3958   EXPECT_EQ(kStreamUrl, stream1->GetUrlFromHeaders().spec());
   3959 
   3960   data.RunFor(1);
   3961   EXPECT_EQ(1u, stream1->stream_id());
   3962   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   3963 
   3964   scoped_ptr<SpdyHeaderBlock> headers2(
   3965       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   3966   EXPECT_EQ(ERR_IO_PENDING,
   3967             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   3968   EXPECT_TRUE(stream2->HasUrlFromHeaders());
   3969   EXPECT_EQ(kStreamUrl, stream2->GetUrlFromHeaders().spec());
   3970 
   3971   data.RunFor(1);
   3972   EXPECT_EQ(3u, stream2->stream_id());
   3973   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
   3974 
   3975   scoped_ptr<SpdyHeaderBlock> headers3(
   3976       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   3977   EXPECT_EQ(ERR_IO_PENDING,
   3978             stream3->SendRequestHeaders(headers3.Pass(), MORE_DATA_TO_SEND));
   3979   EXPECT_TRUE(stream3->HasUrlFromHeaders());
   3980   EXPECT_EQ(kStreamUrl, stream3->GetUrlFromHeaders().spec());
   3981 
   3982   data.RunFor(1);
   3983   EXPECT_EQ(5u, stream3->stream_id());
   3984   EXPECT_TRUE(stream3->send_stalled_by_flow_control());
   3985 
   3986   SpdyStreamId stream_id1 = stream1->stream_id();
   3987   SpdyStreamId stream_id2 = stream2->stream_id();
   3988   SpdyStreamId stream_id3 = stream3->stream_id();
   3989 
   3990   // Close stream1 preemptively.
   3991   session->CloseActiveStream(stream_id1, ERR_CONNECTION_CLOSED);
   3992   EXPECT_EQ(NULL, stream1.get());
   3993 
   3994   EXPECT_FALSE(session->IsStreamActive(stream_id1));
   3995   EXPECT_TRUE(session->IsStreamActive(stream_id2));
   3996   EXPECT_TRUE(session->IsStreamActive(stream_id3));
   3997 
   3998   // Unstall stream2, which should then close stream3.
   3999   delegate2.set_stream_to_close(stream3);
   4000   UnstallSessionSend(session.get(), kBodyDataSize);
   4001 
   4002   data.RunFor(1);
   4003   EXPECT_EQ(NULL, stream3.get());
   4004 
   4005   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   4006   EXPECT_FALSE(session->IsStreamActive(stream_id1));
   4007   EXPECT_TRUE(session->IsStreamActive(stream_id2));
   4008   EXPECT_FALSE(session->IsStreamActive(stream_id3));
   4009 
   4010   data.RunFor(2);
   4011   EXPECT_EQ(NULL, stream2.get());
   4012 
   4013   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   4014   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
   4015   EXPECT_EQ(OK, delegate3.WaitForClose());
   4016 
   4017   EXPECT_TRUE(delegate1.send_headers_completed());
   4018   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
   4019 
   4020   EXPECT_TRUE(delegate2.send_headers_completed());
   4021   EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
   4022   EXPECT_EQ("HTTP/1.1", delegate2.GetResponseHeaderValue(":version"));
   4023   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
   4024 
   4025   EXPECT_TRUE(delegate3.send_headers_completed());
   4026   EXPECT_EQ(std::string(), delegate3.TakeReceivedData());
   4027 
   4028   EXPECT_TRUE(data.at_write_eof());
   4029 }
   4030 
   4031 // Cause a stall by reducing the flow control send window to
   4032 // 0. Unstalling the session should properly handle the session itself
   4033 // being closed.
   4034 TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
   4035   if (GetParam() < kProtoSPDY31)
   4036     return;
   4037 
   4038   const char kStreamUrl[] = "http://www.google.com/";
   4039   GURL url(kStreamUrl);
   4040 
   4041   session_deps_.host_resolver->set_synchronous_mode(true);
   4042 
   4043   scoped_ptr<SpdyFrame> req1(
   4044       spdy_util_.ConstructSpdyPost(
   4045           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   4046   scoped_ptr<SpdyFrame> req2(
   4047       spdy_util_.ConstructSpdyPost(
   4048           kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
   4049   scoped_ptr<SpdyFrame> body1(
   4050       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
   4051   MockWrite writes[] = {
   4052     CreateMockWrite(*req1, 0),
   4053     CreateMockWrite(*req2, 1),
   4054   };
   4055 
   4056   MockRead reads[] = {
   4057     MockRead(ASYNC, 0, 0, 2), // EOF
   4058   };
   4059 
   4060   DeterministicSocketData data(reads, arraysize(reads),
   4061                                writes, arraysize(writes));
   4062   MockConnect connect_data(SYNCHRONOUS, OK);
   4063   data.set_connect_data(connect_data);
   4064 
   4065   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
   4066 
   4067   CreateDeterministicNetworkSession();
   4068   base::WeakPtr<SpdySession> session =
   4069       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
   4070   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
   4071             session->flow_control_state());
   4072 
   4073   base::WeakPtr<SpdyStream> stream1 =
   4074       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   4075                                 session, url, LOWEST, BoundNetLog());
   4076   ASSERT_TRUE(stream1.get() != NULL);
   4077 
   4078   test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
   4079   stream1->SetDelegate(&delegate1);
   4080 
   4081   EXPECT_FALSE(stream1->HasUrlFromHeaders());
   4082 
   4083   base::WeakPtr<SpdyStream> stream2 =
   4084       CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
   4085                                 session, url, LOWEST, BoundNetLog());
   4086   ASSERT_TRUE(stream2.get() != NULL);
   4087 
   4088   test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
   4089   stream2->SetDelegate(&delegate2);
   4090 
   4091   EXPECT_FALSE(stream2->HasUrlFromHeaders());
   4092 
   4093   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   4094   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   4095 
   4096   StallSessionSend(session.get());
   4097 
   4098   scoped_ptr<SpdyHeaderBlock> headers1(
   4099       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   4100   EXPECT_EQ(ERR_IO_PENDING,
   4101             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   4102   EXPECT_TRUE(stream1->HasUrlFromHeaders());
   4103   EXPECT_EQ(kStreamUrl, stream1->GetUrlFromHeaders().spec());
   4104 
   4105   data.RunFor(1);
   4106   EXPECT_EQ(1u, stream1->stream_id());
   4107   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   4108 
   4109   scoped_ptr<SpdyHeaderBlock> headers2(
   4110       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   4111   EXPECT_EQ(ERR_IO_PENDING,
   4112             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   4113   EXPECT_TRUE(stream2->HasUrlFromHeaders());
   4114   EXPECT_EQ(kStreamUrl, stream2->GetUrlFromHeaders().spec());
   4115 
   4116   data.RunFor(1);
   4117   EXPECT_EQ(3u, stream2->stream_id());
   4118   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
   4119 
   4120   EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
   4121 
   4122   // Unstall stream1.
   4123   UnstallSessionSend(session.get(), kBodyDataSize);
   4124 
   4125   // Close the session (since we can't do it from within the delegate
   4126   // method, since it's in the stream's loop).
   4127   session->CloseSessionOnError(ERR_CONNECTION_CLOSED, "Closing session");
   4128   EXPECT_TRUE(session == NULL);
   4129 
   4130   EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
   4131 
   4132   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   4133   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
   4134 
   4135   EXPECT_TRUE(delegate1.send_headers_completed());
   4136   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
   4137 
   4138   EXPECT_TRUE(delegate2.send_headers_completed());
   4139   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
   4140 
   4141   EXPECT_TRUE(data.at_write_eof());
   4142 }
   4143 
   4144 }  // namespace net
   4145