Landing recent QUIC changes until Sun Mar 5 09:18:09 2017 +0000

net/quic/core/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/core/quic_config.h"
 
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_time.h"
@@ skipping 15 matching lines @@
 };
 
 TEST_F(QuicConfigTest, ToHandshakeMessage) {
   config_.SetInitialStreamFlowControlWindowToSend(
       kInitialStreamFlowControlWindowForTest);
   config_.SetInitialSessionFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   config_.SetIdleNetworkTimeout(QuicTime::Delta::FromSeconds(5),
                                 QuicTime::Delta::FromSeconds(2));
   config_.SetMaxStreamsPerConnection(4, 2);
-  config_.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
+  if (!FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+    config_.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
+  }
   CryptoHandshakeMessage msg;
   config_.ToHandshakeMessage(&msg);
 
   uint32_t value;
   QuicErrorCode error = msg.GetUint32(kICSL, &value);
   EXPECT_EQ(QUIC_NO_ERROR, error);
   EXPECT_EQ(5u, value);
 
   error = msg.GetUint32(kMSPC, &value);
   EXPECT_EQ(QUIC_NO_ERROR, error);
   EXPECT_EQ(4u, value);
 
   error = msg.GetUint32(kSFCW, &value);
   EXPECT_EQ(QUIC_NO_ERROR, error);
   EXPECT_EQ(kInitialStreamFlowControlWindowForTest, value);
 
   error = msg.GetUint32(kCFCW, &value);
   EXPECT_EQ(QUIC_NO_ERROR, error);
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest, value);
 
-  error = msg.GetUint32(kSRBF, &value);
-  EXPECT_EQ(QUIC_NO_ERROR, error);
-  EXPECT_EQ(kDefaultSocketReceiveBuffer, value);
+  if (!FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+    error = msg.GetUint32(kSRBF, &value);
+    EXPECT_EQ(QUIC_NO_ERROR, error);
+    EXPECT_EQ(kDefaultSocketReceiveBuffer, value);
+  }
 }
 
 TEST_F(QuicConfigTest, ProcessClientHello) {
   QuicConfig client_config;
   QuicTagVector cgst;
   cgst.push_back(kQBIC);
   client_config.SetIdleNetworkTimeout(
       QuicTime::Delta::FromSeconds(2 * kMaximumIdleTimeoutSecs),
       QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs));
   client_config.SetMaxStreamsPerConnection(2 * kDefaultMaxStreamsPerConnection,
                                            kDefaultMaxStreamsPerConnection);
   client_config.SetInitialRoundTripTimeUsToSend(10 * kNumMicrosPerMilli);
   client_config.SetInitialStreamFlowControlWindowToSend(
       2 * kInitialStreamFlowControlWindowForTest);
   client_config.SetInitialSessionFlowControlWindowToSend(
       2 * kInitialSessionFlowControlWindowForTest);
-  client_config.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
+  if (!FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+    client_config.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
+  }
   client_config.SetForceHolBlocking();
   QuicTagVector copt;
   copt.push_back(kTBBR);
   client_config.SetConnectionOptionsToSend(copt);
   CryptoHandshakeMessage msg;
   client_config.ToHandshakeMessage(&msg);
 
   string error_details;
   QuicTagVector initial_received_options;
   initial_received_options.push_back(kIW50);
@@ skipping 15 matching lines @@
   EXPECT_EQ(10 * kNumMicrosPerMilli, config_.ReceivedInitialRoundTripTimeUs());
   EXPECT_TRUE(config_.ForceHolBlocking(Perspective::IS_SERVER));
   EXPECT_TRUE(config_.HasReceivedConnectionOptions());
   EXPECT_EQ(2u, config_.ReceivedConnectionOptions().size());
   EXPECT_EQ(config_.ReceivedConnectionOptions()[0], kIW50);
   EXPECT_EQ(config_.ReceivedConnectionOptions()[1], kTBBR);
   EXPECT_EQ(config_.ReceivedInitialStreamFlowControlWindowBytes(),
             2 * kInitialStreamFlowControlWindowForTest);
   EXPECT_EQ(config_.ReceivedInitialSessionFlowControlWindowBytes(),
             2 * kInitialSessionFlowControlWindowForTest);
-  EXPECT_EQ(config_.ReceivedSocketReceiveBuffer(), kDefaultSocketReceiveBuffer);
+  if (!FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+    EXPECT_EQ(config_.ReceivedSocketReceiveBuffer(),
+              kDefaultSocketReceiveBuffer);
+  }
 }
 
 TEST_F(QuicConfigTest, ProcessServerHello) {
   QuicIpAddress host;
   host.FromString("127.0.3.1");
   const QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
   QuicConfig server_config;
   QuicTagVector cgst;
   cgst.push_back(kQBIC);
   server_config.SetIdleNetworkTimeout(
       QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs / 2),
       QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs / 2));
   server_config.SetMaxStreamsPerConnection(kDefaultMaxStreamsPerConnection / 2,
                                            kDefaultMaxStreamsPerConnection / 2);
   server_config.SetInitialRoundTripTimeUsToSend(10 * kNumMicrosPerMilli);
   server_config.SetInitialStreamFlowControlWindowToSend(
       2 * kInitialStreamFlowControlWindowForTest);
   server_config.SetInitialSessionFlowControlWindowToSend(
       2 * kInitialSessionFlowControlWindowForTest);
-  server_config.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
+  if (!FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+    server_config.SetSocketReceiveBufferToSend(kDefaultSocketReceiveBuffer);
+  }
   server_config.SetAlternateServerAddressToSend(kTestServerAddress);
   CryptoHandshakeMessage msg;
   server_config.ToHandshakeMessage(&msg);
   string error_details;
   const QuicErrorCode error =
       config_.ProcessPeerHello(msg, SERVER, &error_details);
   EXPECT_EQ(QUIC_NO_ERROR, error);
   EXPECT_TRUE(config_.negotiated());
   EXPECT_EQ(QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs / 2),
             config_.IdleNetworkTimeout());
   EXPECT_EQ(kDefaultMaxStreamsPerConnection / 2,
             config_.MaxStreamsPerConnection());
   EXPECT_EQ(10 * kNumMicrosPerMilli, config_.ReceivedInitialRoundTripTimeUs());
   EXPECT_EQ(config_.ReceivedInitialStreamFlowControlWindowBytes(),
             2 * kInitialStreamFlowControlWindowForTest);
   EXPECT_EQ(config_.ReceivedInitialSessionFlowControlWindowBytes(),
             2 * kInitialSessionFlowControlWindowForTest);
-  EXPECT_EQ(config_.ReceivedSocketReceiveBuffer(), kDefaultSocketReceiveBuffer);
+  if (!FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+    EXPECT_EQ(config_.ReceivedSocketReceiveBuffer(),
+              kDefaultSocketReceiveBuffer);
+  }
   EXPECT_TRUE(config_.HasReceivedAlternateServerAddress());
   EXPECT_EQ(kTestServerAddress, config_.ReceivedAlternateServerAddress());
 }
 
 TEST_F(QuicConfigTest, MissingOptionalValuesInCHLO) {
   CryptoHandshakeMessage msg;
   msg.SetValue(kICSL, 1);
 
   // Set all REQUIRED tags.
   msg.SetValue(kICSL, 1);
@@ skipping 136 matching lines @@
   EXPECT_EQ(1u, config_.ReceivedConnectionOptions().size());
   EXPECT_FALSE(config_.HasClientRequestedIndependentOption(
       kRENO, Perspective::IS_SERVER));
   EXPECT_TRUE(config_.HasClientRequestedIndependentOption(
       kTBBR, Perspective::IS_SERVER));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net