Landing recent QUIC changes until 6/24/2016 14:00 UTC

net/tools/quic/quic_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/tools/quic/quic_client_session.h"
 
 #include <vector>
 
 #include "base/strings/stringprintf.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_quic_spdy_client_stream.h"
+#include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPrintf;
 using google::protobuf::implicit_cast;
 using net::test::ConstructEncryptedPacket;
@@ skipping 79 matching lines @@
     session_->Initialize();
     push_promise_[":path"] = "/bar";
     push_promise_[":authority"] = "www.google.com";
     push_promise_[":version"] = "HTTP/1.1";
     push_promise_[":method"] = "GET";
     push_promise_[":scheme"] = "https";
     promise_url_ = SpdyUtils::GetUrlFromHeaderBlock(push_promise_);
   }
 
   void CompleteCryptoHandshake() {
+    CompleteCryptoHandshake(kDefaultMaxStreamsPerConnection);
+  }
+
+  void CompleteCryptoHandshake(uint32_t server_max_incoming_streams) {
     session_->CryptoConnect();
     QuicCryptoClientStream* stream =
         static_cast<QuicCryptoClientStream*>(session_->GetCryptoStream());
     CryptoTestUtils::FakeServerOptions options;
-    CryptoTestUtils::HandshakeWithFakeServer(&helper_, &alarm_factory_,
+    QuicConfig config = DefaultQuicConfig();
+    config.SetMaxIncomingDynamicStreamsToSend(server_max_incoming_streams);
+    CryptoTestUtils::HandshakeWithFakeServer(&config, &helper_, &alarm_factory_,
                                              connection_, stream, options);
   }
 
   QuicCryptoClientConfig crypto_config_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   PacketSavingConnection* connection_;
   std::unique_ptr<TestQuicClientSession> session_;
   QuicClientPushPromiseIndex push_promise_index_;
   SpdyHeaderBlock push_promise_;
@@ skipping 46 matching lines @@
   QuicIOVector iovector(&iov, 1, iov.iov_len);
   QuicConsumedData consumed =
       session_->WritevData(stream, stream->id(), iovector, 0, false, nullptr);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_EQ(0u, consumed.bytes_consumed);
 }
 
 TEST_P(QuicClientSessionTest, MaxNumStreamsWithNoFinOrRst) {
   EXPECT_CALL(*connection_, SendRstStream(_, _, _)).Times(AnyNumber());
 
-  session_->config()->SetMaxStreamsPerConnection(1, 1);
+  if (GetParam() <= QUIC_VERSION_34) {
+    session_->config()->SetMaxStreamsPerConnection(1, 1);
 
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
+    // Initialize crypto before the client session will create a stream.
+    CompleteCryptoHandshake();
+  } else {
+    const uint32_t kServerMaxIncomingStreams = 1;
+    CompleteCryptoHandshake(kServerMaxIncomingStreams);
+  }
 
   QuicSpdyClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   ASSERT_TRUE(stream);
   EXPECT_FALSE(session_->CreateOutgoingDynamicStream(kDefaultPriority));
 
   // Close the stream, but without having received a FIN or a RST_STREAM
   // and check that a new one can not be created.
   session_->CloseStream(stream->id());
   EXPECT_EQ(1u, session_->GetNumOpenOutgoingStreams());
 
   stream = session_->CreateOutgoingDynamicStream(kDefaultPriority);
   EXPECT_FALSE(stream);
 }
 
 TEST_P(QuicClientSessionTest, MaxNumStreamsWithRst) {
   EXPECT_CALL(*connection_, SendRstStream(_, _, _)).Times(AnyNumber());
 
-  session_->config()->SetMaxStreamsPerConnection(1, 1);
+  if (GetParam() <= QUIC_VERSION_34) {
+    session_->config()->SetMaxStreamsPerConnection(1, 1);
 
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
+    // Initialize crypto before the client session will create a stream.
+    CompleteCryptoHandshake();
+  } else {
+    const uint32_t kServerMaxIncomingStreams = 1;
+    CompleteCryptoHandshake(kServerMaxIncomingStreams);
+  }
 
   QuicSpdyClientStream* stream =
       session_->CreateOutgoingDynamicStream(kDefaultPriority);
   ASSERT_TRUE(stream);
   EXPECT_FALSE(session_->CreateOutgoingDynamicStream(kDefaultPriority));
 
   // Close the stream and receive an RST frame to remove the unfinished stream
   session_->CloseStream(stream->id());
   session_->OnRstStream(QuicRstStreamFrame(
       stream->id(), AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()),
@@ skipping 288 matching lines @@
   QuicClientPromisedInfo* promised =
       session_->GetPromisedById(promised_stream_id_);
   EXPECT_NE(promised, nullptr);
   EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
   EXPECT_EQ(session_->GetPromisedStream(promised_stream_id_), nullptr);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net