CL generated with data from dead-code analysis using

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 262 matching lines @@
     case QUIC_NO_ERROR:
       has_receive_value_ = true;
       break;
     default:
       *error_details = "Bad " + QuicUtils::TagToString(tag_);
       break;
   }
   return error;
 }
 
-QuicFixedTag::QuicFixedTag(QuicTag name,
-                           QuicConfigPresence presence)
-    : QuicConfigValue(name, presence),
-      has_send_value_(false),
-      has_receive_value_(false) {
-}
-
-QuicFixedTag::~QuicFixedTag() {}
-
-bool QuicFixedTag::HasSendValue() const {
-  return has_send_value_;
-}
-
-uint32 QuicFixedTag::GetSendValue() const {
-  LOG_IF(DFATAL, !has_send_value_)
-      << "No send value to get for tag:" << QuicUtils::TagToString(tag_);
-  return send_value_;
-}
-
-void QuicFixedTag::SetSendValue(uint32 value) {
-  has_send_value_ = true;
-  send_value_ = value;
-}
-
-bool QuicFixedTag::HasReceivedValue() const {
-  return has_receive_value_;
-}
-
-uint32 QuicFixedTag::GetReceivedValue() const {
-  LOG_IF(DFATAL, !has_receive_value_)
-      << "No receive value to get for tag:" << QuicUtils::TagToString(tag_);
-  return receive_value_;
-}
-
-void QuicFixedTag::SetReceivedValue(uint32 value) {
-  has_receive_value_ = true;
-  receive_value_ = value;
-}
-
-void QuicFixedTag::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
-  if (has_send_value_) {
-    out->SetValue(tag_, send_value_);
-  }
-}
-
-QuicErrorCode QuicFixedTag::ProcessPeerHello(
-    const CryptoHandshakeMessage& peer_hello,
-    HelloType hello_type,
-    string* error_details) {
-  DCHECK(error_details != nullptr);
-  QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
-  switch (error) {
-    case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
-      if (presence_ == PRESENCE_OPTIONAL) {
-        return QUIC_NO_ERROR;
-      }
-      *error_details = "Missing " + QuicUtils::TagToString(tag_);
-      break;
-    case QUIC_NO_ERROR:
-      has_receive_value_ = true;
-      break;
-    default:
-      *error_details = "Bad " + QuicUtils::TagToString(tag_);
-      break;
-  }
-  return error;
-}
-
 QuicFixedTagVector::QuicFixedTagVector(QuicTag name,
                                        QuicConfigPresence presence)
     : QuicConfigValue(name, presence),
       has_send_values_(false),
       has_receive_values_(false) {
 }
 
 QuicFixedTagVector::~QuicFixedTagVector() {}
 
 bool QuicFixedTagVector::HasSendValues() const {
@@ skipping 108 matching lines @@
   idle_connection_state_lifetime_seconds_.set(
       static_cast<uint32>(max_idle_connection_state_lifetime.ToSeconds()),
       static_cast<uint32>(default_idle_conection_state_lifetime.ToSeconds()));
 }
 
 QuicTime::Delta QuicConfig::IdleConnectionStateLifetime() const {
   return QuicTime::Delta::FromSeconds(
       idle_connection_state_lifetime_seconds_.GetUint32());
 }
 
+// TODO(ianswett) Use this for silent close on mobile, or delete.
 void QuicConfig::SetSilentClose(bool silent_close) {
   silent_close_.set(silent_close ? 1 : 0, silent_close ? 1 : 0);
 }
 
 bool QuicConfig::SilentClose() const {
   return silent_close_.GetUint32() > 0;
 }
 
 void QuicConfig::SetMaxStreamsPerConnection(size_t max_streams,
                                             size_t default_streams) {
@@ skipping 81 matching lines @@
 }
 
 uint32 QuicConfig::ReceivedInitialSessionFlowControlWindowBytes() const {
   return initial_session_flow_control_window_bytes_.GetReceivedValue();
 }
 
 void QuicConfig::SetSocketReceiveBufferToSend(uint32 tcp_receive_window) {
   socket_receive_buffer_.SetSendValue(tcp_receive_window);
 }
 
-uint32 QuicConfig::GetSocketReceiveBufferToSend() const {
-  return socket_receive_buffer_.GetSendValue();
-}
-
 bool QuicConfig::HasReceivedSocketReceiveBuffer() const {
   return socket_receive_buffer_.HasReceivedValue();
 }
 
 uint32 QuicConfig::ReceivedSocketReceiveBuffer() const {
   return socket_receive_buffer_.GetReceivedValue();
 }
 
 bool QuicConfig::negotiated() const {
   // TODO(ianswett): Add the negotiated parameters once and iterate over all
@@ skipping 79 matching lines @@
         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