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 17 matching lines @@
 using ::operator<<;
 
 class QuicPacket;
 
 typedef uint64 QuicGuid;
 typedef uint32 QuicStreamId;
 typedef uint64 QuicStreamOffset;
 typedef uint64 QuicPacketSequenceNumber;
 typedef QuicPacketSequenceNumber QuicFecGroupNumber;
 typedef uint64 QuicPublicResetNonceProof;
+typedef uint8 QuicPacketEntropyHash;
 
 // TODO(rch): Consider Quic specific names for these constants.
 // Maximum size in bytes of a QUIC packet.
 const QuicByteCount kMaxPacketSize = 1200;
 
 // Maximum number of open streams per connection.
 const size_t kDefaultMaxStreamsPerConnection = 100;
 
 // Number of bytes reserved for guid in the packet header.
 const size_t kQuicGuidSize = 8;
@@ skipping 50 matching lines @@
 // Limit on the delta between stream IDs.
 const QuicStreamId kMaxStreamIdDelta = 100;
 
 // Reserved ID for the crypto stream.
 // TODO(rch): ensure that this is not usable by any other streams.
 const QuicStreamId kCryptoStreamId = 1;
 
 // Value which indicates this packet is not FEC protected.
 const uint8 kNoFecOffset = 0xFF;
 
-typedef std::pair<QuicPacketSequenceNumber, QuicPacket*> PacketPair;
-
 const int64 kDefaultTimeoutUs = 600000000;  // 10 minutes.
 
 enum QuicFrameType {
   PADDING_FRAME = 0,
   STREAM_FRAME,
   ACK_FRAME,
   CONGESTION_FEEDBACK_FRAME,
   RST_STREAM_FRAME,
   CONNECTION_CLOSE_FRAME,
+  GOAWAY_FRAME,
   NUM_FRAME_TYPES
 };
 
 enum QuicPacketPublicFlags {
   PACKET_PUBLIC_FLAGS_NONE = 0,
-  PACKET_PUBLIC_FLAGS_VERSION = 1,
-  PACKET_PUBLIC_FLAGS_RST = 2,  // Packet is a public reset packet.
-  PACKET_PUBLIC_FLAGS_MAX = 3  // Both bit set.
+  PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,
+  PACKET_PUBLIC_FLAGS_RST = 1 << 1,  // Packet is a public reset packet.
+  PACKET_PUBLIC_FLAGS_MAX = (1 << 2) - 1  // All bits set.
 };
 
 enum QuicPacketPrivateFlags {
   PACKET_PRIVATE_FLAGS_NONE = 0,
-  PACKET_PRIVATE_FLAGS_FEC = 1,  // Payload is FEC as opposed to frames.
-  PACKET_PRIVATE_FLAGS_MAX = PACKET_PRIVATE_FLAGS_FEC
+  PACKET_PRIVATE_FLAGS_FEC = 1 << 0,  // Payload is FEC as opposed to frames.
+  PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 1,
+  PACKET_PRIVATE_FLAGS_FEC_ENTROPY = 1 << 2,
+  PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1  // All bits set.
 };
 
 enum QuicVersion {
   QUIC_VERSION_1 = 0
 };
 
 enum QuicErrorCode {
   // Stream errors.
   QUIC_NO_ERROR = 0,
 
@@ skipping 11 matching lines @@
   // Control frame is malformed.
   QUIC_INVALID_PACKET_HEADER,
   // Frame data is malformed.
   QUIC_INVALID_FRAME_DATA,
   // FEC data is malformed.
   QUIC_INVALID_FEC_DATA,
   // Stream rst data is malformed
   QUIC_INVALID_RST_STREAM_DATA,
   // Connection close data is malformed.
   QUIC_INVALID_CONNECTION_CLOSE_DATA,
+  // GoAway data is malformed.
+  QUIC_INVALID_GOAWAY_DATA,
   // Ack data is malformed.
   QUIC_INVALID_ACK_DATA,
   // There was an error decrypting.
   QUIC_DECRYPTION_FAILURE,
   // There was an error encrypting.
   QUIC_ENCRYPTION_FAILURE,
   // The packet exceeded kMaxPacketSize.
   QUIC_PACKET_TOO_LARGE,
   // Data was sent for a stream which did not exist.
   QUIC_PACKET_FOR_NONEXISTENT_STREAM,
-  // The client is going away (browser close, etc.)
-  QUIC_CLIENT_GOING_AWAY,
-  // The server is going away (restart etc.)
-  QUIC_SERVER_GOING_AWAY,
+  // The peer is going away.  May be a client or server.
+  QUIC_PEER_GOING_AWAY,
   // A stream ID was invalid.
   QUIC_INVALID_STREAM_ID,
   // Too many streams already open.
   QUIC_TOO_MANY_OPEN_STREAMS,
   // Received public reset for this connection.
   QUIC_PUBLIC_RESET,
 
   // We hit our prenegotiated (or default) timeout
   QUIC_CONNECTION_TIMED_OUT,
 
@@ skipping 15 matching lines @@
   QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
   // A crypto message was received with a parameter that has no overlap
   // with the local parameter.
   QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP,
 };
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   // Universal header. All QuicPacket headers will have a guid and public flags.
   // TODO(satyamshekhar): Support versioning as per Protocol Negotiation Doc.
   QuicGuid guid;
-  QuicPacketPublicFlags flags;
+  bool reset_flag;
+  bool version_flag;
 };
 
 // Header for Data or FEC packets.
 struct QuicPacketHeader {
   QuicPacketHeader() {}
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header)
       : public_header(header) {}
+
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
+      std::ostream& os, const QuicPacketHeader& s);
+
   QuicPacketPublicHeader public_header;
-  QuicPacketPrivateFlags private_flags;
+  bool fec_flag;
+  bool fec_entropy_flag;
+  bool entropy_flag;
+  QuicPacketEntropyHash entropy_hash;
   QuicPacketSequenceNumber packet_sequence_number;
   QuicFecGroupNumber fec_group;
 };
 
 struct QuicPublicResetPacket {
   QuicPublicResetPacket() {}
   explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header)
       : public_header(header) {}
   QuicPacketPublicHeader public_header;
   QuicPacketSequenceNumber rejected_sequence_number;
@@ skipping 12 matching lines @@
                   base::StringPiece data);
 
   QuicStreamId stream_id;
   bool fin;
   QuicStreamOffset offset;  // Location of this data in the stream.
   base::StringPiece data;
 };
 
 // TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing
 // is finalized.
-typedef std::set<QuicPacketSequenceNumber> SequenceSet;
+typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet;
 // TODO(pwestin): Add a way to enforce the max size of this map.
 typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap;
 
 struct NET_EXPORT_PRIVATE ReceivedPacketInfo {
   ReceivedPacketInfo();
   ~ReceivedPacketInfo();
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const ReceivedPacketInfo& s);
 
-  // Records a packet receipt.
-  void RecordReceived(QuicPacketSequenceNumber sequence_number);
-
-  // True if the sequence number is greater than largest_observed or is listed
-  // as missing.
-  // Always returns false for sequence numbers less than least_unacked.
-  bool IsAwaitingPacket(QuicPacketSequenceNumber sequence_number) const;
-
-  // Clears all missing packets less than |least_unacked|.
-  void ClearMissingBefore(QuicPacketSequenceNumber least_unacked);
+  // Entropy hash of all packets up to largest observed not including missing
+  // packets.
+  QuicPacketEntropyHash entropy_hash;
 
   // The highest packet sequence number we've observed from the peer.
   //
   // In general, this should be the largest packet number we've received.  In
   // the case of truncated acks, we may have to advertise a lower "upper bound"
   // than largest received, to avoid implicitly acking missing packets that
   // don't fit in the missing packet list due to size limitations.  In this
   // case, largest_observed may be a packet which is also in the missing packets
   // list.
   QuicPacketSequenceNumber largest_observed;
 
+  // TODO(satyamshekhar): Can be optimized using an interval set like data
+  // structure.
   // The set of packets which we're expecting and have not received.
-  SequenceSet missing_packets;
+  SequenceNumberSet missing_packets;
 };
 
+// True if the sequence number is greater than largest_observed or is listed
+// as missing.
+// Always returns false for sequence numbers less than least_unacked.
+bool NET_EXPORT_PRIVATE IsAwaitingPacket(
+    const ReceivedPacketInfo& received_info,
+    QuicPacketSequenceNumber sequence_number);
+
+// Inserts missing packets between [lower, higher).
+void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
+    ReceivedPacketInfo* received_info,
+    QuicPacketSequenceNumber lower,
+    QuicPacketSequenceNumber higher);
+
 struct NET_EXPORT_PRIVATE SentPacketInfo {
   SentPacketInfo();
   ~SentPacketInfo();
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const SentPacketInfo& s);
 
+  // Entropy hash of all packets up to, but not including, the least unacked
+  // packet.
+  QuicPacketEntropyHash entropy_hash;
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame() {}
   // Testing convenience method to construct a QuicAckFrame with all packets
   // from least_unacked to largest_observed acked.
   QuicAckFrame(QuicPacketSequenceNumber largest_observed,
                QuicPacketSequenceNumber least_unacked);
@@ skipping 43 matching lines @@
   CongestionFeedbackType type;
   // This should really be a union, but since the inter arrival struct
   // is non-trivial, C++ prohibits it.
   CongestionFeedbackMessageTCP tcp;
   CongestionFeedbackMessageInterArrival inter_arrival;
   CongestionFeedbackMessageFixRate fix_rate;
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
   QuicRstStreamFrame() {}
-  QuicRstStreamFrame(QuicStreamId stream_id, uint64 offset,
-                     QuicErrorCode error_code)
-      : stream_id(stream_id), offset(offset), error_code(error_code) {
+  QuicRstStreamFrame(QuicStreamId stream_id, QuicErrorCode error_code)
+      : stream_id(stream_id), error_code(error_code) {
     DCHECK_LE(error_code, std::numeric_limits<uint8>::max());
   }
 
   QuicStreamId stream_id;
-  uint64 offset;
   QuicErrorCode error_code;
   std::string error_details;
 };
 
 struct NET_EXPORT_PRIVATE QuicConnectionCloseFrame {
   QuicErrorCode error_code;
   std::string error_details;
   QuicAckFrame ack_frame;
 };
 
+struct NET_EXPORT_PRIVATE QuicGoAwayFrame {
+  QuicGoAwayFrame() {}
+  QuicGoAwayFrame(QuicErrorCode error_code,
+                  QuicStreamId last_good_stream_id,
+                  const std::string& reason);
+
+  QuicErrorCode error_code;
+  QuicStreamId last_good_stream_id;
+  std::string reason_phrase;
+};
+
 struct NET_EXPORT_PRIVATE QuicFrame {
   QuicFrame() {}
   explicit QuicFrame(QuicPaddingFrame* padding_frame)
       : type(PADDING_FRAME),
         padding_frame(padding_frame) {
   }
   explicit QuicFrame(QuicStreamFrame* stream_frame)
       : type(STREAM_FRAME),
         stream_frame(stream_frame) {
   }
   explicit QuicFrame(QuicAckFrame* frame)
       : type(ACK_FRAME),
         ack_frame(frame) {
   }
   explicit QuicFrame(QuicCongestionFeedbackFrame* frame)
       : type(CONGESTION_FEEDBACK_FRAME),
         congestion_feedback_frame(frame) {
   }
   explicit QuicFrame(QuicRstStreamFrame* frame)
       : type(RST_STREAM_FRAME),
         rst_stream_frame(frame) {
   }
   explicit QuicFrame(QuicConnectionCloseFrame* frame)
       : type(CONNECTION_CLOSE_FRAME),
         connection_close_frame(frame) {
   }
+  explicit QuicFrame(QuicGoAwayFrame* frame)
+      : type(GOAWAY_FRAME),
+        goaway_frame(frame) {
+  }
 
   QuicFrameType type;
   union {
     QuicPaddingFrame* padding_frame;
     QuicStreamFrame* stream_frame;
     QuicAckFrame* ack_frame;
     QuicCongestionFeedbackFrame* congestion_feedback_frame;
     QuicRstStreamFrame* rst_stream_frame;
     QuicConnectionCloseFrame* connection_close_frame;
+    QuicGoAwayFrame* goaway_frame;
   };
 };
 
 typedef std::vector<QuicFrame> QuicFrames;
 
 struct NET_EXPORT_PRIVATE QuicFecData {
   QuicFecData();
 
   bool operator==(const QuicFecData& other) const;
 
@@ skipping 35 matching lines @@
   const char* buffer_;
   size_t length_;
   bool owns_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
   static QuicPacket* NewDataPacket(char* buffer,
-                               size_t length,
-                               bool owns_buffer) {
+                                   size_t length,
+                                   bool owns_buffer) {
     return new QuicPacket(buffer, length, owns_buffer, false);
   }
 
   static QuicPacket* NewFecPacket(char* buffer,
                                   size_t length,
                                   bool owns_buffer) {
     return new QuicPacket(buffer, length, owns_buffer, true);
   }
 
   base::StringPiece FecProtectedData() const {
@@ skipping 44 matching lines @@
 
   base::StringPiece AssociatedData() const {
     return base::StringPiece(data() + kStartOfHashData,
                              kStartOfEncryptedData - kStartOfHashData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
+class NET_EXPORT_PRIVATE RetransmittableFrames {
+ public:
+  RetransmittableFrames();
+  ~RetransmittableFrames();
+
+  // Allocates a local copy of the referenced StringPiece has QuicStreamFrame
+  // use it.
+  // Takes ownership of |stream_frame|.
+  const QuicFrame& AddStreamFrame(QuicStreamFrame* stream_frame);
+  // Takes ownership of the frame inside |frame|.
+  const QuicFrame& AddNonStreamFrame(const QuicFrame& frame);
+  const QuicFrames& frames() const { return frames_; }
+
+ private:
+  QuicFrames frames_;
+  // Data referenced by the StringPiece of a QuicStreamFrame.
+  std::vector<std::string*> stream_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(RetransmittableFrames);
+};
+
+struct NET_EXPORT_PRIVATE SerializedPacket {
+  SerializedPacket(QuicPacketSequenceNumber sequence_number,
+                   QuicPacket* packet,
+                   QuicPacketEntropyHash entropy_hash,
+                   RetransmittableFrames* retransmittable_frames)
+      : sequence_number(sequence_number),
+        packet(packet),
+        entropy_hash(entropy_hash),
+        retransmittable_frames(retransmittable_frames) { }
+
+  QuicPacketSequenceNumber sequence_number;
+  QuicPacket* packet;
+  QuicPacketEntropyHash entropy_hash;
+  RetransmittableFrames* retransmittable_frames;
+};
+
 // A struct for functions which consume data payloads and fins.
 // The first member of the pair indicates bytes consumed.
 // The second member of the pair indicates if an incoming fin was consumed.
 struct QuicConsumedData {
   QuicConsumedData(size_t bytes_consumed, bool fin_consumed)
       : bytes_consumed(bytes_consumed),
         fin_consumed(fin_consumed) {
   }
 
   // By default, gtest prints the raw bytes of an object. The bool data
   // member causes this object to have padding bytes, which causes the
   // default gtest object printer to read uninitialize memory. So we need
   // to teach gtest how to print this object.
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicConsumedData& s);
 
   size_t bytes_consumed;
   bool fin_consumed;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_