Flag-protected. Add stateless reject support to crypto streams.

net/quic/test_tools/quic_test_utils.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/test_tools/quic_test_utils.h"
 
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/crypto/crypto_framer.h"
@@ skipping 363 matching lines @@
 TestClientSession::~TestClientSession() {}
 
 void TestClientSession::SetCryptoStream(QuicCryptoStream* stream) {
   crypto_stream_ = stream;
 }
 
 QuicCryptoStream* TestClientSession::GetCryptoStream() {
   return crypto_stream_;
 }
 
+TestServerSession::TestServerSession(const QuicConfig& config,
+                                     QuicConnection* connection)
+    : QuicServerSession(config, connection, nullptr) {
+}
+
+TestServerSession::~TestServerSession() {
+}
+
 MockPacketWriter::MockPacketWriter() {
 }
 
 MockPacketWriter::~MockPacketWriter() {
 }
 
 MockSendAlgorithm::MockSendAlgorithm() {
 }
 
 MockSendAlgorithm::~MockSendAlgorithm() {
@@ skipping 310 matching lines @@
 
 QuicConfig DefaultQuicConfig() {
   QuicConfig config;
   config.SetInitialStreamFlowControlWindowToSend(
       kInitialStreamFlowControlWindowForTest);
   config.SetInitialSessionFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   return config;
 }
 
+QuicConfig DefaultQuicConfigStatelessRejects() {
+  QuicConfig config = DefaultQuicConfig();
+  QuicTagVector copt;
+  copt.push_back(kSREJ);
+  config.SetConnectionOptionsToSend(copt);
+  return config;
+}
+
 QuicVersionVector SupportedVersions(QuicVersion version) {
   QuicVersionVector versions;
   versions.push_back(version);
   return versions;
 }
 
 TestWriterFactory::TestWriterFactory() : current_writer_(nullptr) {}
 TestWriterFactory::~TestWriterFactory() {}
 
 QuicPacketWriter* TestWriterFactory::Create(QuicPacketWriter* writer,
@@ skipping 29 matching lines @@
 WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket(
     const char* buffer,
     size_t buf_len,
     const IPAddressNumber& self_address,
     const IPEndPoint& peer_address) {
   // A DCHECK(factory_current_writer_ == nullptr) would be wrong here -- this
   // class may be used in a setting where connection()->OnPacketSent() is called
   // in a different way, so TestWriterFactory::OnPacketSent might never be
   // called.
   factory_->current_writer_ = this;
-  return tools::QuicPerConnectionPacketWriter::WritePacket(buffer,
-                                                    buf_len,
-                                                    self_address,
-                                                    peer_address);
+  return tools::QuicPerConnectionPacketWriter::WritePacket(
+      buffer, buf_len, self_address, peer_address);
 }
 
 MockQuicConnectionDebugVisitor::MockQuicConnectionDebugVisitor() {
 }
 
 MockQuicConnectionDebugVisitor::~MockQuicConnectionDebugVisitor() {
 }
 
+void SetupCryptoClientStreamForTest(
+    QuicServerId server_id,
+    bool supports_stateless_rejects,
+    QuicTime::Delta connection_start_time,
+    QuicCryptoClientConfig* crypto_client_config,
+    PacketSavingConnection** client_connection,
+    TestClientSession** client_session,
+    QuicCryptoClientStream** client_stream) {
+  CHECK(crypto_client_config);
+  CHECK(client_connection);
+  CHECK(client_session);
+  CHECK(client_stream);
+  CHECK(!connection_start_time.IsZero())
+      << "Connections must start at non-zero times, otherwise the "
+      << "strike-register will be unhappy.";
+
+  QuicConfig config = supports_stateless_rejects
+                          ? DefaultQuicConfigStatelessRejects()
+                          : DefaultQuicConfig();
+  *client_connection = new PacketSavingConnection(Perspective::IS_CLIENT);
+  *client_session = new TestClientSession(*client_connection, config);
+  *client_stream = new QuicCryptoClientStream(server_id, *client_session,
+                                              nullptr, crypto_client_config);
+  (*client_session)->SetCryptoStream(*client_stream);
+  (*client_connection)->AdvanceTime(connection_start_time);
+}
+
+// Setup or create?
+void SetupCryptoServerStreamForTest(
+    QuicServerId server_id,
+    QuicTime::Delta connection_start_time,
+    QuicCryptoServerConfig* server_crypto_config,
+    PacketSavingConnection** server_connection,
+    TestServerSession** server_session,
+    QuicCryptoServerStream** server_stream) {
+  CHECK(server_crypto_config);
+  CHECK(server_connection);
+  CHECK(server_session);
+  CHECK(server_stream);
+  CHECK(!connection_start_time.IsZero())
+      << "Connections must start at non-zero times, otherwise the "
+      << "strike-register will be unhappy.";
+
+  *server_connection = new PacketSavingConnection(Perspective::IS_SERVER);
+  *server_session =
+      new TestServerSession(DefaultQuicConfig(), *server_connection);
+  *server_stream =
+      new QuicCryptoServerStream(server_crypto_config, *server_session);
+  (*server_session)->InitializeSession(server_crypto_config);
+
+  // We advance the clock initially because the default time is zero and the
+  // strike register worries that we've just overflowed a uint32 time.
+  (*server_connection)->AdvanceTime(connection_start_time);
+}
+
 }  // namespace test
 }  // namespace net