Call SetDefaults from the QuicConfig constructor instead of requiring

net/quic/quic_config_test.cc

 // Copyright (c) 2013 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/quic_config.h"
 
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_time.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 
 namespace net {
 namespace test {
 namespace {
 
 class QuicConfigTest : public ::testing::Test {
  protected:
-  QuicConfigTest() {
-    config_.SetDefaults();
-  }
-
   QuicConfig config_;
 };
 
 TEST_F(QuicConfigTest, ToHandshakeMessage) {
-  config_.SetDefaults();
   config_.SetInitialFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   config_.SetInitialStreamFlowControlWindowToSend(
       kInitialStreamFlowControlWindowForTest);
   config_.SetInitialSessionFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   config_.SetIdleConnectionStateLifetime(QuicTime::Delta::FromSeconds(5),
                                          QuicTime::Delta::FromSeconds(2));
   config_.SetMaxStreamsPerConnection(4, 2);
   config_.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
@@ skipping 214 matching lines @@
   CryptoHandshakeMessage msg;
   server_config.ToHandshakeMessage(&msg);
   string error_details;
   const QuicErrorCode error =
       config_.ProcessPeerHello(msg, SERVER, &error_details);
   EXPECT_EQ(QUIC_INVALID_NEGOTIATED_VALUE, error);
 }
 
 TEST_F(QuicConfigTest, NoOverLapInCGST) {
   QuicConfig server_config;
-  server_config.SetDefaults();
   QuicTagVector cgst;
   cgst.push_back(kTBBR);
   server_config.SetCongestionFeedback(cgst, kTBBR);
 
   CryptoHandshakeMessage msg;
   string error_details;
   server_config.ToHandshakeMessage(&msg);
   const QuicErrorCode error =
       config_.ProcessPeerHello(msg, CLIENT, &error_details);
   DVLOG(1) << QuicUtils::ErrorToString(error);
   EXPECT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP, error);
 }
 
 TEST_F(QuicConfigTest, InvalidFlowControlWindow) {
   // QuicConfig should not accept an invalid flow control window to send to the
   // peer: the receive window must be at least the default of 16 Kb.
   QuicConfig config;
   const uint64 kInvalidWindow = kDefaultFlowControlSendWindow - 1;
   EXPECT_DFATAL(config.SetInitialFlowControlWindowToSend(kInvalidWindow),
                 "Initial flow control receive window");
 
   EXPECT_EQ(kDefaultFlowControlSendWindow,
             config.GetInitialFlowControlWindowToSend());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net