SPDY - default to SPDY/2.1 protocol in unittests

net/spdy/spdy_network_transaction_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/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 109 matching lines @@
 
       std::vector<std::string> next_protos;
       next_protos.push_back("http/1.1");
       next_protos.push_back("spdy/2");
       next_protos.push_back("spdy/2.1");
 
       switch (test_type_) {
         case SPDYNPN:
           session_->http_server_properties()->SetAlternateProtocol(
               HostPortPair("www.google.com", 80), 443,
-              NPN_SPDY_2);
+              NPN_SPDY_21);
           HttpStreamFactory::set_use_alternate_protocols(true);
           HttpStreamFactory::set_next_protos(next_protos);
           break;
         case SPDYNOSSL:
           HttpStreamFactory::set_force_spdy_over_ssl(false);
           HttpStreamFactory::set_force_spdy_always(true);
           break;
         case SPDYSSL:
           HttpStreamFactory::set_force_spdy_over_ssl(true);
           HttpStreamFactory::set_force_spdy_always(true);
@@ skipping 86 matching lines @@
       VerifyDataConsumed();
     }
 
     void AddData(StaticSocketDataProvider* data) {
       DCHECK(!deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(true, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
-        ssl_->next_proto = "spdy/2";
+        ssl_->next_proto = "spdy/2.1";
         ssl_->was_npn_negotiated = true;
-        ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY2;
+        ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY21;
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)
         session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());
       session_deps_->socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(false, ERR_IO_PENDING);
         linked_ptr<StaticSocketDataProvider>
             hanging_non_alternate_protocol_socket(
                 new StaticSocketDataProvider(NULL, 0, NULL, 0));
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
             hanging_non_alternate_protocol_socket.get());
         alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
       }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(true, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
-        ssl_->next_proto = "spdy/2";
+        ssl_->next_proto = "spdy/2.1";
         ssl_->was_npn_negotiated = true;
-        ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY2;
+        ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY21;
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {
         session_deps_->deterministic_socket_factory->
             AddSSLSocketDataProvider(ssl_.get());
       }
       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(false, ERR_IO_PENDING);
         scoped_refptr<DeterministicSocketData>
@@ skipping 1600 matching lines @@
 // enough number of WINDOW_UPDATEs to finish the first read and cause a
 // write, leading to a complete write of request body; after that we send
 // a reply with a body, to cause a graceful shutdown.
 
 // TODO(agayev): develop a socket data provider where both, reads and
 // writes are ordered so that writing tests like these are easy and rewrite
 // all these tests using it.  Right now we are working around the
 // limitations as described above and it's not deterministic, tests may
 // fail under specific circumstances.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateReceived) {
-  SpdySession::set_use_flow_control(true);
+  SpdySession::set_use_flow_control(SpdySession::kEnableFlowControl);
 
   static int kFrameCount = 2;
   scoped_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyPost(
       kMaxSpdyFrameChunkSize * kFrameCount, NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(
       ConstructSpdyBodyFrame(1, content->c_str(), content->size(), false));
   scoped_ptr<spdy::SpdyFrame> body_end(
       ConstructSpdyBodyFrame(1, content->c_str(), content->size(), true));
@@ skipping 50 matching lines @@
   EXPECT_EQ(OK, rv);
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(static_cast<int>(spdy::kSpdyStreamInitialWindowSize) +
             kDeltaWindowSize * kDeltaCount -
             kMaxSpdyFrameChunkSize * kFrameCount,
             stream->stream()->send_window_size());
   helper.VerifyDataConsumed();
-  SpdySession::set_use_flow_control(false);
+
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 // Test that received data frames and sent WINDOW_UPDATE frames change
 // the recv_window_size_ correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) {
-  SpdySession::set_use_flow_control(true);
+  SpdySession::set_use_flow_control(SpdySession::kEnableFlowControl);
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> window_update(
       ConstructSpdyWindowUpdate(1, kUploadDataSize));
 
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*window_update),
   };
 
@@ skipping 56 matching lines @@
   data->CompleteRead();
 
   // Force write of WINDOW_UPDATE which was scheduled during the above
   // read.
   MessageLoop::current()->RunAllPending();
 
   // Read EOF.
   data->CompleteRead();
 
   helper.VerifyDataConsumed();
-  SpdySession::set_use_flow_control(false);
+
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 // Test that WINDOW_UPDATE frame causing overflow is handled correctly.  We
 // use the same trick as in the above test to enforce our scenario.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateOverflow) {
-  SpdySession::set_use_flow_control(true);
+  SpdySession::set_use_flow_control(SpdySession::kEnableFlowControl);
 
   // number of full frames we hope to write (but will not, used to
   // set content-length header correctly)
   static int kFrameCount = 3;
 
   scoped_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyPost(
       kMaxSpdyFrameChunkSize * kFrameCount, NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(
@@ skipping 52 matching lines @@
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
 
   data->CompleteRead();
 
   ASSERT_TRUE(helper.session() != NULL);
   ASSERT_TRUE(helper.session()->spdy_session_pool() != NULL);
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 
-  SpdySession::set_use_flow_control(false);
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 // Test that after hitting a send window size of 0, the write process
 // stalls and upon receiving WINDOW_UPDATE frame write resumes.
 
 // This test constructs a POST request followed by enough data frames
 // containing 'a' that would make the window size 0, followed by another
 // data frame containing default content (which is "hello!") and this frame
 // also contains a FIN flag.  DelayedSocketData is used to enforce all
 // writes go through before a read could happen.  However, the last frame
 // ("hello!")  is not supposed to go through since by the time its turn
 // arrives, window size is 0.  At this point MessageLoop::Run() called via
 // callback would block.  Therefore we call MessageLoop::RunAllPending()
 // which returns after performing all possible writes.  We use DCHECKS to
 // ensure that last data frame is still there and stream has stalled.
 // After that, next read is artifically enforced, which causes a
 // WINDOW_UPDATE to be read and I/O process resumes.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) {
-  SpdySession::set_use_flow_control(true);
+  SpdySession::set_use_flow_control(SpdySession::kEnableFlowControl);
 
   // Number of frames we need to send to zero out the window size: data
   // frames plus SYN_STREAM plus the last data frame; also we need another
   // data frame that we will send once the WINDOW_UPDATE is received,
   // therefore +3.
   size_t nwrites =
       spdy::kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3;
 
   // Calculate last frame's size; 0 size data frame is legal.
   size_t last_frame_size =
@@ skipping 70 matching lines @@
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(0, stream->stream()->send_window_size());
   EXPECT_FALSE(stream->request_body_stream_->eof());
 
   data->ForceNextRead();   // Read in WINDOW_UPDATE frame.
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 
-  SpdySession::set_use_flow_control(false);
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 TEST_P(SpdyNetworkTransactionTest, CancelledTransaction) {
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 716 matching lines @@
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) {
+  SpdySession::set_use_flow_control(SpdySession::kDisableFlowControl);
+
   static const unsigned char kPushBodyFrame1[] = {
     0x00, 0x00, 0x00, 0x02,                                      // header, ID
     0x01, 0x00, 0x00, 0x1F,                                      // FIN, length
     'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
   };
   static const char kPushBodyFrame2[] = " my darling";
   static const char kPushBodyFrame3[] = " hello";
   static const char kPushBodyFrame4[] = " my baby";
 
   scoped_ptr<spdy::SpdyFrame>
@@ skipping 41 matching lines @@
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
+
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
   scoped_ptr<spdy::SpdyFrame>
       stream1_syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame>
       stream2_rst(ConstructSpdyRstStream(2, spdy::INVALID_STREAM));
   MockWrite writes[] = {
@@ skipping 694 matching lines @@
       ++it) {
     EXPECT_EQ(it->second, (*headers)[it->first]);
   }
 }
 
 // Since we buffer the IO from the stream to the renderer, this test verifies
 // that when we read out the maximum amount of data (e.g. we received 50 bytes
 // on the network, but issued a Read for only 5 of those bytes) that the data
 // flow still works correctly.
 TEST_P(SpdyNetworkTransactionTest, BufferFull) {
+  SpdySession::set_use_flow_control(SpdySession::kDisableFlowControl);
+
   spdy::SpdyFramer framer;
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 2 data frames in a single read.
   scoped_ptr<spdy::SpdyFrame> data_frame_1(
       framer.CreateDataFrame(1, "goodby", 6, spdy::DATA_FLAG_NONE));
   scoped_ptr<spdy::SpdyFrame> data_frame_2(
       framer.CreateDataFrame(1, "e worl", 6, spdy::DATA_FLAG_NONE));
@@ skipping 69 matching lines @@
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("goodbye world", out.response_data);
+
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 // Verify that basic buffering works; when multiple data frames arrive
 // at the same time, ensure that we don't notify a read completion for
 // each data frame individually.
 TEST_P(SpdyNetworkTransactionTest, Buffering) {
+  SpdySession::set_use_flow_control(SpdySession::kDisableFlowControl);
+
   spdy::SpdyFramer framer;
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 4 data frames in a single read.
   scoped_ptr<spdy::SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, spdy::DATA_FLAG_NONE));
   scoped_ptr<spdy::SpdyFrame> data_frame_fin(
       framer.CreateDataFrame(1, "message", 7, spdy::DATA_FLAG_FIN));
@@ skipping 71 matching lines @@
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
+
+  SpdySession::set_use_flow_control(SpdySession::kFlowControlBasedOnNPN);
 }
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
   spdy::SpdyFramer framer;
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // 5 data frames in a single read.
@@ skipping 1741 matching lines @@
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net