QUIC - stream id refactor for tests.

net/quic/chromium/quic_chromium_client_session_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/chromium/quic_chromium_client_session.h"
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
@@ skipping 139 matching lines @@
 
   QuicChromiumPacketWriter* CreateQuicChromiumPacketWriter(
       DatagramClientSocket* socket,
       QuicChromiumClientSession* session) const {
     std::unique_ptr<QuicChromiumPacketWriter> writer(
         new QuicChromiumPacketWriter(socket));
     writer->set_delegate(session);
     return writer.release();
   }
 
+  QuicStreamId GetNthClientInitiatedStreamId(int n) {
+    return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(*session_, n);
+  }
+
+  QuicStreamId GetNthServerInitiatedStreamId(int n) {
+    return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(*session_, n);
+  }
+
   QuicCryptoClientConfig crypto_config_;
   TestNetLog net_log_;
   BoundTestNetLog bound_test_net_log_;
   MockClientSocketFactory socket_factory_;
   std::unique_ptr<MockRead> default_read_;
   std::unique_ptr<SequencedSocketData> socket_data_;
   MockClock clock_;
   MockRandom random_;
   QuicChromiumConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
@@ skipping 91 matching lines @@
   EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
 
   quic_data.Resume();
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) {
   MockQuicData quic_data;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1,
-                                                 QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Request a stream and cancel it without releasing the stream.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
       session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
   stream_request.reset();
 
   quic_data.Resume();
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1,
-                                                 QUIC_RST_ACKNOWLEDGEMENT));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Open the maximum number of streams so that a subsequent request
   // can not proceed immediately.
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     session_->CreateOutgoingDynamicStream(kDefaultPriority);
   }
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
       session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
   // Close a stream and ensure the stream request completes.
-  QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_CANCELLED, 0);
+  QuicRstStreamFrame rst(GetNthClientInitiatedStreamId(0),
+                         QUIC_STREAM_CANCELLED, 0);
   session_->OnRstStream(rst);
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
 
   quic_data.Resume();
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1,
-                                                 QUIC_RST_ACKNOWLEDGEMENT));
+  quic_data.AddWrite(client_maker_.MakeRstPacket(
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Open the maximum number of streams so that a subsequent request
   // can not proceed immediately.
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     session_->CreateOutgoingDynamicStream(kDefaultPriority);
   }
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
       session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
   // Cancel the pending stream request.
   stream_request.reset();
 
   // Close a stream and ensure that no new stream is created.
-  QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_CANCELLED, 0);
+  QuicRstStreamFrame rst(GetNthClientInitiatedStreamId(0),
+                         QUIC_STREAM_CANCELLED, 0);
   session_->OnRstStream(rst);
   EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams());
 
   quic_data.Resume();
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) {
   MockQuicData quic_data;
@@ skipping 76 matching lines @@
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
 
   Initialize();
   CompleteCryptoHandshake();
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams());
   EXPECT_TRUE(session_->CreateOutgoingDynamicStream(kDefaultPriority));
 }
 
 TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutNoResponse) {
   base::HistogramTester histogram_tester;
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kServerDataStreamId1, QUIC_PUSH_STREAM_TIMED_OUT));
+      2, true, GetNthServerInitiatedStreamId(0), QUIC_PUSH_STREAM_TIMED_OUT));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
   Initialize();
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
   session_->OnProofVerifyDetailsAvailable(details);
 
   QuicChromiumClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   EXPECT_TRUE(stream);
 
   SpdyHeaderBlock promise_headers;
   promise_headers[":method"] = "GET";
   promise_headers[":authority"] = "www.example.org";
   promise_headers[":scheme"] = "https";
   promise_headers[":path"] = "/pushed.jpg";
 
   // Receive a PUSH PROMISE from the server.
-  EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1,
-                                       promise_headers));
+  EXPECT_TRUE(session_->HandlePromised(
+      stream->id(), GetNthServerInitiatedStreamId(0), promise_headers));
 
   QuicClientPromisedInfo* promised =
-      session_->GetPromisedById(kServerDataStreamId1);
+      session_->GetPromisedById(GetNthServerInitiatedStreamId(0));
   EXPECT_TRUE(promised);
   // Fire alarm to time out the push stream.
   alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised));
   EXPECT_FALSE(
       session_->GetPromisedByUrl("https://www.example.org/pushed.jpg"));
   EXPECT_EQ(0u,
             QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get()));
   EXPECT_EQ(0u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount(
                     session_.get()));
 }
 
 TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutWithResponse) {
   base::HistogramTester histogram_tester;
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kServerDataStreamId1, QUIC_PUSH_STREAM_TIMED_OUT));
+      2, true, GetNthServerInitiatedStreamId(0), QUIC_PUSH_STREAM_TIMED_OUT));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
   Initialize();
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
   session_->OnProofVerifyDetailsAvailable(details);
 
   QuicChromiumClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   EXPECT_TRUE(stream);
 
   SpdyHeaderBlock promise_headers;
   promise_headers[":method"] = "GET";
   promise_headers[":authority"] = "www.example.org";
   promise_headers[":scheme"] = "https";
   promise_headers[":path"] = "/pushed.jpg";
 
-  session_->GetOrCreateStream(kServerDataStreamId1);
+  session_->GetOrCreateStream(GetNthServerInitiatedStreamId(0));
   // Receive a PUSH PROMISE from the server.
-  EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1,
-                                       promise_headers));
-  session_->OnInitialHeadersComplete(kServerDataStreamId1, SpdyHeaderBlock());
+  EXPECT_TRUE(session_->HandlePromised(
+      stream->id(), GetNthServerInitiatedStreamId(0), promise_headers));
+  session_->OnInitialHeadersComplete(GetNthServerInitiatedStreamId(0),
+                                     SpdyHeaderBlock());
   // Read data on the pushed stream.
-  QuicStreamFrame data(kServerDataStreamId1, false, 0, QuicStringPiece("SP"));
+  QuicStreamFrame data(GetNthServerInitiatedStreamId(0), false, 0,
+                       QuicStringPiece("SP"));
   session_->OnStreamFrame(data);
 
   QuicClientPromisedInfo* promised =
-      session_->GetPromisedById(kServerDataStreamId1);
+      session_->GetPromisedById(GetNthServerInitiatedStreamId(0));
   EXPECT_TRUE(promised);
   // Fire alarm to time out the push stream.
   alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised));
   EXPECT_EQ(2u,
             QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get()));
   EXPECT_EQ(2u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount(
                     session_.get()));
 }
 
 TEST_P(QuicChromiumClientSessionTest, CancelPushWhenPendingValidation) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
 
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
   Initialize();
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
   session_->OnProofVerifyDetailsAvailable(details);
 
   QuicChromiumClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   EXPECT_TRUE(stream);
 
   SpdyHeaderBlock promise_headers;
   promise_headers[":method"] = "GET";
   promise_headers[":authority"] = "www.example.org";
   promise_headers[":scheme"] = "https";
   promise_headers[":path"] = "/pushed.jpg";
 
   // Receive a PUSH PROMISE from the server.
-  EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1,
-                                       promise_headers));
+  EXPECT_TRUE(session_->HandlePromised(
+      stream->id(), GetNthServerInitiatedStreamId(0), promise_headers));
 
   QuicClientPromisedInfo* promised =
-      session_->GetPromisedById(kServerDataStreamId1);
+      session_->GetPromisedById(GetNthServerInitiatedStreamId(0));
   EXPECT_TRUE(promised);
 
   // Initiate rendezvous.
   SpdyHeaderBlock client_request = promise_headers.Clone();
   TestPushPromiseDelegate delegate(/*match=*/true);
   promised->HandleClientRequest(client_request, &delegate);
 
   // Cancel the push before receiving the response to the pushed request.
   GURL pushed_url("https://www.example.org/pushed.jpg");
   test_push_delegate_.CancelPush(pushed_url);
   EXPECT_TRUE(session_->GetPromisedByUrl(pushed_url.spec()));
 
   // Reset the stream now before tear down.
-  session_->CloseStream(kClientDataStreamId1);
+  session_->CloseStream(GetNthClientInitiatedStreamId(0));
 }
 
 TEST_P(QuicChromiumClientSessionTest, CancelPushBeforeReceivingResponse) {
   base::HistogramTester histogram_tester;
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kServerDataStreamId1, QUIC_STREAM_CANCELLED));
+      2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
   Initialize();
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
   session_->OnProofVerifyDetailsAvailable(details);
 
   QuicChromiumClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   EXPECT_TRUE(stream);
 
   SpdyHeaderBlock promise_headers;
   promise_headers[":method"] = "GET";
   promise_headers[":authority"] = "www.example.org";
   promise_headers[":scheme"] = "https";
   promise_headers[":path"] = "/pushed.jpg";
 
   // Receive a PUSH PROMISE from the server.
-  EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1,
-                                       promise_headers));
+  EXPECT_TRUE(session_->HandlePromised(
+      stream->id(), GetNthServerInitiatedStreamId(0), promise_headers));
 
   QuicClientPromisedInfo* promised =
-      session_->GetPromisedById(kServerDataStreamId1);
+      session_->GetPromisedById(GetNthServerInitiatedStreamId(0));
   EXPECT_TRUE(promised);
   // Cancel the push before receiving the response to the pushed request.
   GURL pushed_url("https://www.example.org/pushed.jpg");
   test_push_delegate_.CancelPush(pushed_url);
 
   EXPECT_FALSE(session_->GetPromisedByUrl(pushed_url.spec()));
   EXPECT_EQ(0u,
             QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get()));
   EXPECT_EQ(0u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount(
                     session_.get()));
 }
 
 TEST_P(QuicChromiumClientSessionTest, CancelPushAfterReceivingResponse) {
   base::HistogramTester histogram_tester;
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kServerDataStreamId1, QUIC_STREAM_CANCELLED));
+      2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
   Initialize();
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
   session_->OnProofVerifyDetailsAvailable(details);
 
   QuicChromiumClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   EXPECT_TRUE(stream);
 
   SpdyHeaderBlock promise_headers;
   promise_headers[":method"] = "GET";
   promise_headers[":authority"] = "www.example.org";
   promise_headers[":scheme"] = "https";
   promise_headers[":path"] = "/pushed.jpg";
 
-  session_->GetOrCreateStream(kServerDataStreamId1);
+  session_->GetOrCreateStream(GetNthServerInitiatedStreamId(0));
   // Receive a PUSH PROMISE from the server.
-  EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1,
-                                       promise_headers));
-  session_->OnInitialHeadersComplete(kServerDataStreamId1, SpdyHeaderBlock());
+  EXPECT_TRUE(session_->HandlePromised(
+      stream->id(), GetNthServerInitiatedStreamId(0), promise_headers));
+  session_->OnInitialHeadersComplete(GetNthServerInitiatedStreamId(0),
+                                     SpdyHeaderBlock());
   // Read data on the pushed stream.
-  QuicStreamFrame data(kServerDataStreamId1, false, 0, QuicStringPiece("SP"));
+  QuicStreamFrame data(GetNthServerInitiatedStreamId(0), false, 0,
+                       QuicStringPiece("SP"));
   session_->OnStreamFrame(data);
 
   QuicClientPromisedInfo* promised =
-      session_->GetPromisedById(kServerDataStreamId1);
+      session_->GetPromisedById(GetNthServerInitiatedStreamId(0));
   EXPECT_TRUE(promised);
   // Cancel the push after receiving data on the push stream.
   GURL pushed_url("https://www.example.org/pushed.jpg");
   test_push_delegate_.CancelPush(pushed_url);
 
   EXPECT_FALSE(session_->GetPromisedByUrl(pushed_url.spec()));
   EXPECT_EQ(2u,
             QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get()));
   EXPECT_EQ(2u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount(
                     session_.get()));
 }
 
 TEST_P(QuicChromiumClientSessionTest, Priority) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
 
   Initialize();
   CompleteCryptoHandshake();
   for (SpdyPriority priority : {kV3HighestPriority, kV3LowestPriority}) {
     QuicChromiumClientStream* stream =
         session_->CreateOutgoingDynamicStream(priority);
     EXPECT_EQ(kV3HighestPriority, stream->priority());
 
     MockStreamDelegate delegate;
     EXPECT_CALL(delegate, HasSendHeadersComplete())
         .WillOnce(testing::Return(true));
     stream->SetDelegate(&delegate);
     EXPECT_EQ(priority, stream->priority());
     stream->SetDelegate(nullptr);
     session_->CloseStream(stream->id());
   }
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   std::unique_ptr<QuicEncryptedPacket> settings_packet(
       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket(
-      2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
+      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
   MockWrite writes[] = {
       MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1),
       MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)};
   socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
                                              arraysize(writes)));
 
   Initialize();
   CompleteCryptoHandshake();
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
 
@@ skipping 350 matching lines @@
 
   EXPECT_TRUE(socket_data_->AllReadDataConsumed());
   EXPECT_TRUE(socket_data_->AllWriteDataConsumed());
   EXPECT_TRUE(new_socket_data.AllReadDataConsumed());
   EXPECT_TRUE(new_socket_data.AllWriteDataConsumed());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net