QUIC - stream id refactor for tests.

net/quic/chromium/bidirectional_stream_quic_impl_unittest.cc

 // Copyright 2016 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/quic/chromium/bidirectional_stream_quic_impl.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
@@ skipping 23 matching lines @@
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
+#include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace test {
 
@@ skipping 295 matching lines @@
     PacketToWrite(IoMode mode, int rv) : mode(mode), packet(nullptr), rv(rv) {}
     IoMode mode;
     QuicReceivedPacket* packet;
     int rv;
   };
 
   BidirectionalStreamQuicImplTest()
       : crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
         read_buffer_(new IOBufferWithSize(4096)),
         connection_id_(2),
-        stream_id_(kClientDataStreamId1),
+        stream_id_(GetNthClientInitiatedStreamId(0)),
         client_maker_(GetParam(),
                       connection_id_,
                       &clock_,
                       kDefaultServerHostName,
                       Perspective::IS_CLIENT),
         server_maker_(GetParam(),
                       connection_id_,
                       &clock_,
                       kDefaultServerHostName,
                       Perspective::IS_SERVER),
@@ skipping 303 matching lines @@
           load_timing_info.connect_timing,
           CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES);
     }
     ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
   }
 
   const BoundTestNetLog& net_log() const { return net_log_; }
 
   QuicChromiumClientSession* session() const { return session_.get(); }
 
+  QuicStreamId GetNthClientInitiatedStreamId(int n) {
+    return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(*session_, n);
+  }
+
  protected:
   BoundTestNetLog net_log_;
   scoped_refptr<TestTaskRunner> runner_;
   std::unique_ptr<MockWrite[]> mock_writes_;
   MockClock clock_;
   QuicConnection* connection_;
   std::unique_ptr<QuicChromiumConnectionHelper> helper_;
   std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
   TransportSecurityState transport_security_state_;
   std::unique_ptr<QuicChromiumClientSession> session_;
@@ skipping 17 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(Version,
                         BidirectionalStreamQuicImplTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 TEST_P(BidirectionalStreamQuicImplTest, GetRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructRequestHeadersPacketInner(
-      1, kClientDataStreamId1, kFin, DEFAULT_PRIORITY,
+      1, GetNthClientInitiatedStreamId(0), kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset));
   AddWrite(ConstructClientAckPacket(3, 3, 1, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = true;
@@ skipping 76 matching lines @@
   ExpectLogContainsSomewhere(
       entries, /*min_offset=*/pos,
       NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
       NetLogEventPhase::NONE);
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, LoadTimingTwoRequests) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   QuicStreamOffset offset = 0;
   AddWrite(ConstructRequestHeadersPacketInner(
-      1, kClientDataStreamId1, kFin, DEFAULT_PRIORITY, nullptr, &offset));
+      1, GetNthClientInitiatedStreamId(0), kFin, DEFAULT_PRIORITY, nullptr,
+      &offset));
   // SetRequest() again for second request as |request_headers_| was moved.
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId2, kFin, DEFAULT_PRIORITY, nullptr, &offset));
+      2, GetNthClientInitiatedStreamId(1), kFin, DEFAULT_PRIORITY, nullptr,
+      &offset));
   AddWrite(ConstructInitialSettingsPacket(3, &offset));
   AddWrite(ConstructClientAckPacket(4, 3, 1, 1));
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
@@ skipping 12 matching lines @@
   delegate->WaitUntilNextCallback();   // OnStreamReady
   delegate2->WaitUntilNextCallback();  // OnStreamReady
 
   ConfirmHandshake();
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0));
 
   // Server sends the response headers.
   offset = 0;
   ProcessPacket(ConstructResponseHeadersPacketInner(
-      2, kClientDataStreamId1, kFin, ConstructResponseHeaders("200"), nullptr,
-      &offset));
+      2, GetNthClientInitiatedStreamId(0), kFin,
+      ConstructResponseHeaders("200"), nullptr, &offset));
 
   ProcessPacket(ConstructResponseHeadersPacketInner(
-      3, kClientDataStreamId2, kFin, ConstructResponseHeaders("200"), nullptr,
-      &offset));
+      3, GetNthClientInitiatedStreamId(1), kFin,
+      ConstructResponseHeaders("200"), nullptr, &offset));
 
   delegate->WaitUntilNextCallback();   // OnHeadersReceived
   delegate2->WaitUntilNextCallback();  // OnHeadersReceived
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
   LoadTimingInfo load_timing_info2;
   EXPECT_TRUE(delegate2->GetLoadTimingInfo(&load_timing_info2));
   ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false);
   ExpectLoadTimingValid(load_timing_info2, /*session_reused=*/true);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ("200", delegate2->response_headers().find(":status")->second);
   // No response body. ReadData() should return OK synchronously.
   TestCompletionCallback dummy_callback;
   EXPECT_EQ(OK, delegate->ReadData(dummy_callback.callback()));
   EXPECT_EQ(OK, delegate2->ReadData(dummy_callback.callback()));
 }
 
 // Tests that when request headers are not delayed, only data buffers are
 // coalesced.
 TEST_P(BidirectionalStreamQuicImplTest, CoalesceDataBuffersNotHeadersFrame) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   const char kBody1[] = "here are some data";
   const char kBody2[] = "data keep coming";
   std::vector<std::string> two_writes = {kBody1, kBody2};
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, !kFin, 0,
                                                    {kBody1, kBody2}));
   // Ack server's data packet.
   AddWrite(ConstructClientAckPacket(4, 3, 1, 1));
   const char kBody3[] = "hello there";
   const char kBody4[] = "another piece of small data";
   const char kBody5[] = "really small";
   QuicStreamOffset data_offset = strlen(kBody1) + strlen(kBody2);
   AddWrite(ConstructClientMultipleDataFramesPacket(
@@ skipping 287 matching lines @@
                            strlen(kResponseBody) + spdy_trailers_frame_length),
       delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, PostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, 0, kUploadData,
                                &client_maker_));
   AddWrite(ConstructClientAckPacket(4, 3, 1, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
@@ skipping 137 matching lines @@
                            strlen(kResponseBody) + spdy_trailers_frame_length),
       delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, InterleaveReadDataAndSendData) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructAckAndDataPacket(3, !kIncludeVersion, 2, 1, 1, !kFin, 0,
                                      kUploadData, &client_maker_));
   AddWrite(ConstructAckAndDataPacket(4, !kIncludeVersion, 3, 3, 3, kFin,
                                      strlen(kUploadData), kUploadData,
                                      &client_maker_));
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
@@ skipping 66 matching lines @@
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
                                  2 * strlen(kResponseBody)),
             delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, ServerSendsRstAfterHeaders) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructRequestHeadersPacketInner(
-      1, kClientDataStreamId1, kFin, DEFAULT_PRIORITY,
+      1, GetNthClientInitiatedStreamId(0), kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset));
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = true;
   request.priority = DEFAULT_PRIORITY;
 
@@ skipping 20 matching lines @@
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, ServerSendsRstAfterReadData) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructRequestHeadersPacketInner(
-      1, kClientDataStreamId1, kFin, DEFAULT_PRIORITY,
+      1, GetNthClientInitiatedStreamId(0), kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset));
   // Why does QUIC ack Rst? Is this expected?
   AddWrite(ConstructClientAckPacket(3, 3, 1, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
@@ skipping 41 matching lines @@
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeReadData) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
@@ skipping 39 matching lines @@
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamAfterReadData) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructClientAckAndRstStreamPacket(3, 2, 1, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
@@ skipping 33 matching lines @@
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnHeadersReceived) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructClientAckAndRstStreamPacket(3, 2, 1, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
   request.priority = DEFAULT_PRIORITY;
@@ skipping 25 matching lines @@
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnDataRead) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   AddWrite(ConstructRequestHeadersPacketInner(
-      2, kClientDataStreamId1, !kFin, DEFAULT_PRIORITY,
+      2, GetNthClientInitiatedStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   AddWrite(ConstructClientAckPacket(3, 3, 1, 1));
   AddWrite(ConstructClientRstStreamPacket(4));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.end_stream_on_headers = false;
@@ skipping 100 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net