Remove loss detection from QuicConfig now that connection options has

net/quic/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/quic_config.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 409 matching lines @@
     default:
       *error_details = "Bad " + QuicUtils::TagToString(tag_);
       break;
   }
   return error;
 }
 
 QuicConfig::QuicConfig()
     : congestion_feedback_(kCGST, PRESENCE_REQUIRED),
       connection_options_(kCOPT, PRESENCE_OPTIONAL),
-      loss_detection_(kLOSS, PRESENCE_OPTIONAL),
       idle_connection_state_lifetime_seconds_(kICSL, PRESENCE_REQUIRED),
       keepalive_timeout_seconds_(kKATO, PRESENCE_OPTIONAL),
       max_streams_per_connection_(kMSPC, PRESENCE_REQUIRED),
       max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
       initial_congestion_window_(kSWND, PRESENCE_OPTIONAL),
       initial_round_trip_time_us_(kIRTT, PRESENCE_OPTIONAL),
       // TODO(rjshade): Make this PRESENCE_REQUIRED when QUIC_VERSION_16 is
       // retired.
       initial_flow_control_window_bytes_(kIFCW, PRESENCE_OPTIONAL),
       // TODO(rjshade): Make this PRESENCE_REQUIRED when retiring
@@ skipping 31 matching lines @@
 }
 
 bool QuicConfig::HasSendConnectionOptions() const {
   return connection_options_.HasSendValues();
 }
 
 QuicTagVector QuicConfig::SendConnectionOptions() const {
   return connection_options_.GetSendValues();
 }
 
-void QuicConfig::SetLossDetectionToSend(QuicTag loss_detection) {
-  loss_detection_.SetSendValue(loss_detection);
-}
-
-bool QuicConfig::HasReceivedLossDetection() const {
-  return loss_detection_.HasReceivedValue();
-}
-
-QuicTag QuicConfig::ReceivedLossDetection() const {
-  return loss_detection_.GetReceivedValue();
-}
-
 void QuicConfig::set_idle_connection_state_lifetime(
     QuicTime::Delta max_idle_connection_state_lifetime,
     QuicTime::Delta default_idle_conection_state_lifetime) {
   idle_connection_state_lifetime_seconds_.set(
       max_idle_connection_state_lifetime.ToSeconds(),
       default_idle_conection_state_lifetime.ToSeconds());
 }
 
 QuicTime::Delta QuicConfig::idle_connection_state_lifetime() const {
   return QuicTime::Delta::FromSeconds(
@@ skipping 165 matching lines @@
   SetInitialSessionFlowControlWindowToSend(kDefaultFlowControlSendWindow);
 }
 
 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   congestion_feedback_.ToHandshakeMessage(out);
   idle_connection_state_lifetime_seconds_.ToHandshakeMessage(out);
   keepalive_timeout_seconds_.ToHandshakeMessage(out);
   max_streams_per_connection_.ToHandshakeMessage(out);
   initial_congestion_window_.ToHandshakeMessage(out);
   initial_round_trip_time_us_.ToHandshakeMessage(out);
-  loss_detection_.ToHandshakeMessage(out);
   initial_flow_control_window_bytes_.ToHandshakeMessage(out);
   initial_stream_flow_control_window_bytes_.ToHandshakeMessage(out);
   initial_session_flow_control_window_bytes_.ToHandshakeMessage(out);
   socket_receive_buffer_.ToHandshakeMessage(out);
   connection_options_.ToHandshakeMessage(out);
 }
 
 QuicErrorCode QuicConfig::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
@@ skipping 35 matching lines @@
   }
   if (error == QUIC_NO_ERROR) {
     error = initial_session_flow_control_window_bytes_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = socket_receive_buffer_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
-    error = loss_detection_.ProcessPeerHello(
-        peer_hello, hello_type, error_details);
-  }
-  if (error == QUIC_NO_ERROR) {
     error = connection_options_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net