Landing Recent QUIC changes until 4/22/2016 14:55 UTC

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 <stdint.h>
 
@@ skipping 748 matching lines @@
   NEGOTIATION_IN_PROGRESS,
   // This indicates this endpoint has received a packet from the peer with a
   // version this endpoint supports.  Version negotiation is complete, and the
   // version number will no longer be sent with future packets.
   NEGOTIATED_VERSION
 };
 
 typedef QuicPacketPublicHeader QuicVersionNegotiationPacket;
 
 // A padding frame contains no payload.
-struct NET_EXPORT_PRIVATE QuicPaddingFrame {};
+struct NET_EXPORT_PRIVATE QuicPaddingFrame {
+  QuicPaddingFrame() : num_padding_bytes(-1) {}
+  explicit QuicPaddingFrame(int num_padding_bytes)
+      : num_padding_bytes(num_padding_bytes) {}
+
+  // -1: full padding to the end of a max-sized packet
+  // otherwise: only pad up to num_padding_bytes bytes
+  int num_padding_bytes;
+};
 
 // A ping frame contains no payload, though it is retransmittable,
 // and ACK'd just like other normal frames.
 struct NET_EXPORT_PRIVATE QuicPingFrame {};
 
 // A path MTU discovery frame contains no payload and is serialized as a ping
 // frame.
 struct NET_EXPORT_PRIVATE QuicMtuDiscoveryFrame {};
 
 class NET_EXPORT_PRIVATE QuicBufferAllocator {
@@ skipping 570 matching lines @@
                    bool has_ack,
                    bool has_stop_waiting);
   SerializedPacket(const SerializedPacket& other);
   ~SerializedPacket();
 
   // Not owned.
   const char* encrypted_buffer;
   QuicPacketLength encrypted_length;
   QuicFrames retransmittable_frames;
   IsHandshake has_crypto_handshake;
-  bool needs_padding;
+  // -1: full padding to the end of a max-sized packet
+  //  0: no padding
+  //  otherwise: only pad up to num_padding_bytes bytes
+  int num_padding_bytes;
   QuicPathId path_id;
   QuicPacketNumber packet_number;
   QuicPacketNumberLength packet_number_length;
   EncryptionLevel encryption_level;
   QuicPacketEntropyHash entropy_hash;
   bool has_ack;
   bool has_stop_waiting;
   QuicPacketNumber original_packet_number;
   TransmissionType transmission_type;
 
   // Optional notifiers which will be informed when this packet has been ACKed.
   std::list<AckListenerWrapper> listeners;
 };
 
 struct NET_EXPORT_PRIVATE TransmissionInfo {
   // Used by STL when assigning into a map.
   TransmissionInfo();
 
   // Constructs a Transmission with a new all_transmissions set
   // containing |packet_number|.
   TransmissionInfo(EncryptionLevel level,
                    QuicPacketNumberLength packet_number_length,
                    TransmissionType transmission_type,
                    QuicTime sent_time,
                    QuicPacketLength bytes_sent,
                    bool has_crypto_handshake,
-                   bool needs_padding);
+                   int num_padding_bytes);
 
   TransmissionInfo(const TransmissionInfo& other);
 
   ~TransmissionInfo();
 
   QuicFrames retransmittable_frames;
   EncryptionLevel encryption_level;
   QuicPacketNumberLength packet_number_length;
   QuicPacketLength bytes_sent;
   uint16_t nack_count;
   QuicTime sent_time;
   // Reason why this packet was transmitted.
   TransmissionType transmission_type;
   // In flight packets have not been abandoned or lost.
   bool in_flight;
   // True if the packet can never be acked, so it can be removed.
   bool is_unackable;
   // True if the packet contains stream data from the crypto stream.
   bool has_crypto_handshake;
-  // True if the packet needs padding if it's retransmitted.
-  bool needs_padding;
+  // Non-zero if the packet needs padding if it's retransmitted.
+  int num_padding_bytes;
   // Stores the packet number of the next retransmission of this packet.
   // Zero if the packet has not been retransmitted.
   QuicPacketNumber retransmission;
   // Non-empty if there is a listener for this packet.
   std::list<AckListenerWrapper> ack_listeners;
 };
 
 // Struct to store the pending retransmission information.
 struct PendingRetransmission {
   PendingRetransmission(QuicPathId path_id,
                         QuicPacketNumber packet_number,
                         TransmissionType transmission_type,
                         const QuicFrames& retransmittable_frames,
                         bool has_crypto_handshake,
-                        bool needs_padding,
+                        int num_padding_bytes,
                         EncryptionLevel encryption_level,
                         QuicPacketNumberLength packet_number_length)
       : packet_number(packet_number),
         retransmittable_frames(retransmittable_frames),
         transmission_type(transmission_type),
         path_id(path_id),
         has_crypto_handshake(has_crypto_handshake),
-        needs_padding(needs_padding),
+        num_padding_bytes(num_padding_bytes),
         encryption_level(encryption_level),
         packet_number_length(packet_number_length) {}
 
   QuicPacketNumber packet_number;
   const QuicFrames& retransmittable_frames;
   TransmissionType transmission_type;
   QuicPathId path_id;
   bool has_crypto_handshake;
-  bool needs_padding;
+  int num_padding_bytes;
   EncryptionLevel encryption_level;
   QuicPacketNumberLength packet_number_length;
 };
 
 // Convenience wrapper to wrap an iovec array and the total length, which must
 // be less than or equal to the actual total length of the iovecs.
 struct NET_EXPORT_PRIVATE QuicIOVector {
   QuicIOVector(const struct iovec* iov, int iov_count, size_t total_length)
       : iov(iov), iov_count(iov_count), total_length(total_length) {}
 
   const struct iovec* iov;
   const int iov_count;
   const size_t total_length;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_