[SPDY] Fix SpdySession's handling of SYN_REPLY frames

net/spdy/spdy_http_stream_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/spdy/spdy_http_stream.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 45 matching lines @@
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
                               CONNECT_TIMING_HAS_DNS_TIMES);
   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
 }
 
 }  // namespace
 
-class SpdyHttpStreamSpdy2Test : public testing::Test,
-                                public testing::WithParamInterface<NextProto> {
+class SpdyHttpStreamTest : public testing::Test,
+                           public testing::WithParamInterface<NextProto> {
  public:
-  SpdyHttpStreamSpdy2Test()
+  SpdyHttpStreamTest()
       : spdy_util_(GetParam()),
         session_deps_(GetParam()) {
     session_deps_.net_log = &net_log_;
   }
 
   DeterministicSocketData* deterministic_data() {
     return deterministic_data_.get();
   }
 
   OrderedSocketData* data() { return data_.get(); }
@@ skipping 77 matching lines @@
   scoped_refptr<HttpNetworkSession> http_session_;
   scoped_refptr<SpdySession> session_;
   scoped_refptr<TransportSocketParams> transport_params_;
 
  private:
   MockECSignatureCreatorFactory ec_signature_creator_factory_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
-    SpdyHttpStreamSpdy2Test,
+    SpdyHttpStreamTest,
     testing::Values(kProtoSPDY2, kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2));
 
 // TODO(akalin): Don't early-exit in the tests below for values >
 // kProtoSPDY3.
 
 // SpdyHttpStream::GetUploadProgress() should still work even before the
 // stream is initialized.
-TEST_P(SpdyHttpStreamSpdy2Test, GetUploadProgressBeforeInitialization) {
+TEST_P(SpdyHttpStreamTest, GetUploadProgressBeforeInitialization) {
   if (GetParam() > kProtoSPDY3)
     return;
 
   SpdyHttpStream stream(NULL, false);
   UploadProgress progress = stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
 }
 
-TEST_P(SpdyHttpStreamSpdy2Test, SendRequest) {
+TEST_P(SpdyHttpStreamTest, SendRequest) {
   if (GetParam() > kProtoSPDY3)
     return;
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req.get(), 1),
   };
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
@@ skipping 46 matching lines @@
   EXPECT_TRUE(data()->at_read_eof());
   EXPECT_TRUE(data()->at_write_eof());
 
   TestLoadTimingNotReused(*http_stream);
   http_stream->Close(true);
   // Test that there's no crash when trying to get the load timing after the
   // stream has been closed.
   TestLoadTimingNotReused(*http_stream);
 }
 
-TEST_P(SpdyHttpStreamSpdy2Test, LoadTimingTwoRequests) {
+TEST_P(SpdyHttpStreamTest, LoadTimingTwoRequests) {
   if (GetParam() > kProtoSPDY3)
     return;
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
     CreateMockWrite(*req2, 1),
@@ skipping 80 matching lines @@
   scoped_refptr<IOBuffer> buf1(new IOBuffer(1));
   ASSERT_EQ(
       0, http_stream1->ReadResponseBody(buf1.get(), 1, callback1.callback()));
 
   // Stream 1 has been read to completion.
   TestLoadTimingNotReused(*http_stream1);
   // Stream 2 still has queued body data.
   TestLoadTimingReused(*http_stream2);
 }
 
-TEST_P(SpdyHttpStreamSpdy2Test, SendChunkedPost) {
+TEST_P(SpdyHttpStreamTest, SendChunkedPost) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> initial_window_update(
       framer.CreateWindowUpdate(
           kSessionFlowControlStreamId,
           kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> body(
       framer.CreateDataFrame(1, kUploadData, kUploadDataSize, DATA_FLAG_FIN));
@@ skipping 56 matching lines @@
 
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(http_session_->spdy_session_pool()->HasSession(key));
   EXPECT_TRUE(data()->at_read_eof());
   EXPECT_TRUE(data()->at_write_eof());
 }
 
 // Test to ensure the SpdyStream state machine does not get confused when a
 // chunk becomes available while a write is pending.
-TEST_P(SpdyHttpStreamSpdy2Test, DelayedSendChunkedPost) {
+TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPost) {
   if (GetParam() > kProtoSPDY3)
     return;
 
   const char kUploadData1[] = "12345678";
   const int kUploadData1Size = arraysize(kUploadData1)-1;
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk2(
       spdy_util_.ConstructSpdyBodyFrame(
           1, kUploadData1, kUploadData1Size, false));
@@ skipping 89 matching lines @@
   // Finish reading the |EOF|.
   deterministic_data()->RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
   EXPECT_TRUE(deterministic_data()->at_read_eof());
   EXPECT_TRUE(deterministic_data()->at_write_eof());
 }
 
 // Test the receipt of a WINDOW_UPDATE frame while waiting for a chunk to be
 // made available is handled correctly.
-TEST_P(SpdyHttpStreamSpdy2Test, DelayedSendChunkedPostWithWindowUpdate) {
+TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithWindowUpdate) {
   if (GetParam() != kProtoSPDY3)
     return;
 
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req.get(), 0),
     CreateMockWrite(*chunk1, 1),
   };
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
@@ skipping 96 matching lines @@
 
   // Finish reading the |EOF|.
   data.RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 // Test case for bug: http://code.google.com/p/chromium/issues/detail?id=50058
-TEST_P(SpdyHttpStreamSpdy2Test, SpdyURLTest) {
+TEST_P(SpdyHttpStreamTest, SpdyURLTest) {
   if (GetParam() > kProtoSPDY3)
     return;
 
   const char * const full_url = "http://www.google.com/foo?query=what#anchor";
   const char * const base_url = "http://www.google.com/foo?query=what";
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(base_url, false, 1, LOWEST));
   MockWrite writes[] = {
     CreateMockWrite(*req.get(), 1),
   };
@@ skipping 97 matching lines @@
 }
 
 }  // namespace
 
 // TODO(rch): When openssl supports server bound certifictes, this
 // guard can be removed
 #if !defined(USE_OPENSSL)
 // Test that if we request a resource for a new origin on a session that
 // used domain bound certificates, that we send a CREDENTIAL frame for
 // the new domain before we send the new request.
-void SpdyHttpStreamSpdy2Test::TestSendCredentials(
+void SpdyHttpStreamTest::TestSendCredentials(
     ServerBoundCertService* server_bound_cert_service,
     const std::string& cert,
     const std::string& proof) {
   const char* kUrl1 = "https://www.google.com/";
   const char* kUrl2 = "https://www.gmail.com/";
 
   SpdyCredential cred;
   cred.slot = 2;
   cred.proof = proof;
   cred.certs.push_back(cert);
@@ skipping 103 matching lines @@
   callback.WaitForResult();
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream2->ReadResponseHeaders(
       callback.callback()));
   data.RunFor(1);
   EXPECT_EQ(OK, callback.WaitForResult());
   ASSERT_TRUE(response.headers.get() != NULL);
   ASSERT_EQ(200, response.headers->response_code());
 }
 
-TEST_P(SpdyHttpStreamSpdy2Test, SendCredentialsEC) {
+TEST_P(SpdyHttpStreamTest, SendCredentialsEC) {
   if (GetParam() != kProtoSPDY3)
     return;
 
   scoped_refptr<base::SequencedWorkerPool> sequenced_worker_pool =
       new base::SequencedWorkerPool(1, "SpdyHttpStreamSpdy3Test");
   scoped_ptr<ServerBoundCertService> server_bound_cert_service(
       new ServerBoundCertService(new DefaultServerBoundCertStore(NULL),
                                  sequenced_worker_pool));
   std::string cert;
   std::string proof;
   GetECServerBoundCertAndProof("www.gmail.com",
                                server_bound_cert_service.get(),
                                &cert, &proof);
 
   TestSendCredentials(server_bound_cert_service.get(), cert, proof);
 
   sequenced_worker_pool->Shutdown();
 }
 
-TEST_P(SpdyHttpStreamSpdy2Test, DontSendCredentialsForHttpUrlsEC) {
+TEST_P(SpdyHttpStreamTest, DontSendCredentialsForHttpUrlsEC) {
   if (GetParam() != kProtoSPDY3)
     return;
 
   scoped_refptr<base::SequencedWorkerPool> sequenced_worker_pool =
       new base::SequencedWorkerPool(1, "SpdyHttpStreamSpdy3Test");
   scoped_ptr<ServerBoundCertService> server_bound_cert_service(
       new ServerBoundCertService(new DefaultServerBoundCertStore(NULL),
                                  sequenced_worker_pool));
   std::string cert;
   std::string proof;
@@ skipping 117 matching lines @@
   data.RunFor(1);
   sequenced_worker_pool->Shutdown();
 }
 
 #endif  // !defined(USE_OPENSSL)
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace net