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

net/quic/core/quic_utils.cc

 // Copyright (c) 2012 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_utils.h"
 
 #include <ctype.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 106 matching lines @@
                         UINT64_C(7113472399480571277));
 
   uint128 hash = IncrementalHash(kOffset, data1, len1);
   if (data2 == nullptr) {
     return hash;
   }
   return IncrementalHash(hash, data2, len2);
 }
 
 // static
-bool QuicUtils::FindMutualTag(const QuicTagVector& our_tags_vector,
-                              const QuicTag* their_tags,
-                              size_t num_their_tags,
-                              QuicTag* out_result,
-                              size_t* out_index) {
-  if (our_tags_vector.empty()) {
-    return false;
-  }
-  const size_t num_our_tags = our_tags_vector.size();
-  for (size_t i = 0; i < num_our_tags; i++) {
-    for (size_t j = 0; j < num_their_tags; j++) {
-      if (our_tags_vector[i] == their_tags[j]) {
-        *out_result = our_tags_vector[i];
-        if (out_index != nullptr) {
-          *out_index = j;
-        }
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-// static
 void QuicUtils::SerializeUint128Short(uint128 v, uint8_t* out) {
   const uint64_t lo = Uint128Low64(v);
   const uint64_t hi = Uint128High64(v);
   // This assumes that the system is little-endian.
   memcpy(out, &lo, sizeof(lo));
   memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2);
 }
 
 #define RETURN_STRING_LITERAL(x) \
   case x:                        \
@@ skipping 151 matching lines @@
     RETURN_STRING_LITERAL(LOSS_RETRANSMISSION);
     RETURN_STRING_LITERAL(ALL_UNACKED_RETRANSMISSION);
     RETURN_STRING_LITERAL(ALL_INITIAL_RETRANSMISSION);
     RETURN_STRING_LITERAL(RTO_RETRANSMISSION);
     RETURN_STRING_LITERAL(TLP_RETRANSMISSION);
   }
   return "INVALID_TRANSMISSION_TYPE";
 }
 
 // static
-string QuicUtils::TagToString(QuicTag tag) {
-  char chars[sizeof tag];
-  bool ascii = true;
-  const QuicTag orig_tag = tag;
-
-  for (size_t i = 0; i < arraysize(chars); i++) {
-    chars[i] = static_cast<char>(tag);
-    if ((chars[i] == 0 || chars[i] == '\xff') && i == arraysize(chars) - 1) {
-      chars[i] = ' ';
-    }
-    if (!isprint(static_cast<unsigned char>(chars[i]))) {
-      ascii = false;
-      break;
-    }
-    tag >>= 8;
-  }
-
-  if (ascii) {
-    return string(chars, sizeof(chars));
-  }
-
-  return base::UintToString(orig_tag);
-}
-
-// static
 QuicTagVector QuicUtils::ParseQuicConnectionOptions(
     const std::string& connection_options) {
   QuicTagVector options;
   // Tokens are expected to be no more than 4 characters long, but we
   // handle overflow gracefully.
   for (const base::StringPiece& token :
        base::SplitStringPiece(connection_options, ",", base::TRIM_WHITESPACE,
                               base::SPLIT_WANT_ALL)) {
     uint32_t option = 0;
     for (char token_char : base::Reversed(token)) {
@@ skipping 189 matching lines @@
 
     bytes_remaining -= line_bytes;
     offset += line_bytes;
     p += line_bytes;
     s += '\n';
   }
   return s;
 }
 
 }  // namespace net