Landing Recent QUIC changes until Mon Apr 17 2017

net/quic/core/quic_config.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 <algorithm>
 
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
-#include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_flag_utils.h"
+#include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 
 using std::string;
 
 namespace net {
 
 // Reads the value corresponding to |name_| from |msg| into |out|. If the
 // |name_| is absent in |msg| and |presence| is set to OPTIONAL |out| is set
 // to |default_value|.
@@ skipping 308 matching lines @@
       max_streams_per_connection_(kMSPC, PRESENCE_OPTIONAL),
       max_incoming_dynamic_streams_(kMIDS, PRESENCE_OPTIONAL),
       bytes_for_connection_id_(kTCID, PRESENCE_OPTIONAL),
       initial_round_trip_time_us_(kIRTT, PRESENCE_OPTIONAL),
       initial_stream_flow_control_window_bytes_(kSFCW, PRESENCE_OPTIONAL),
       initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
       socket_receive_buffer_(kSRBF, PRESENCE_OPTIONAL),
       connection_migration_disabled_(kNCMR, PRESENCE_OPTIONAL),
       alternate_server_address_(kASAD, PRESENCE_OPTIONAL),
       force_hol_blocking_(kFHL2, PRESENCE_OPTIONAL),
-      support_max_header_list_size_(kSMHL, PRESENCE_OPTIONAL),
-      latched_no_socket_receive_buffer_(
-          FLAGS_quic_reloadable_flag_quic_no_socket_receive_buffer) {
+      support_max_header_list_size_(kSMHL, PRESENCE_OPTIONAL) {
   SetDefaults();
 }
 
 QuicConfig::QuicConfig(const QuicConfig& other) = default;
 
 QuicConfig::~QuicConfig() {}
 
 bool QuicConfig::SetInitialReceivedConnectionOptions(
     const QuicTagVector& tags) {
   if (HasReceivedConnectionOptions()) {
@@ skipping 180 matching lines @@
 }
 
 bool QuicConfig::HasReceivedInitialSessionFlowControlWindowBytes() const {
   return initial_session_flow_control_window_bytes_.HasReceivedValue();
 }
 
 uint32_t QuicConfig::ReceivedInitialSessionFlowControlWindowBytes() const {
   return initial_session_flow_control_window_bytes_.GetReceivedValue();
 }
 
-void QuicConfig::SetSocketReceiveBufferToSend(uint32_t tcp_receive_window) {
-  if (latched_no_socket_receive_buffer_) {
-    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_no_socket_receive_buffer, 1, 3);
-  } else {
-    socket_receive_buffer_.SetSendValue(tcp_receive_window);
-  }
-}
-
-bool QuicConfig::HasReceivedSocketReceiveBuffer() const {
-  return socket_receive_buffer_.HasReceivedValue();
-}
-
-uint32_t QuicConfig::ReceivedSocketReceiveBuffer() const {
-  return socket_receive_buffer_.GetReceivedValue();
-}
-
 void QuicConfig::SetDisableConnectionMigration() {
   connection_migration_disabled_.SetSendValue(1);
 }
 
 bool QuicConfig::DisableConnectionMigration() const {
   return connection_migration_disabled_.HasReceivedValue();
 }
 
 void QuicConfig::SetAlternateServerAddressToSend(
     const QuicSocketAddress& alternate_server_address) {
@@ skipping 58 matching lines @@
 
 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   idle_network_timeout_seconds_.ToHandshakeMessage(out);
   silent_close_.ToHandshakeMessage(out);
   max_streams_per_connection_.ToHandshakeMessage(out);
   max_incoming_dynamic_streams_.ToHandshakeMessage(out);
   bytes_for_connection_id_.ToHandshakeMessage(out);
   initial_round_trip_time_us_.ToHandshakeMessage(out);
   initial_stream_flow_control_window_bytes_.ToHandshakeMessage(out);
   initial_session_flow_control_window_bytes_.ToHandshakeMessage(out);
-  if (latched_no_socket_receive_buffer_) {
-    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_no_socket_receive_buffer, 2, 3);
-  } else {
-    socket_receive_buffer_.ToHandshakeMessage(out);
-  }
   connection_migration_disabled_.ToHandshakeMessage(out);
   connection_options_.ToHandshakeMessage(out);
   alternate_server_address_.ToHandshakeMessage(out);
   force_hol_blocking_.ToHandshakeMessage(out);
   support_max_header_list_size_.ToHandshakeMessage(out);
 }
 
 QuicErrorCode QuicConfig::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
@@ skipping 26 matching lines @@
                                                          error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = initial_stream_flow_control_window_bytes_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = initial_session_flow_control_window_bytes_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
-  if (latched_no_socket_receive_buffer_) {
-    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_no_socket_receive_buffer, 3, 3);
-  } else if (error == QUIC_NO_ERROR) {
-    error = socket_receive_buffer_.ProcessPeerHello(peer_hello, hello_type,
-                                                    error_details);
-  }
   if (error == QUIC_NO_ERROR) {
     error = connection_migration_disabled_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = connection_options_.ProcessPeerHello(peer_hello, hello_type,
                                                  error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = alternate_server_address_.ProcessPeerHello(peer_hello, hello_type,
                                                        error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = force_hol_blocking_.ProcessPeerHello(peer_hello, hello_type,
                                                  error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = support_max_header_list_size_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net