Land Recent QUIC Changes.

net/quic/quic_protocol.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <stddef.h>
 #include <limits>
 #include <map>
@@ skipping 15 matching lines @@
 #include "net/quic/quic_time.h"
 
 namespace net {
 
 using ::operator<<;
 
 class QuicAckNotifier;
 class QuicPacket;
 struct QuicPacketHeader;
 
-typedef uint64 QuicGuid;
+typedef uint64 QuicConnectionId;
 typedef uint32 QuicStreamId;
 typedef uint64 QuicStreamOffset;
 typedef uint64 QuicPacketSequenceNumber;
 typedef QuicPacketSequenceNumber QuicFecGroupNumber;
 typedef uint64 QuicPublicResetNonceProof;
 typedef uint8 QuicPacketEntropyHash;
 typedef uint32 QuicHeaderId;
 // QuicTag is the type of a tag in the wire protocol.
 typedef uint32 QuicTag;
 typedef std::vector<QuicTag> QuicTagVector;
@@ skipping 111 matching lines @@
   STOP_WAITING_FRAME = 6,
 
   // STREAM, ACK, and CONGESTION_FEEDBACK frames are special frames. They are
   // encoded differently on the wire and their values do not need to be stable.
   STREAM_FRAME,
   ACK_FRAME,
   CONGESTION_FEEDBACK_FRAME,
   NUM_FRAME_TYPES
 };
 
-enum QuicGuidLength {
-  PACKET_0BYTE_GUID = 0,
-  PACKET_1BYTE_GUID = 1,
-  PACKET_4BYTE_GUID = 4,
-  PACKET_8BYTE_GUID = 8
+enum QuicConnectionIdLength {
+  PACKET_0BYTE_CONNECTION_ID = 0,
+  PACKET_1BYTE_CONNECTION_ID = 1,
+  PACKET_4BYTE_CONNECTION_ID = 4,
+  PACKET_8BYTE_CONNECTION_ID = 8
 };
 
 enum InFecGroup {
   NOT_IN_FEC_GROUP,
   IN_FEC_GROUP,
 };
 
 enum QuicSequenceNumberLength {
   PACKET_1BYTE_SEQUENCE_NUMBER = 1,
   PACKET_2BYTE_SEQUENCE_NUMBER = 2,
@@ skipping 12 matching lines @@
 // The public flags are specified in one byte.
 enum QuicPacketPublicFlags {
   PACKET_PUBLIC_FLAGS_NONE = 0,
 
   // Bit 0: Does the packet header contains version info?
   PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,
 
   // Bit 1: Is this packet a public reset packet?
   PACKET_PUBLIC_FLAGS_RST = 1 << 1,
 
-  // Bits 2 and 3 specify the length of the GUID as follows:
+  // Bits 2 and 3 specify the length of the ConnectionId as follows:
   // ----00--: 0 bytes
   // ----01--: 1 byte
   // ----10--: 4 bytes
   // ----11--: 8 bytes
-  PACKET_PUBLIC_FLAGS_0BYTE_GUID = 0,
-  PACKET_PUBLIC_FLAGS_1BYTE_GUID = 1 << 2,
-  PACKET_PUBLIC_FLAGS_4BYTE_GUID = 1 << 3,
-  PACKET_PUBLIC_FLAGS_8BYTE_GUID = 1 << 3 | 1 << 2,
+  PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID = 0,
+  PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID = 1 << 2,
+  PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID = 1 << 3,
+  PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID = 1 << 3 | 1 << 2,
 
   // Bits 4 and 5 describe the packet sequence number length as follows:
   // --00----: 1 byte
   // --01----: 2 bytes
   // --10----: 4 bytes
   // --11----: 6 bytes
   PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE = PACKET_FLAGS_1BYTE_SEQUENCE << 4,
   PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE = PACKET_FLAGS_2BYTE_SEQUENCE << 4,
   PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE = PACKET_FLAGS_4BYTE_SEQUENCE << 4,
   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE = PACKET_FLAGS_6BYTE_SEQUENCE << 4,
@@ skipping 81 matching lines @@
 // to reverse the order of the bytes.
 
 // MakeQuicTag returns a value given the four bytes. For example:
 //   MakeQuicTag('C', 'H', 'L', 'O');
 NET_EXPORT_PRIVATE QuicTag MakeQuicTag(char a, char b, char c, char d);
 
 // Size in bytes of the data or fec packet header.
 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(const QuicPacketHeader& header);
 
 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(
-    QuicGuidLength guid_length,
+    QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length,
     InFecGroup is_in_fec_group);
 
 // Index of the first byte in a QUIC packet of FEC protected data.
 NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(
-    QuicGuidLength guid_length,
+    QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length);
 // Index of the first byte in a QUIC packet of encrypted data.
 NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
-    QuicGuidLength guid_length,
+    QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length);
 
 enum QuicRstStreamErrorCode {
   QUIC_STREAM_NO_ERROR = 0,
 
   // There was some error which halted stream processing.
   QUIC_ERROR_PROCESSING_STREAM,
   // We got two fin or reset offsets which did not match.
   QUIC_MULTIPLE_TERMINATION_OFFSETS,
@@ skipping 149 matching lines @@
 
   // No error. Used as bound while iterating.
   QUIC_LAST_ERROR = 61,
 };
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicPacketPublicHeader();
   explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
   ~QuicPacketPublicHeader();
 
-  // Universal header. All QuicPacket headers will have a guid and public flags.
-  QuicGuid guid;
-  QuicGuidLength guid_length;
+  // Universal header. All QuicPacket headers will have a connection_id and
+  // public flags.
+  QuicConnectionId connection_id;
+  QuicConnectionIdLength connection_id_length;
   bool reset_flag;
   bool version_flag;
   QuicSequenceNumberLength sequence_number_length;
   QuicVersionVector versions;
 };
 
 // Header for Data or FEC packets.
 struct NET_EXPORT_PRIVATE QuicPacketHeader {
   QuicPacketHeader();
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header);
@@ skipping 351 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
   static QuicPacket* NewDataPacket(
       char* buffer,
       size_t length,
       bool owns_buffer,
-      QuicGuidLength guid_length,
+      QuicConnectionIdLength connection_id_length,
       bool includes_version,
       QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, guid_length,
+    return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
                           includes_version, sequence_number_length, false);
   }
 
   static QuicPacket* NewFecPacket(
       char* buffer,
       size_t length,
       bool owns_buffer,
-      QuicGuidLength guid_length,
+      QuicConnectionIdLength connection_id_length,
       bool includes_version,
       QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, guid_length,
+    return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
                           includes_version, sequence_number_length, true);
   }
 
   base::StringPiece FecProtectedData() const;
   base::StringPiece AssociatedData() const;
   base::StringPiece BeforePlaintext() const;
   base::StringPiece Plaintext() const;
 
   bool is_fec_packet() const { return is_fec_packet_; }
 
   char* mutable_data() { return buffer_; }
 
  private:
   QuicPacket(char* buffer,
              size_t length,
              bool owns_buffer,
-             QuicGuidLength guid_length,
+             QuicConnectionIdLength connection_id_length,
              bool includes_version,
              QuicSequenceNumberLength sequence_number_length,
              bool is_fec_packet);
 
   char* buffer_;
   const bool is_fec_packet_;
-  const QuicGuidLength guid_length_;
+  const QuicConnectionIdLength connection_id_length_;
   const bool includes_version_;
   const QuicSequenceNumberLength sequence_number_length_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacket);
 };
 
 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
  public:
   QuicEncryptedPacket(const char* buffer, size_t length);
   QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer);
@@ skipping 91 matching lines @@
   WriteStatus status;
   union {
     int bytes_written;  // only valid when status is OK
     int error_code;  // only valid when status is ERROR
   };
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_