Land Recent QUIC Changes.

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 91 matching lines @@
   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),
@@ skipping 97 matching lines @@
       has_send_value_(false),
       has_receive_value_(false) {
 }
 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_;
+  LOG_IF(DFATAL, !has_send_value_)
+      << "No send value to get for tag:" << QuicUtils::TagToString(tag_);
   return send_value_;
 }
 
 void QuicFixedUint32::SetSendValue(uint32 value) {
   has_send_value_ = true;
   send_value_ = value;
 }
 
 bool QuicFixedUint32::HasReceivedValue() const {
   return has_receive_value_;
 }
 
 uint32 QuicFixedUint32::GetReceivedValue() const {
   LOG_IF(DFATAL, !has_receive_value_)
-      << "No receive value to get for tag:" << tag_;
+      << "No receive value to get for tag:" << QuicUtils::TagToString(tag_);
   return receive_value_;
 }
 
 void QuicFixedUint32::SetReceivedValue(uint32 value) {
   has_receive_value_ = true;
   receive_value_ = value;
 }
 
 void QuicFixedUint32::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (has_send_value_) {
@@ skipping 31 matching lines @@
       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:" << tag_;
+  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:" << tag_;
+      << "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_) {
@@ skipping 31 matching lines @@
       has_receive_values_(false) {
 }
 
 QuicFixedTagVector::~QuicFixedTagVector() {}
 
 bool QuicFixedTagVector::HasSendValues() const {
   return has_send_values_;
 }
 
 QuicTagVector QuicFixedTagVector::GetSendValues() const {
-  LOG_IF(DFATAL, !has_send_values_) << "No send values to get for tag:" << tag_;
+  LOG_IF(DFATAL, !has_send_values_)
+      << "No send values to get for tag:" << QuicUtils::TagToString(tag_);
   return send_values_;
 }
 
 void QuicFixedTagVector::SetSendValues(const QuicTagVector& values) {
   has_send_values_ = true;
   send_values_ = values;
 }
 
 bool QuicFixedTagVector::HasReceivedValues() const {
   return has_receive_values_;
 }
 
 QuicTagVector QuicFixedTagVector::GetReceivedValues() const {
   LOG_IF(DFATAL, !has_receive_values_)
-      << "No receive value to get for tag:" << tag_;
+      << "No receive value to get for tag:" << QuicUtils::TagToString(tag_);
   return receive_values_;
 }
 
 void QuicFixedTagVector::SetReceivedValues(const QuicTagVector& values) {
   has_receive_values_ = true;
   receive_values_ = values;
 }
 
 void QuicFixedTagVector::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (has_send_values_) {
@@ skipping 242 matching lines @@
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = congestion_options_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net