Remove many-many SpdyMajorVersion and NextProto arguments and members.

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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 1805 matching lines @@
   expected_response += kUploadData;
 
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ(expected_response, out.response_data);
 }
 
 // Test that a POST without any post data works.
 TEST_P(SpdyNetworkTransactionTest, NullPost) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   // Create an empty UploadData.
   request.upload_data_stream = NULL;
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
   SpdyHeaderBlock req_block(
@@ skipping 21 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
   // Create an empty UploadDataStream.
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   ElementsUploadDataStream stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = default_url_;
   request.upload_data_stream = &stream;
 
@@ skipping 1706 matching lines @@
     EXPECT_NE(header_list->end(), header_list->Find(header)) <<
         "Header not found: " << *it;
   }
 }
 
 // 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) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 2 data frames in a single read.
   std::unique_ptr<SpdySerializedFrame> data_frame_1(
       framer.CreateDataFrame(1, "goodby", 6, DATA_FLAG_NONE));
   std::unique_ptr<SpdySerializedFrame> data_frame_2(
       framer.CreateDataFrame(1, "e worl", 6, DATA_FLAG_NONE));
@@ skipping 72 matching lines @@
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("goodbye world", out.response_data);
 }
 
 // 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) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 4 data frames in a single read.
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   std::unique_ptr<SpdySerializedFrame> data_frame_fin(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
@@ skipping 71 matching lines @@
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 5 data frames in a single read.
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
@@ skipping 65 matching lines @@
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data and close the connection.
 TEST_P(SpdyNetworkTransactionTest, BufferedClosed) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // All data frames in a single read.
   // NOTE: We don't FIN the stream.
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   const SpdySerializedFrame* data_frames[4] = {
@@ skipping 66 matching lines @@
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   base::RunLoop().RunUntilIdle();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Verify the case where we buffer data and cancel the transaction.
 TEST_P(SpdyNetworkTransactionTest, BufferedCancelled) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4)};
 
   // NOTE: We don't FIN the stream.
   std::unique_ptr<SpdySerializedFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
@@ skipping 1865 matching lines @@
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   data.RunUntilPaused();
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream);
   ASSERT_TRUE(stream->stream());
-  EXPECT_EQ(
-      static_cast<int>(SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2)) +
-          kDeltaWindowSize * kDeltaCount - kMaxSpdyFrameChunkSize * kFrameCount,
-      stream->stream()->send_window_size());
+  EXPECT_EQ(static_cast<int>(kDefaultInitialWindowSize) +
+                kDeltaWindowSize * kDeltaCount -
+                kMaxSpdyFrameChunkSize * kFrameCount,
+            stream->stream()->send_window_size());
 
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   helper.VerifyDataConsumed();
 }
 
 // Test that received data frames and sent WINDOW_UPDATE frames change
 // the recv_window_size_ correctly.
 TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) {
-  const int32_t default_initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
   // Session level maximum window size that is more than twice the default
   // initial window size so that an initial window update is sent.
   const int32_t session_max_recv_window_size = 5 * 64 * 1024;
-  ASSERT_LT(2 * default_initial_window_size, session_max_recv_window_size);
+  ASSERT_LT(2 * kDefaultInitialWindowSize, session_max_recv_window_size);
   // Stream level maximum window size that is less than the session level
   // maximum window size so that we test for confusion between the two.
   const int32_t stream_max_recv_window_size = 4 * 64 * 1024;
   ASSERT_GT(session_max_recv_window_size, stream_max_recv_window_size);
   // Size of body to be sent.  Has to be less than or equal to both window sizes
   // so that we do not run out of receiving window.  Also has to be greater than
   // half of them so that it triggers both a session level and a stream level
   // window update frame.
   const int32_t kTargetSize = 3 * 64 * 1024;
   ASSERT_GE(session_max_recv_window_size, kTargetSize);
@@ skipping 13 matching lines @@
   SettingsMap initial_settings;
   initial_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
   initial_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, stream_max_recv_window_size);
   std::unique_ptr<SpdySerializedFrame> initial_settings_frame(
       spdy_util_.ConstructSpdySettings(initial_settings));
   std::unique_ptr<SpdySerializedFrame> initial_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(
           kSessionFlowControlStreamId,
-          session_max_recv_window_size - default_initial_window_size));
+          session_max_recv_window_size - kDefaultInitialWindowSize));
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> session_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(0, session_window_update_delta));
   std::unique_ptr<SpdySerializedFrame> stream_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, stream_window_update_delta));
 
   std::vector<MockWrite> writes;
   writes.push_back(MockWrite(ASYNC, kHttp2ConnectionHeaderPrefix,
                              kHttp2ConnectionHeaderPrefixSize, 0));
@@ skipping 147 matching lines @@
 // also contains a FIN flag.  SequencedSocketData is used to enforce all
 // writes, save the last, go through before a read could happen.  The last frame
 // ("hello!") is not permitted 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::RunUntilIdle()
 // 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) {
-  const int32_t initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
+  const int32_t initial_window_size = kDefaultInitialWindowSize;
   // Number of upload data buffers we need to send to zero out the window size
   // is the minimal number of upload buffers takes to be bigger than
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
@@ skipping 127 matching lines @@
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
   data.Resume();  // Read in WINDOW_UPDATE frame.
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in
 // unstalling the send window.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) {
-  const int32_t initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
+  const int32_t initial_window_size = kDefaultInitialWindowSize;
   // Number of upload data buffers we need to send to zero out the window size
   // is the minimal number of upload buffers takes to be bigger than
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
@@ skipping 144 matching lines @@
 
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
   // If stream is NULL, that means it was unstalled and closed.
   EXPECT_TRUE(stream->stream() == NULL);
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in a
 // negative send window size.
 TEST_P(SpdyNetworkTransactionTest, FlowControlNegativeSendWindowSize) {
-  const int32_t initial_window_size =
-      SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2);
+  const int32_t initial_window_size = kDefaultInitialWindowSize;
   // Number of upload data buffers we need to send to zero out the window size
   // is the minimal number of upload buffers takes to be bigger than
   // |initial_window_size|.
   size_t num_upload_buffers =
       ceil(static_cast<double>(initial_window_size) / kBufferSize);
   // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
   // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
   // which has kBufferSize % kMaxSpdyChunkSize bytes.
   size_t num_frames_in_one_upload_buffer =
       ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
@@ skipping 316 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net