Clang format slam.

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 29 matching lines @@
       break;
     case QUIC_NO_ERROR:
       break;
     default:
       *error_details = "Bad " + QuicUtils::TagToString(tag);
       break;
   }
   return error;
 }
 
-
-QuicConfigValue::QuicConfigValue(QuicTag tag,
-                                 QuicConfigPresence presence)
-    : tag_(tag),
-      presence_(presence) {
+QuicConfigValue::QuicConfigValue(QuicTag tag, QuicConfigPresence presence)
+    : tag_(tag), presence_(presence) {
 }
-QuicConfigValue::~QuicConfigValue() {}
+QuicConfigValue::~QuicConfigValue() {
+}
 
 QuicNegotiableValue::QuicNegotiableValue(QuicTag tag,
                                          QuicConfigPresence presence)
-    : QuicConfigValue(tag, presence),
-      negotiated_(false) {
+    : QuicConfigValue(tag, presence), negotiated_(false) {
 }
-QuicNegotiableValue::~QuicNegotiableValue() {}
+QuicNegotiableValue::~QuicNegotiableValue() {
+}
 
 QuicNegotiableUint32::QuicNegotiableUint32(QuicTag tag,
                                            QuicConfigPresence presence)
-    : QuicNegotiableValue(tag, presence),
-      max_value_(0),
-      default_value_(0) {
+    : QuicNegotiableValue(tag, presence), max_value_(0), default_value_(0) {
 }
-QuicNegotiableUint32::~QuicNegotiableUint32() {}
+QuicNegotiableUint32::~QuicNegotiableUint32() {
+}
 
 void QuicNegotiableUint32::set(uint32 max, uint32 default_value) {
   DCHECK_LE(default_value, max);
   max_value_ = max;
   default_value_ = default_value;
 }
 
 uint32 QuicNegotiableUint32::GetUint32() const {
   if (negotiated_) {
     return negotiated_value_;
@@ skipping 10 matching lines @@
   }
 }
 
 QuicErrorCode QuicNegotiableUint32::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   DCHECK(!negotiated_);
   DCHECK(error_details != NULL);
   uint32 value;
-  QuicErrorCode error = ReadUint32(peer_hello,
-                                   tag_,
-                                   presence_,
-                                   default_value_,
-                                   &value,
-                                   error_details);
+  QuicErrorCode error = ReadUint32(
+      peer_hello, tag_, presence_, default_value_, &value, error_details);
   if (error != QUIC_NO_ERROR) {
     return error;
   }
   if (hello_type == SERVER && value > max_value_) {
-    *error_details = "Invalid value received for " +
-        QuicUtils::TagToString(tag_);
+    *error_details =
+        "Invalid value received for " + QuicUtils::TagToString(tag_);
     return QUIC_INVALID_NEGOTIATED_VALUE;
   }
 
   negotiated_ = true;
   negotiated_value_ = min(value, max_value_);
   return QUIC_NO_ERROR;
 }
 
 QuicNegotiableTag::QuicNegotiableTag(QuicTag tag, QuicConfigPresence presence)
     : QuicNegotiableValue(tag, presence),
       negotiated_tag_(0),
       default_value_(0) {
 }
 
-QuicNegotiableTag::~QuicNegotiableTag() {}
+QuicNegotiableTag::~QuicNegotiableTag() {
+}
 
 void QuicNegotiableTag::set(const QuicTagVector& possible,
                             QuicTag default_value) {
   DCHECK(std::find(possible.begin(), possible.end(), default_value) !=
-            possible.end());
+         possible.end());
   possible_values_ = possible;
   default_value_ = default_value;
 }
 
 QuicTag QuicNegotiableTag::GetTag() const {
   if (negotiated_) {
     return negotiated_tag_;
   }
   return default_value_;
 }
 
 void QuicNegotiableTag::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (negotiated_) {
     // Because of the way we serialize and parse handshake messages we can
     // serialize this as value and still parse it as a vector.
     out->SetValue(tag_, negotiated_tag_);
   } else {
     out->SetVector(tag_, possible_values_);
   }
 }
 
-QuicErrorCode QuicNegotiableTag::ReadVector(
-    const CryptoHandshakeMessage& msg,
-    const QuicTag** out,
-    size_t* out_length,
-    string* error_details) const {
+QuicErrorCode QuicNegotiableTag::ReadVector(const CryptoHandshakeMessage& msg,
+                                            const QuicTag** out,
+                                            size_t* out_length,
+                                            string* error_details) const {
   DCHECK(error_details != NULL);
   QuicErrorCode error = msg.GetTaglist(tag_, out, out_length);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence_ == PRESENCE_REQUIRED) {
         *error_details = "Missing " + QuicUtils::TagToString(tag_);
         break;
       }
       error = QUIC_NO_ERROR;
       *out_length = 1;
       *out = &default_value_;
 
     case QUIC_NO_ERROR:
       break;
     default:
       *error_details = "Bad " + QuicUtils::TagToString(tag_);
       break;
   }
   return error;
 }
 
 QuicErrorCode QuicNegotiableTag::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   DCHECK(!negotiated_);
   DCHECK(error_details != NULL);
   const QuicTag* received_tags;
   size_t received_tags_length;
-  QuicErrorCode error = ReadVector(peer_hello, &received_tags,
-                                   &received_tags_length, error_details);
+  QuicErrorCode error = ReadVector(
+      peer_hello, &received_tags, &received_tags_length, error_details);
   if (error != QUIC_NO_ERROR) {
     return error;
   }
 
   if (hello_type == SERVER) {
     if (received_tags_length != 1 ||
-        std::find(possible_values_.begin(), possible_values_.end(),
+        std::find(possible_values_.begin(),
+                  possible_values_.end(),
                   *received_tags) == possible_values_.end()) {
       *error_details = "Invalid " + QuicUtils::TagToString(tag_);
       return QUIC_INVALID_NEGOTIATED_VALUE;
     }
     negotiated_tag_ = *received_tags;
   } else {
     QuicTag negotiated_tag;
     if (!QuicUtils::FindMutualTag(possible_values_,
                                   received_tags,
                                   received_tags_length,
                                   QuicUtils::LOCAL_PRIORITY,
                                   &negotiated_tag,
                                   NULL)) {
       *error_details = "Unsupported " + QuicUtils::TagToString(tag_);
       return QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP;
     }
     negotiated_tag_ = negotiated_tag;
   }
 
   negotiated_ = true;
   return QUIC_NO_ERROR;
 }
 
 QuicFixedUint32::QuicFixedUint32(QuicTag tag, QuicConfigPresence presence)
     : QuicConfigValue(tag, presence),
       has_send_value_(false),
       has_receive_value_(false) {
 }
-QuicFixedUint32::~QuicFixedUint32() {}
+QuicFixedUint32::~QuicFixedUint32() {
+}
 
 bool QuicFixedUint32::HasSendValue() const {
   return has_send_value_;
 }
 
 uint32 QuicFixedUint32::GetSendValue() const {
   LOG_IF(DFATAL, !has_send_value_) << "No send value to get for tag:" << tag_;
   return send_value_;
 }
 
@@ skipping 40 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)
+QuicFixedTag::QuicFixedTag(QuicTag name, QuicConfigPresence presence)
     : QuicConfigValue(name, presence),
       has_send_value_(false),
       has_receive_value_(false) {
 }
 
-QuicFixedTag::~QuicFixedTag() {}
+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:" << tag_;
   return send_value_;
 }
 
@@ skipping 54 matching lines @@
       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 retiring
       // QUIC_VERSION_17.
       initial_flow_control_window_bytes_(kIFCW, PRESENCE_OPTIONAL) {
 }
 
-QuicConfig::~QuicConfig() {}
+QuicConfig::~QuicConfig() {
+}
 
-void QuicConfig::set_congestion_control(
-    const QuicTagVector& congestion_control,
-    QuicTag default_congestion_control) {
+void QuicConfig::set_congestion_control(const QuicTagVector& congestion_control,
+                                        QuicTag default_congestion_control) {
   congestion_control_.set(congestion_control, default_congestion_control);
 }
 
 QuicTag QuicConfig::congestion_control() const {
   return congestion_control_.GetTag();
 }
 
 void QuicConfig::SetLossDetectionToSend(QuicTag loss_detection) {
   loss_detection_.SetSendValue(loss_detection);
 }
@@ skipping 13 matching lines @@
       max_idle_connection_state_lifetime.ToSeconds(),
       default_idle_conection_state_lifetime.ToSeconds());
 }
 
 QuicTime::Delta QuicConfig::idle_connection_state_lifetime() const {
   return QuicTime::Delta::FromSeconds(
       idle_connection_state_lifetime_seconds_.GetUint32());
 }
 
 QuicTime::Delta QuicConfig::keepalive_timeout() const {
-  return QuicTime::Delta::FromSeconds(
-      keepalive_timeout_seconds_.GetUint32());
+  return QuicTime::Delta::FromSeconds(keepalive_timeout_seconds_.GetUint32());
 }
 
 void QuicConfig::set_max_streams_per_connection(size_t max_streams,
                                                 size_t default_streams) {
   max_streams_per_connection_.set(max_streams, default_streams);
 }
 
 uint32 QuicConfig::max_streams_per_connection() const {
   return max_streams_per_connection_.GetUint32();
 }
@@ skipping 29 matching lines @@
 
 uint32 QuicConfig::ReceivedInitialRoundTripTimeUs() const {
   return initial_round_trip_time_us_.GetReceivedValue();
 }
 
 void QuicConfig::SetInitialFlowControlWindowToSend(uint32 window_bytes) {
   initial_flow_control_window_bytes_.SetSendValue(window_bytes);
 }
 
 bool QuicConfig::HasReceivedInitialFlowControlWindowBytes() const {
-  return initial_flow_control_window_bytes_.HasReceivedValue();;
+  return initial_flow_control_window_bytes_.HasReceivedValue();
+  ;
 }
 
 uint32 QuicConfig::ReceivedInitialFlowControlWindowBytes() const {
   return initial_flow_control_window_bytes_.GetReceivedValue();
 }
 
 bool QuicConfig::negotiated() {
   // TODO(ianswett): Add the negotiated parameters once and iterate over all
   // of them in negotiated, ToHandshakeMessage, ProcessClientHello, and
   // ProcessServerHello.
   return congestion_control_.negotiated() &&
-      idle_connection_state_lifetime_seconds_.negotiated() &&
-      keepalive_timeout_seconds_.negotiated() &&
-      max_streams_per_connection_.negotiated();
+         idle_connection_state_lifetime_seconds_.negotiated() &&
+         keepalive_timeout_seconds_.negotiated() &&
+         max_streams_per_connection_.negotiated();
 }
 
 void QuicConfig::SetDefaults() {
   QuicTagVector congestion_control;
   if (FLAGS_enable_quic_pacing) {
     congestion_control.push_back(kPACE);
   }
   congestion_control.push_back(kQBIC);
   congestion_control_.set(congestion_control, kQBIC);
   idle_connection_state_lifetime_seconds_.set(kDefaultTimeoutSecs,
                                               kDefaultInitialTimeoutSecs);
   // kKATO is optional. Return 0 if not negotiated.
   keepalive_timeout_seconds_.set(0, 0);
   max_streams_per_connection_.set(kDefaultMaxStreamsPerConnection,
                                   kDefaultMaxStreamsPerConnection);
-  max_time_before_crypto_handshake_ = QuicTime::Delta::FromSeconds(
-      kDefaultMaxTimeForCryptoHandshakeSecs);
+  max_time_before_crypto_handshake_ =
+      QuicTime::Delta::FromSeconds(kDefaultMaxTimeForCryptoHandshakeSecs);
 }
 
 void QuicConfig::EnablePacing(bool enable_pacing) {
   QuicTagVector congestion_control;
   if (enable_pacing) {
     congestion_control.push_back(kPACE);
   }
   congestion_control.push_back(kQBIC);
   congestion_control_.set(congestion_control, kQBIC);
 }
@@ skipping 11 matching lines @@
 
 QuicErrorCode QuicConfig::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   DCHECK(error_details != NULL);
 
   QuicErrorCode error = QUIC_NO_ERROR;
   if (error == QUIC_NO_ERROR) {
     error = congestion_control_.ProcessPeerHello(
-        peer_hello,  hello_type, error_details);
+        peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = idle_connection_state_lifetime_seconds_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = keepalive_timeout_seconds_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = max_streams_per_connection_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = initial_congestion_window_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = initial_round_trip_time_us_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = initial_flow_control_window_bytes_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
-    error = loss_detection_.ProcessPeerHello(
-        peer_hello, hello_type, error_details);
+    error =
+        loss_detection_.ProcessPeerHello(peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net