Moves QuicTag typedefs, and QuicTag utility methods to quic_tag.{h,cc}. No behavior change.

net/quic/core/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/core/quic_config.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
@@ skipping 14 matching lines @@
                          QuicTag tag,
                          QuicConfigPresence presence,
                          uint32_t default_value,
                          uint32_t* out,
                          string* error_details) {
   DCHECK(error_details != nullptr);
   QuicErrorCode error = msg.GetUint32(tag, out);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence == PRESENCE_REQUIRED) {
-        *error_details = "Missing " + QuicUtils::TagToString(tag);
+        *error_details = "Missing " + QuicTagToString(tag);
         break;
       }
       error = QUIC_NO_ERROR;
       *out = default_value;
       break;
     case QUIC_NO_ERROR:
       break;
     default:
-      *error_details = "Bad " + QuicUtils::TagToString(tag);
+      *error_details = "Bad " + QuicTagToString(tag);
       break;
   }
   return error;
 }
 
 QuicConfigValue::QuicConfigValue(QuicTag tag, QuicConfigPresence presence)
     : tag_(tag), presence_(presence) {}
 QuicConfigValue::~QuicConfigValue() {}
 
 QuicNegotiableValue::QuicNegotiableValue(QuicTag tag,
@@ skipping 42 matching lines @@
     string* error_details) {
   DCHECK(!negotiated());
   DCHECK(error_details != nullptr);
   uint32_t value;
   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 " + QuicTagToString(tag_);
     return QUIC_INVALID_NEGOTIATED_VALUE;
   }
 
   set_negotiated(true);
   negotiated_value_ = min(value, max_value_);
   return QUIC_NO_ERROR;
 }
 
 QuicFixedUint32::QuicFixedUint32(QuicTag tag, QuicConfigPresence presence)
     : QuicConfigValue(tag, presence),
       has_send_value_(false),
       has_receive_value_(false) {}
 QuicFixedUint32::~QuicFixedUint32() {}
 
 bool QuicFixedUint32::HasSendValue() const {
   return has_send_value_;
 }
 
 uint32_t QuicFixedUint32::GetSendValue() const {
   QUIC_BUG_IF(!has_send_value_) << "No send value to get for tag:"
-                                << QuicUtils::TagToString(tag_);
+                                << QuicTagToString(tag_);
   return send_value_;
 }
 
 void QuicFixedUint32::SetSendValue(uint32_t value) {
   has_send_value_ = true;
   send_value_ = value;
 }
 
 bool QuicFixedUint32::HasReceivedValue() const {
   return has_receive_value_;
 }
 
 uint32_t QuicFixedUint32::GetReceivedValue() const {
   QUIC_BUG_IF(!has_receive_value_) << "No receive value to get for tag:"
-                                   << QuicUtils::TagToString(tag_);
+                                   << QuicTagToString(tag_);
   return receive_value_;
 }
 
 void QuicFixedUint32::SetReceivedValue(uint32_t value) {
   has_receive_value_ = true;
   receive_value_ = value;
 }
 
 void QuicFixedUint32::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (has_send_value_) {
     out->SetValue(tag_, send_value_);
   }
 }
 
 QuicErrorCode QuicFixedUint32::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_);
+      *error_details = "Missing " + QuicTagToString(tag_);
       break;
     case QUIC_NO_ERROR:
       has_receive_value_ = true;
       break;
     default:
-      *error_details = "Bad " + QuicUtils::TagToString(tag_);
+      *error_details = "Bad " + QuicTagToString(tag_);
       break;
   }
   return error;
 }
 
 QuicFixedTagVector::QuicFixedTagVector(QuicTag name,
                                        QuicConfigPresence presence)
     : QuicConfigValue(name, presence),
       has_send_values_(false),
       has_receive_values_(false) {}
 
 QuicFixedTagVector::QuicFixedTagVector(const QuicFixedTagVector& other) =
     default;
 
 QuicFixedTagVector::~QuicFixedTagVector() {}
 
 bool QuicFixedTagVector::HasSendValues() const {
   return has_send_values_;
 }
 
 QuicTagVector QuicFixedTagVector::GetSendValues() const {
   QUIC_BUG_IF(!has_send_values_) << "No send values to get for tag:"
-                                 << QuicUtils::TagToString(tag_);
+                                 << QuicTagToString(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 {
   QUIC_BUG_IF(!has_receive_values_) << "No receive value to get for tag:"
-                                    << QuicUtils::TagToString(tag_);
+                                    << QuicTagToString(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_) {
     out->SetVector(tag_, send_values_);
   }
 }
 
 QuicErrorCode QuicFixedTagVector::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   DCHECK(error_details != nullptr);
   const QuicTag* received_tags;
   size_t received_tags_length;
   QuicErrorCode error =
       peer_hello.GetTaglist(tag_, &received_tags, &received_tags_length);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence_ == PRESENCE_OPTIONAL) {
         return QUIC_NO_ERROR;
       }
-      *error_details = "Missing " + QuicUtils::TagToString(tag_);
+      *error_details = "Missing " + QuicTagToString(tag_);
       break;
     case QUIC_NO_ERROR:
       DVLOG(1) << "Received Connection Option tags from receiver.";
       has_receive_values_ = true;
       for (size_t i = 0; i < received_tags_length; ++i) {
         receive_values_.push_back(received_tags[i]);
       }
       break;
     default:
-      *error_details = "Bad " + QuicUtils::TagToString(tag_);
+      *error_details = "Bad " + QuicTagToString(tag_);
       break;
   }
   return error;
 }
 
 QuicFixedIPEndPoint::QuicFixedIPEndPoint(QuicTag tag,
                                          QuicConfigPresence presence)
     : QuicConfigValue(tag, presence),
       has_send_value_(false),
       has_receive_value_(false) {}
 
 QuicFixedIPEndPoint::~QuicFixedIPEndPoint() {}
 
 bool QuicFixedIPEndPoint::HasSendValue() const {
   return has_send_value_;
 }
 
 const IPEndPoint& QuicFixedIPEndPoint::GetSendValue() const {
   QUIC_BUG_IF(!has_send_value_) << "No send value to get for tag:"
-                                << QuicUtils::TagToString(tag_);
+                                << QuicTagToString(tag_);
   return send_value_;
 }
 
 void QuicFixedIPEndPoint::SetSendValue(const IPEndPoint& value) {
   has_send_value_ = true;
   send_value_ = value;
 }
 
 bool QuicFixedIPEndPoint::HasReceivedValue() const {
   return has_receive_value_;
 }
 
 const IPEndPoint& QuicFixedIPEndPoint::GetReceivedValue() const {
   QUIC_BUG_IF(!has_receive_value_) << "No receive value to get for tag:"
-                                   << QuicUtils::TagToString(tag_);
+                                   << QuicTagToString(tag_);
   return receive_value_;
 }
 
 void QuicFixedIPEndPoint::SetReceivedValue(const IPEndPoint& value) {
   has_receive_value_ = true;
   receive_value_ = value;
 }
 
 void QuicFixedIPEndPoint::ToHandshakeMessage(
     CryptoHandshakeMessage* out) const {
   if (has_send_value_) {
     QuicSocketAddressCoder address_coder(send_value_);
     out->SetStringPiece(tag_, address_coder.Encode());
   }
 }
 
 QuicErrorCode QuicFixedIPEndPoint::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   base::StringPiece address;
   if (!peer_hello.GetStringPiece(tag_, &address)) {
     if (presence_ == PRESENCE_REQUIRED) {
-      *error_details = "Missing " + QuicUtils::TagToString(tag_);
+      *error_details = "Missing " + QuicTagToString(tag_);
       return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
     }
   } else {
     QuicSocketAddressCoder address_coder;
     if (address_coder.Decode(address.data(), address.length())) {
       SetReceivedValue(IPEndPoint(address_coder.ip(), address_coder.port()));
     }
   }
   return QUIC_NO_ERROR;
 }
@@ skipping 350 matching lines @@
                                                        error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = force_hol_blocking_.ProcessPeerHello(peer_hello, hello_type,
                                                  error_details);
   }
   return error;
 }
 
 }  // namespace net