Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

net/quic/chromium/quic_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 <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 36 matching lines @@
 #include "net/quic/chromium/quic_test_packet_maker.h"
 #include "net/quic/chromium/test_task_runner.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/impl/quic_test_impl.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_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/mock_client_socket_pool_manager.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_performance_watcher.h"
 #include "net/socket/socket_performance_watcher_factory.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/core/spdy_frame_builder.h"
 #include "net/spdy/core/spdy_framer.h"
 #include "net/ssl/ssl_config_service_defaults.h"
@@ skipping 642 matching lines @@
     EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty());
 
     // The alternative proxy server should no longer be in use.
     EXPECT_FALSE(test_proxy_delegate.alternative_proxy_server().is_valid());
 
     // Verify that the second request completes successfully, and the
     // alternative proxy server job is not started.
     SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443);
   }
 
+  QuicStreamId GetNthClientInitiatedStreamId(int n) {
+    return test::GetNthClientInitiatedStreamId(version_, n);
+  }
+
+  QuicStreamId GetNthServerInitiatedStreamId(int n) {
+    return test::GetNthServerInitiatedStreamId(version_, n);
+  }
+
   const QuicVersion version_;
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   MockClock clock_;
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
   std::unique_ptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   ProofVerifyDetailsChromium verify_details_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockHostResolver host_resolver_;
@@ skipping 42 matching lines @@
 
 TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) {
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
   test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true);
 
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) {
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
   test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false);
 
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuic) {
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
 
   SendRequestAndExpectQuicResponse("hello!");
 
   // Check that the NetLog was filled reasonably.
@@ skipping 38 matching lines @@
 TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) {
   params_.origins_to_force_quic_on.insert(HostPortPair());
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
 
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicProxy) {
   params_.enable_quic = true;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("QUIC mail.example.org:70");
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
   // There is no need to set up an alternate protocol job, because
   // no attempt will be made to speak to the proxy over TCP.
@@ skipping 16 matching lines @@
   params_.enable_quic = true;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("QUIC " + proxy_host + ":70");
 
   client_maker_.set_hostname(origin_host);
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
   ASSERT_TRUE(cert.get());
   // This certificate is valid for the proxy, but not for the origin.
   EXPECT_TRUE(cert->VerifyNameMatch(proxy_host, false));
@@ skipping 27 matching lines @@
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
   client_maker_.set_hostname(origin.host());
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   request_.url = GURL("https://" + origin.host());
   AddQuicRemoteAlternativeServiceMapping(
       MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative);
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
@@ skipping 16 matching lines @@
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties_.SetAlternativeService(server, alternative_service,
                                                 expiration);
 
   // First try: alternative job uses QUIC, gets 421 Misdirected Request error.
   MockQuicData mock_quic_data;
   QuicStreamOffset request_header_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &request_header_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
-  mock_quic_data.AddRead(
-      ConstructServerResponseHeadersPacket(1, kClientDataStreamId1, false, true,
-                                           GetResponseHeaders("421"), nullptr));
+  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
+      1, GetNthClientInitiatedStreamId(0), false, true,
+      GetResponseHeaders("421"), nullptr));
   mock_quic_data.AddWrite(ConstructClientAckAndRstPacket(
-      3, kClientDataStreamId1, QUIC_STREAM_CANCELLED, 1, 1, 1));
+      3, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED, 1, 1, 1));
   mock_quic_data.AddRead(ASYNC, OK);
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // First try: main job uses TCP, connection fails.
   // (A hanging connection would not work here, because the main Job on the
   // second try would pool to that socket and hang.)
   StaticSocketDataProvider failing_data;
   MockConnect failing_connect(SYNCHRONOUS, ERR_CONNECTION_CLOSED);
   failing_data.set_connect_data(failing_connect);
   socket_factory_.AddSocketDataProvider(&failing_data);
@@ skipping 84 matching lines @@
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
@@ skipping 12 matching lines @@
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
@@ skipping 78 matching lines @@
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
   // Read a GoAway packet with
   // QuicErrorCode: QUIC_ERROR_MIGRATING_PORT from the peer.
   mock_quic_data.AddSynchronousRead(ConstructServerGoAwayPacket(
       2, QUIC_ERROR_MIGRATING_PORT,
       "connection migration with port change only"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddSynchronousRead(ConstructServerDataPacket(
-      3, kClientDataStreamId1, false, true, 0, "hello!"));
+      3, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckAndRstPacket(
-      4, kClientDataStreamId1, QUIC_STREAM_CANCELLED, 3, 3, 1));
+      4, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED, 3, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // In order for a new QUIC session to be established via alternate-protocol
@@ skipping 37 matching lines @@
   params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true,
                                                   false, 0, request_data));
@@ skipping 69 matching lines @@
   params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true,
                                                   false, 0, request_data));
@@ skipping 78 matching lines @@
   params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
 
-  quic_data.AddWrite(client_maker_.MakeRstPacket(3, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, true,
                                                   false, 0, request_data));
   // TLP 2
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       5, kHeadersStreamId, true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(client_maker_.MakeRstPacket(6, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      6, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   quic_data.AddWrite(client_maker_.MakeDataPacket(7, kHeadersStreamId, true,
                                                   false, 0, request_data));
   // RTO 2
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       8, kHeadersStreamId, true, false, settings_offset, settings_data));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(9, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      9, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   // RTO 3
   quic_data.AddWrite(client_maker_.MakeDataPacket(10, kHeadersStreamId, true,
                                                   false, 0, request_data));
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       11, kHeadersStreamId, true, false, settings_offset, settings_data));
   // RTO 4
-  quic_data.AddWrite(client_maker_.MakeRstPacket(12, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      12, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   quic_data.AddWrite(client_maker_.MakeDataPacket(13, kHeadersStreamId, true,
                                                   false, 0, request_data));
   // RTO 5
   quic_data.AddWrite(client_maker_.MakeAckAndConnectionClosePacket(
       14, true, QuicTime::Delta::Infinite(), 0, 1, 1, QUIC_TOO_MANY_RTOS,
       "5 consecutive retransmission timeouts"));
 
   quic_data.AddRead(ASYNC, OK);
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
@@ skipping 44 matching lines @@
   ASSERT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 // Verify that if a QUIC protocol error occurs after the handshake is confirmed
 // the request fails with QUIC_PROTOCOL_ERROR.
 TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmed) {
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
+      1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset));
   // Peer sending data from an non-existing stream causes this end to raise
   // error and close connection.
   quic_data.AddRead(
       ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR));
   std::string quic_error_details = "Data for nonexistent stream";
   quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket(
       3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID,
       quic_error_details));
@@ skipping 48 matching lines @@
   params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true,
                                                   false, 0, request_data));
@@ skipping 96 matching lines @@
   params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true,
                                                   false, 0, request_data));
@@ skipping 99 matching lines @@
   params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
 
   quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
   // quic_data.AddWrite(ConstructClientAckPacket(3, 1, 1));
   quic_data.AddWrite(ConstructClientAckPacket(
       3, 1, 1, 1, QuicTime::Delta::FromMilliseconds(25)));
 
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, false,
                                                   false, 0, request_data));
   // TLP 2
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       5, kHeadersStreamId, false, false, settings_offset, settings_data));
@@ skipping 80 matching lines @@
   params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true,
                                                   false, 0, request_data));
@@ skipping 104 matching lines @@
   params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
-      1, kClientDataStreamId1, true, true, priority,
+      1, GetNthClientInitiatedStreamId(0), true, true, priority,
       GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset,
       &request_data));
 
   std::string settings_data;
   QuicStreamOffset settings_offset = header_stream_offset;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData(
       2, &header_stream_offset, &settings_data));
 
-  quic_data.AddWrite(client_maker_.MakeRstPacket(3, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   // TLP 1
   quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, true,
                                                   false, 0, request_data));
   // TLP 2
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       5, kHeadersStreamId, true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(client_maker_.MakeRstPacket(6, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      6, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   quic_data.AddWrite(client_maker_.MakeDataPacket(7, kHeadersStreamId, true,
                                                   false, 0, request_data));
   // RTO 2
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       8, kHeadersStreamId, true, false, settings_offset, settings_data));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(9, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      9, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   // RTO 3
   quic_data.AddWrite(client_maker_.MakeDataPacket(10, kHeadersStreamId, true,
                                                   false, 0, request_data));
   quic_data.AddWrite(client_maker_.MakeDataPacket(
       11, kHeadersStreamId, true, false, settings_offset, settings_data));
   // RTO 4
-  quic_data.AddWrite(client_maker_.MakeRstPacket(12, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      12, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   quic_data.AddWrite(client_maker_.MakeDataPacket(13, kHeadersStreamId, true,
                                                   false, 0, request_data));
   // RTO 5
   quic_data.AddWrite(client_maker_.MakeAckAndConnectionClosePacket(
       14, true, QuicTime::Delta::Infinite(), 0, 1, 1, QUIC_TOO_MANY_RTOS,
       "5 consecutive retransmission timeouts"));
 
   quic_data.AddRead(ASYNC, OK);
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
@@ skipping 49 matching lines @@
 // retried over TCP and the QUIC will be marked as broken.
 TEST_P(QuicNetworkTransactionTest,
        ProtocolErrorAfterHandshakeConfirmedThenBroken) {
   params_.retry_without_alt_svc_on_quic_errors = true;
   params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
+      1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset));
   // Peer sending data from an non-existing stream causes this end to raise
   // error and close connection.
   quic_data.AddRead(
       ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR));
   std::string quic_error_details = "Data for nonexistent stream";
   quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket(
       3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID,
       quic_error_details));
@@ skipping 105 matching lines @@
 
   QuicStreamOffset request_header_offset = 0;
   QuicStreamOffset response_header_offset = 0;
   // First QUIC request data.
   // Open a session to foo.example.org:443 using the first entry of the
   // alternative service list.
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &request_header_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
 
   std::string alt_svc_list =
       "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", "
       "quic=\"bar.example.org:445\"";
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false,
+      1, GetNthClientInitiatedStreamId(0), false, false,
       GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
 
   // Second QUIC request data.
   // Connection pooling, using existing session, no need to include version
   // as version negotiation has been completed.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      4, kClientDataStreamId2, false, true,
+      4, GetNthClientInitiatedStreamId(1), false, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
-                                                   false, true, 0, "hello!"));
+      3, GetNthClientInitiatedStreamId(1), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(
       ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
@@ skipping 10 matching lines @@
 
   QuicStreamOffset request_header_offset = 0;
   QuicStreamOffset response_header_offset = 0;
   // First QUIC request data.
   // Open a session to foo.example.org:443 using the first entry of the
   // alternative service list.
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &request_header_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "http", "/"), &request_header_offset));
 
   std::string alt_svc_list;
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false,
+      1, GetNthClientInitiatedStreamId(0), false, false,
       GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
 
   // Second QUIC request data.
   // Connection pooling, using existing session, no need to include version
   // as version negotiation has been completed.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      4, kClientDataStreamId2, false, true,
+      4, GetNthClientInitiatedStreamId(1), false, true,
       GetRequestHeaders("GET", "http", "/"), &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
-                                                   false, true, 0, "hello!"));
+      3, GetNthClientInitiatedStreamId(1), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(
       ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
 
   TestProxyDelegate test_proxy_delegate;
@@ skipping 25 matching lines @@
 // even if alternative service destination is different.
 TEST_P(QuicNetworkTransactionTest, PoolByOrigin) {
   MockQuicData mock_quic_data;
   QuicStreamOffset request_header_offset(0);
   QuicStreamOffset response_header_offset(0);
 
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &request_header_offset));
   // First request.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
 
   // Second request.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      4, kClientDataStreamId2, false, true,
+      4, GetNthClientInitiatedStreamId(1), false, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
-                                                   false, true, 0, "hello!"));
+      3, GetNthClientInitiatedStreamId(1), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(
       ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   AddHangingNonAlternateProtocolSocketData();
 
@@ skipping 30 matching lines @@
   ASSERT_NE(origin1.host(), origin2.host());
 
   MockQuicData mock_quic_data;
   QuicStreamOffset request_header_offset(0);
   QuicStreamOffset response_header_offset(0);
 
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &request_header_offset));
   // First request.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
 
   // Second request.
   QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2.host(),
                                     Perspective::IS_CLIENT);
   QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2.host(),
                                     Perspective::IS_SERVER);
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      4, kClientDataStreamId2, false, true,
+      4, GetNthClientInitiatedStreamId(1), false, true,
       GetRequestHeaders("GET", "https", "/", &client_maker2),
       &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
-                                                   false, true, 0, "hello!"));
+      3, GetNthClientInitiatedStreamId(1), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(
       ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   AddHangingNonAlternateProtocolSocketData();
 
@@ skipping 70 matching lines @@
 
   QuicTestPacketMaker client_maker(version_, 0, &clock_, "mail.example.org",
                                    Perspective::IS_CLIENT);
   server_maker_.set_hostname("www.example.org");
   client_maker_.set_hostname("www.example.org");
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &request_header_offset));
   // First QUIC request data.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &request_header_offset));
 
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(
-      2, kClientDataStreamId1, false, true, 0, "hello from mail QUIC!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(
+      ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), false,
+                                true, 0, "hello from mail QUIC!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   // Second QUIC request data.
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      4, kClientDataStreamId2, false, true,
+      4, GetNthClientInitiatedStreamId(1), false, true,
       GetRequestHeaders("GET", "https", "/", &client_maker),
       &request_header_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
-      &response_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(
-      4, kClientDataStreamId2, false, true, 0, "hello from mail QUIC!"));
+      3, GetNthClientInitiatedStreamId(1), false, false,
+      GetResponseHeaders("200 OK"), &response_header_offset));
+  mock_quic_data.AddRead(
+      ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), false,
+                                true, 0, "hello from mail QUIC!"));
   mock_quic_data.AddWrite(
       ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
@@ skipping 51 matching lines @@
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   AlternativeService alternative_service(kProtoQUIC,
@@ skipping 25 matching lines @@
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo().
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 // Tests that the connection to an HTTPS proxy is raced with an available
 // alternative proxy server.
 TEST_P(QuicNetworkTransactionTest, QuicProxyWithRacing) {
   base::HistogramTester histogram_tester;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("HTTPS mail.example.org:443");
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // There is no need to set up main job, because no attempt will be made to
   // speak to the proxy over TCP.
   request_.url = GURL("http://mail.example.org/");
   TestProxyDelegate test_proxy_delegate;
@@ skipping 70 matching lines @@
 
   ASSERT_TRUE(http_data2.AllReadDataConsumed());
   ASSERT_TRUE(http_data2.AllWriteDataConsumed());
   ASSERT_TRUE(quic_data.AllReadDataConsumed());
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
+      1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 
   EXPECT_EQ(nullptr,
             http_server_properties_.GetServerNetworkStats(
                 url::SchemeHostPort("https", request_.url.host(), 443)));
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
+      1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
@@ skipping 45 matching lines @@
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
@@ skipping 26 matching lines @@
   CheckResponseData(&trans, "hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest,
        LogGranularQuicErrorCodeOnQuicProtocolErrorLocal) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   // Read a close connection packet with
   // QuicErrorCode: QUIC_CRYPTO_VERSION_NOT_SUPPORTED from the peer.
   mock_quic_data.AddRead(ConstructServerConnectionClosePacket(1));
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
@@ skipping 32 matching lines @@
   EXPECT_EQ(QUIC_CRYPTO_VERSION_NOT_SUPPORTED, details.quic_connection_error);
 }
 
 TEST_P(QuicNetworkTransactionTest,
        LogGranularQuicErrorCodeOnQuicProtocolErrorRemote) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   // Peer sending data from an non-existing stream causes this end to raise
   // error and close connection.
   mock_quic_data.AddRead(
       ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR));
   std::string quic_error_details = "Data for nonexistent stream";
   mock_quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket(
       3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID,
       quic_error_details));
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
@@ skipping 34 matching lines @@
   trans.PopulateNetErrorDetails(&details);
   EXPECT_EQ(QUIC_INVALID_STREAM_ID, details.quic_connection_error);
 }
 
 TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   // Read the response headers, then a RST_STREAM frame.
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(ConstructServerRstPacket(
-      2, false, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
+      2, false, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more read data.
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
@@ skipping 35 matching lines @@
   std::string response_data;
   ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, ReadTransaction(&trans, &response_data));
 }
 
 TEST_P(QuicNetworkTransactionTest, RstSteamBeforeHeaders) {
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerRstPacket(
-      1, false, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
+      1, false, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more read data.
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
@@ skipping 198 matching lines @@
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
 
   ExpectBrokenAlternateProtocolMapping();
 }
 
 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
+      1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1, 1, 1));
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // When the QUIC connection fails, we will try the request again over HTTP.
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
@@ skipping 45 matching lines @@
   TestAlternativeProxy(ERR_IO_PENDING);
 }
 TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyAddressUnreachable) {
   TestAlternativeProxy(ERR_ADDRESS_UNREACHABLE);
 }
 
 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnectProxy) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
+      1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1, 1, 1));
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // When the QUIC connection fails, we will try the request again over HTTP.
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
@@ skipping 33 matching lines @@
 
 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
   client_maker_.set_hostname("www.example.org");
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more read data.
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(
@@ skipping 88 matching lines @@
 
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
   params_.quic_migrate_sessions_on_network_change = true;
 
   MockQuicData socket_data;
   socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   QuicStreamOffset offset = 0;
   socket_data.AddWrite(ConstructInitialSettingsPacket(1, &offset));
   socket_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, false,
+      2, GetNthClientInitiatedStreamId(0), true, false,
       GetRequestHeaders("POST", "https", "/"), &offset));
   socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED);
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   MockQuicData socket_data2;
   socket_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_INVALID);
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
@@ skipping 23 matching lines @@
 // Adds coverage to catch regression such as https://crbug.com/622043
 TEST_P(QuicNetworkTransactionTest, QuicServerPush) {
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   QuicStreamOffset server_header_offset = 0;
   mock_quic_data.AddRead(ConstructServerPushPromisePacket(
-      1, kClientDataStreamId1, kServerDataStreamId1, false,
-      GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset,
-      &server_maker_));
+      1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0),
+      false, GetRequestHeaders("GET", "https", "/pushed.jpg"),
+      &server_header_offset, &server_maker_));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
+      2, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      3, GetNthServerInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1));
   mock_quic_data.AddRead(ConstructServerDataPacket(
-      5, kServerDataStreamId1, false, true, 0, "and hello!"));
+      5, GetNthServerInitiatedStreamId(0), false, true, 0, "and hello!"));
   mock_quic_data.AddWrite(ConstructClientAckAndRstPacket(
-      5, kServerDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1));
+      5, GetNthServerInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
@@ skipping 18 matching lines @@
 TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) {
   params_.quic_force_hol_blocking = true;
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
 
   QuicStreamOffset offset = 0;
   mock_quic_data.AddWrite(ConstructInitialSettingsPacket(1, &offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, false,
+      2, GetNthClientInitiatedStreamId(0), true, false,
       GetRequestHeaders("POST", "https", "/"), &offset));
 
   std::unique_ptr<QuicEncryptedPacket> packet;
   if (version_ == QUIC_VERSION_36) {
-    packet = ConstructClientForceHolDataPacket(3, kClientDataStreamId1, true,
-                                               true, &offset, "1");
+    packet = ConstructClientForceHolDataPacket(
+        3, GetNthClientInitiatedStreamId(0), true, true, &offset, "1");
   } else {
-    packet =
-        ConstructClientDataPacket(3, kClientDataStreamId1, true, true, 0, "1");
+    packet = ConstructClientDataPacket(3, GetNthClientInitiatedStreamId(0),
+                                       true, true, 0, "1");
   }
   mock_quic_data.AddWrite(std::move(packet));
 
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
 
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
 
   mock_quic_data.AddWrite(ConstructClientAckPacket(4, 2, 1, 1));
 
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
@@ skipping 46 matching lines @@
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/"));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true, std::move(headers),
+      2, GetNthClientInitiatedStreamId(0), true, true, std::move(headers),
       &header_stream_offset));
 
   QuicStreamOffset expected_raw_header_response_size = 0;
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &expected_raw_header_response_size));
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &expected_raw_header_response_size));
 
-  mock_quic_data.AddRead(ConstructServerDataPacket(
-      2, kClientDataStreamId1, false, true, 0, "Main Resource Data"));
+  mock_quic_data.AddRead(
+      ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), false,
+                                true, 0, "Main Resource Data"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
 
   mock_quic_data.AddRead(ASYNC, 0);  // EOF
 
   CreateSession();
 
   TestDelegate delegate;
   QuicURLRequestContext quic_url_request_context(std::move(session_),
                                                  &socket_factory_);
 
@@ skipping 28 matching lines @@
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/"));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true, std::move(headers),
+      2, GetNthClientInitiatedStreamId(0), true, true, std::move(headers),
       &header_stream_offset));
 
   QuicStreamOffset server_header_offset = 0;
   QuicStreamOffset expected_raw_header_response_size = 0;
 
   mock_quic_data.AddRead(ConstructServerPushPromisePacket(
-      1, kClientDataStreamId1, kServerDataStreamId1, false,
-      GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset,
-      &server_maker_));
+      1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0),
+      false, GetRequestHeaders("GET", "https", "/pushed.jpg"),
+      &server_header_offset, &server_maker_));
 
   expected_raw_header_response_size = server_header_offset;
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
+      2, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
   expected_raw_header_response_size =
       server_header_offset - expected_raw_header_response_size;
 
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
 
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(
-      4, kServerDataStreamId1, false, true, 0, "Pushed Resource Data"));
+      3, GetNthServerInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
+  mock_quic_data.AddRead(
+      ConstructServerDataPacket(4, GetNthServerInitiatedStreamId(0), false,
+                                true, 0, "Pushed Resource Data"));
 
   mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1));
-  mock_quic_data.AddRead(ConstructServerDataPacket(
-      5, kClientDataStreamId1, false, true, 0, "Main Resource Data"));
+  mock_quic_data.AddRead(
+      ConstructServerDataPacket(5, GetNthClientInitiatedStreamId(0), false,
+                                true, 0, "Main Resource Data"));
 
   mock_quic_data.AddRead(ConstructServerConnectionClosePacket(6));
 
   CreateSession();
 
   TestDelegate delegate;
   QuicURLRequestContext quic_url_request_context(std::move(session_),
                                                  &socket_factory_);
 
   mock_quic_data.AddSocketDataToFactory(
@@ skipping 215 matching lines @@
     ASSERT_TRUE(response != nullptr);
     ASSERT_TRUE(response->headers.get() != nullptr);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_alpn_negotiated);
     EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_),
               response->connection_info);
     EXPECT_EQ(443, response->socket_address.port());
   }
 
+  QuicStreamId GetNthClientInitiatedStreamId(int n) {
+    return test::GetNthClientInitiatedStreamId(version_, n);
+  }
+
   MockClock clock_;
   QuicVersion version_;
   DestinationType destination_type_;
   std::string origin1_;
   std::string origin2_;
   std::unique_ptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;
@@ skipping 86 matching lines @@
   QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_,
                                     Perspective::IS_SERVER);
 
   QuicStreamOffset request_header_offset(0);
   QuicStreamOffset response_header_offset(0);
 
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(ConstructInitialSettingsPacket(
       1, &request_header_offset, &client_maker1));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, &request_header_offset, &client_maker1));
+      2, GetNthClientInitiatedStreamId(0), true, &request_header_offset,
+      &client_maker1));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, &response_header_offset, &server_maker1));
-  mock_quic_data.AddRead(
-      ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker1));
+      1, GetNthClientInitiatedStreamId(0), &response_header_offset,
+      &server_maker1));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), &server_maker1));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1, &client_maker1));
 
   QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2_,
                                     Perspective::IS_CLIENT);
   QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_,
                                     Perspective::IS_SERVER);
 
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      4, kClientDataStreamId2, false, &request_header_offset, &client_maker2));
+      4, GetNthClientInitiatedStreamId(1), false, &request_header_offset,
+      &client_maker2));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kClientDataStreamId2, &response_header_offset, &server_maker2));
-  mock_quic_data.AddRead(
-      ConstructServerDataPacket(4, kClientDataStreamId2, &server_maker2));
+      3, GetNthClientInitiatedStreamId(1), &response_header_offset,
+      &server_maker2));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(1), &server_maker2));
   mock_quic_data.AddWrite(ConstructClientAckPacket(5, 4, 3, 1, &client_maker2));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingSocketData();
   AddHangingSocketData();
 
   SendRequestAndExpectQuicResponse(origin1_);
@@ skipping 38 matching lines @@
   QuicTestPacketMaker client_maker1(version_, 0, &clock_, origin1_,
                                     Perspective::IS_CLIENT);
   QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_,
                                     Perspective::IS_SERVER);
 
   MockQuicData mock_quic_data1;
   QuicStreamOffset header_stream_offset1 = 0;
   mock_quic_data1.AddWrite(ConstructInitialSettingsPacket(
       1, &header_stream_offset1, &client_maker1));
   mock_quic_data1.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, &header_stream_offset1, &client_maker1));
+      2, GetNthClientInitiatedStreamId(0), true, &header_stream_offset1,
+      &client_maker1));
   mock_quic_data1.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, &server_maker1));
-  mock_quic_data1.AddRead(
-      ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker1));
+      1, GetNthClientInitiatedStreamId(0), &server_maker1));
+  mock_quic_data1.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), &server_maker1));
   mock_quic_data1.AddWrite(
       ConstructClientAckPacket(3, 2, 1, 1, &client_maker1));
   mock_quic_data1.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data1.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data1.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingSocketData();
 
   QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2_,
                                     Perspective::IS_CLIENT);
   QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_,
                                     Perspective::IS_SERVER);
 
   MockQuicData mock_quic_data2;
   QuicStreamOffset header_stream_offset2 = 0;
   mock_quic_data2.AddWrite(ConstructInitialSettingsPacket(
       1, &header_stream_offset2, &client_maker2));
   mock_quic_data2.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, &header_stream_offset2, &client_maker2));
+      2, GetNthClientInitiatedStreamId(0), true, &header_stream_offset2,
+      &client_maker2));
   mock_quic_data2.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, &server_maker2));
-  mock_quic_data2.AddRead(
-      ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker2));
+      1, GetNthClientInitiatedStreamId(0), &server_maker2));
+  mock_quic_data2.AddRead(ConstructServerDataPacket(
+      2, GetNthClientInitiatedStreamId(0), &server_maker2));
   mock_quic_data2.AddWrite(
       ConstructClientAckPacket(3, 2, 1, 1, &client_maker2));
   mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data2.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data2.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingSocketData();
 
   SendRequestAndExpectQuicResponse(origin1_);
   SendRequestAndExpectQuicResponse(origin2_);
 
   EXPECT_TRUE(AllDataConsumed());
 }
 
 // crbug.com/705109 - this confirms that matching request with a body
 // triggers a crash (pre-fix).
 TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) {
   params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      2, kClientDataStreamId1, true, true,
+      2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   QuicStreamOffset server_header_offset = 0;
   mock_quic_data.AddRead(ConstructServerPushPromisePacket(
-      1, kClientDataStreamId1, kServerDataStreamId1, false,
-      GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset,
-      &server_maker_));
+      1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0),
+      false, GetRequestHeaders("GET", "https", "/pushed.jpg"),
+      &server_header_offset, &server_maker_));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
+      2, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
-  mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
+      3, GetNthServerInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
+  mock_quic_data.AddRead(ConstructServerDataPacket(
+      4, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1));
   mock_quic_data.AddRead(ConstructServerDataPacket(
-      5, kServerDataStreamId1, false, true, 0, "and hello!"));
+      5, GetNthServerInitiatedStreamId(0), false, true, 0, "and hello!"));
 
   // Because the matching request has a body, we will see the push
   // stream get cancelled, and the matching request go out on the
   // wire.
   mock_quic_data.AddWrite(ConstructClientAckAndRstPacket(
-      5, kServerDataStreamId1, QUIC_STREAM_CANCELLED, 5, 5, 1));
+      5, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED, 5, 5, 1));
   const char kBody[] = "1";
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      6, kClientDataStreamId2, false, false,
+      6, GetNthClientInitiatedStreamId(1), false, false,
       GetRequestHeaders("GET", "https", "/pushed.jpg"), &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientMultipleDataFramesPacket(
-      7, kClientDataStreamId2, false, true, {kBody}, 0));
+      7, GetNthClientInitiatedStreamId(1), false, true, {kBody}, 0));
 
   // We see the same response as for the earlier pushed and cancelled
   // stream.
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      6, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
-      &server_header_offset));
+      6, GetNthClientInitiatedStreamId(1), false, false,
+      GetResponseHeaders("200 OK"), &server_header_offset));
   mock_quic_data.AddRead(ConstructServerDataPacket(
-      7, kClientDataStreamId2, false, true, 0, "and hello!"));
+      7, GetNthClientInitiatedStreamId(1), false, true, 0, "and hello!"));
 
   mock_quic_data.AddWrite(ConstructClientAckPacket(8, 7, 6, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
   // PUSH_PROMISE handling in the http layer gets exercised here.
   SendRequestAndExpectQuicResponse("hello!");
 
   request_.url = GURL("https://mail.example.org/pushed.jpg");
   ChunkedUploadDataStream upload_data(0);
   upload_data.AppendData("1", 1, true);
   request_.upload_data_stream = &upload_data;
   SendRequestAndExpectQuicResponse("and hello!");
 }
 
 }  // namespace test
 }  // namespace net