No functional change. Rename QuicConfig methods from lowercase with

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 429 matching lines @@
       // QUIC_VERSION_19.
       initial_stream_flow_control_window_bytes_(kSFCW, PRESENCE_OPTIONAL),
       // TODO(rjshade): Make this PRESENCE_REQUIRED when retiring
       // QUIC_VERSION_19.
       initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
       socket_receive_buffer_(kSRBF, PRESENCE_OPTIONAL) {
 }
 
 QuicConfig::~QuicConfig() {}
 
-void QuicConfig::set_congestion_feedback(
+void QuicConfig::SetCongestionFeedback(
     const QuicTagVector& congestion_feedback,
     QuicTag default_congestion_feedback) {
   congestion_feedback_.set(congestion_feedback, default_congestion_feedback);
 }
 
-QuicTag QuicConfig::congestion_feedback() const {
+QuicTag QuicConfig::CongestionFeedback() const {
   return congestion_feedback_.GetTag();
 }
 
 void QuicConfig::SetConnectionOptionsToSend(
     const QuicTagVector& connection_options) {
   connection_options_.SetSendValues(connection_options);
 }
 
 bool QuicConfig::HasReceivedConnectionOptions() const {
   return connection_options_.HasReceivedValues();
 }
 
 QuicTagVector QuicConfig::ReceivedConnectionOptions() const {
   return connection_options_.GetReceivedValues();
 }
 
 bool QuicConfig::HasSendConnectionOptions() const {
   return connection_options_.HasSendValues();
 }
 
 QuicTagVector QuicConfig::SendConnectionOptions() const {
   return connection_options_.GetSendValues();
 }
 
-void QuicConfig::set_idle_connection_state_lifetime(
+void QuicConfig::SetIdleConnectionStateLifetime(
     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 {
+QuicTime::Delta QuicConfig::IdleConnectionStateLifetime() const {
   return QuicTime::Delta::FromSeconds(
       idle_connection_state_lifetime_seconds_.GetUint32());
 }
 
-QuicTime::Delta QuicConfig::keepalive_timeout() const {
+QuicTime::Delta QuicConfig::KeepaliveTimeout() const {
   return QuicTime::Delta::FromSeconds(
       keepalive_timeout_seconds_.GetUint32());
 }
 
-void QuicConfig::set_max_streams_per_connection(size_t max_streams,
-                                                size_t default_streams) {
+void QuicConfig::SetMaxStreamsPerConnection(size_t max_streams,
+                                            size_t default_streams) {
   max_streams_per_connection_.set(max_streams, default_streams);
 }
 
-uint32 QuicConfig::max_streams_per_connection() const {
+uint32 QuicConfig::MaxStreamsPerConnection() const {
   return max_streams_per_connection_.GetUint32();
 }
 
 void QuicConfig::set_max_time_before_crypto_handshake(
     QuicTime::Delta max_time_before_crypto_handshake) {
   max_time_before_crypto_handshake_ = max_time_before_crypto_handshake;
 }
 
 QuicTime::Delta QuicConfig::max_time_before_crypto_handshake() const {
   return max_time_before_crypto_handshake_;
@@ skipping 124 matching lines @@
 }
 
 void QuicConfig::SetDefaults() {
   QuicTagVector congestion_feedback;
   congestion_feedback.push_back(kQBIC);
   congestion_feedback_.set(congestion_feedback, kQBIC);
   idle_connection_state_lifetime_seconds_.set(kMaximumIdleTimeoutSecs,
                                               kDefaultInitialTimeoutSecs);
   // kKATO is optional. Return 0 if not negotiated.
   keepalive_timeout_seconds_.set(0, 0);
-  set_max_streams_per_connection(kDefaultMaxStreamsPerConnection,
-                                 kDefaultMaxStreamsPerConnection);
+  SetMaxStreamsPerConnection(kDefaultMaxStreamsPerConnection,
+                             kDefaultMaxStreamsPerConnection);
   max_time_before_crypto_handshake_ = QuicTime::Delta::FromSeconds(
       kDefaultMaxTimeForCryptoHandshakeSecs);
 
   SetInitialFlowControlWindowToSend(kDefaultFlowControlSendWindow);
   SetInitialStreamFlowControlWindowToSend(kDefaultFlowControlSendWindow);
   SetInitialSessionFlowControlWindowToSend(kDefaultFlowControlSendWindow);
 }
 
 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   congestion_feedback_.ToHandshakeMessage(out);
@@ skipping 57 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