Land Recent QUIC changes.

net/quic/quic_protocol.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/quic_protocol.h"
+
 #include "base/stl_util.h"
+#include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::map;
 using std::numeric_limits;
 using std::ostream;
 using std::string;
 
 namespace net {
 
 size_t GetPacketHeaderSize(QuicPacketHeader header) {
@@ skipping 28 matching lines @@
 size_t GetStartOfEncryptedData(
     QuicGuidLength guid_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length) {
   // Don't include the fec size, since encryption starts before private flags.
   return GetPacketHeaderSize(
       guid_length, include_version, sequence_number_length, NOT_IN_FEC_GROUP) -
       kPrivateFlagsSize;
 }
 
-uint32 MakeQuicTag(char a, char b, char c, char d) {
-  return static_cast<uint32>(a) |
-         static_cast<uint32>(b) << 8 |
-         static_cast<uint32>(c) << 16 |
-         static_cast<uint32>(d) << 24;
-}
-
 QuicPacketPublicHeader::QuicPacketPublicHeader()
     : guid(0),
       guid_length(PACKET_8BYTE_GUID),
       reset_flag(false),
       version_flag(false),
       sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
 }
 
 QuicPacketPublicHeader::QuicPacketPublicHeader(
     const QuicPacketPublicHeader& other)
@@ skipping 40 matching lines @@
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
                                  StringPiece data)
     : stream_id(stream_id),
       fin(fin),
       offset(offset),
       data(data) {
 }
 
+uint32 MakeQuicTag(char a, char b, char c, char d) {
+  return static_cast<uint32>(a) |
+         static_cast<uint32>(b) << 8 |
+         static_cast<uint32>(c) << 16 |
+         static_cast<uint32>(d) << 24;
+}
+
+QuicVersion QuicVersionMax() { return kSupportedQuicVersions[0]; }
+
+QuicTag QuicVersionToQuicTag(const QuicVersion version) {
+  switch (version) {
+    case QUIC_VERSION_6:
+      return MakeQuicTag('Q', '0', '0', '6');
+    // case QUIC_VERSION_7
+      // return MakeQuicTag('Q', '0', '0', '7');
+    default:
+      // This shold be an ERROR because we should never attempt to convert an
+      // invalid QuicVersion to be written to the wire.
+      LOG(ERROR) << "Unsupported QuicVersion: " << version;
+      return 0;
+  }
+}
+
+QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
+  const QuicTag quic_tag_v6 = MakeQuicTag('Q', '0', '0', '6');
+  // const QuicTag quic_tag_v7 = MakeQuicTag('Q', '0', '0', '7');
+
+  if (version_tag == quic_tag_v6) {
+    return QUIC_VERSION_6;
+  // } else if (version_tag == quic_tag_v7) {
+    // return QUIC_VERSION_7;
+  } else {
+    // Reading from the client so this should not be considered an ERROR.
+    DLOG(INFO) << "Unsupported QuicTag version: "
+               << QuicUtils::TagToString(version_tag);
+    return QUIC_VERSION_UNSUPPORTED;
+  }
+}
+
+string QuicVersionToString(const QuicVersion version) {
+  // TODO(rjshade): Possibly start using RETURN_STRING_LITERAL here when we
+  //                start supporting a lot of versions.
+  switch (version) {
+    case QUIC_VERSION_6:
+      return "QUIC_VERSION_6";
+    // case QUIC_VERSION_7:
+      // return "QUIC_VERSION_7";
+    default:
+      return "QUIC_VERSION_UNSUPPORTED";
+  }
+}
+
+string QuicVersionArrayToString(const QuicVersion versions[],
+                                int num_versions) {
+  string result = "";
+  for (int i = 0; i < num_versions; ++i) {
+    const QuicVersion& version = versions[i];
+    result.append(QuicVersionToString(version));
+    result.append(",");
+  }
+  return result;
+}
+
 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
   os << "{ guid: " << header.public_header.guid
      << ", guid_length:" << header.public_header.guid_length
      << ", reset_flag: " << header.public_header.reset_flag
      << ", version_flag: " << header.public_header.version_flag;
   if (header.public_header.version_flag) {
     os << " version: ";
     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
       os << header.public_header.versions[0] << " ";
     }
@@ skipping 226 matching lines @@
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
   os << "bytes_consumed: " << s.bytes_consumed
      << " fin_consumed: " << s.fin_consumed;
   return os;
 }
 
 }  // namespace net