Land Recent QUIC Changes

net/quic/quic_framer.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_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 26 matching lines @@
 const size_t kQuicStreamIdSize = 4;
 // Number of bytes reserved for fin flag in stream frame.
 const size_t kQuicStreamFinSize = 1;
 // Number of bytes reserved for byte offset in stream frame.
 const size_t kQuicStreamOffsetSize = 8;
 // Number of bytes reserved to store payload length in stream frame.
 const size_t kQuicStreamPayloadLengthSize = 2;
 
 // Size in bytes of the entropy hash sent in ack frames.
 const size_t kQuicEntropyHashSize = 1;
+// Size in bytes reserved for the delta time of the largest observed
+// sequence number in ack frames.
+const size_t kQuicDeltaTimeLargestObservedSize = 4;
 // Size in bytes reserved for the number of missing packets in ack frames.
 const size_t kNumberOfMissingPacketsSize = 1;
 
 // This class receives callbacks from the framer when packets
 // are processed.
 class NET_EXPORT_PRIVATE QuicFramerVisitorInterface {
  public:
   virtual ~QuicFramerVisitorInterface() {}
 
   // Called if an error is detected in the QUIC protocol.
@@ skipping 26 matching lines @@
 
   // Called when the complete header of a packet had been parsed.
   // If OnPacketHeader returns false, framing for this packet will cease.
   virtual bool OnPacketHeader(const QuicPacketHeader& header) = 0;
 
   // Called when a data packet is parsed that is part of an FEC group.
   // |payload| is the non-encrypted FEC protected payload of the packet.
   virtual void OnFecProtectedPayload(base::StringPiece payload) = 0;
 
   // Called when a StreamFrame has been parsed.
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) = 0;
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) = 0;
 
-  // Called when a AckFrame has been parsed.
-  virtual void OnAckFrame(const QuicAckFrame& frame) = 0;
+  // Called when a AckFrame has been parsed.  If OnAckFrame returns false,
+  // the framer will stop parsing the current packet.
+  virtual bool OnAckFrame(const QuicAckFrame& frame) = 0;
 
   // Called when a CongestionFeedbackFrame has been parsed.
-  virtual void OnCongestionFeedbackFrame(
+  virtual bool OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) = 0;
 
   // Called when a RstStreamFrame has been parsed.
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) = 0;
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) = 0;
 
   // Called when a ConnectionCloseFrame has been parsed.
-  virtual void OnConnectionCloseFrame(
+  virtual bool OnConnectionCloseFrame(
       const QuicConnectionCloseFrame& frame) = 0;
 
   // Called when a GoAwayFrame has been parsed.
-  virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) = 0;
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) = 0;
 
   // Called when FEC data has been parsed.
   virtual void OnFecData(const QuicFecData& fec) = 0;
 
   // Called when a packet has been completely processed.
   virtual void OnPacketComplete() = 0;
 };
 
 class NET_EXPORT_PRIVATE QuicFecBuilderInterface {
  public:
@@ skipping 187 matching lines @@
   bool WritePacketHeader(const QuicPacketHeader& header,
                          QuicDataWriter* writer);
 
   bool ProcessPublicHeader(QuicPacketPublicHeader* header);
 
   bool ProcessPacketHeader(QuicPacketHeader* header,
                            const QuicEncryptedPacket& packet);
 
   bool ProcessPacketSequenceNumber(QuicPacketSequenceNumber* sequence_number);
   bool ProcessFrameData();
-  bool ProcessStreamFrame();
+  bool ProcessStreamFrame(QuicStreamFrame* frame);
   bool ProcessAckFrame(QuicAckFrame* frame);
   bool ProcessReceivedInfo(ReceivedPacketInfo* received_info);
   bool ProcessSentInfo(SentPacketInfo* sent_info);
   bool ProcessQuicCongestionFeedbackFrame(
       QuicCongestionFeedbackFrame* congestion_feedback);
-  bool ProcessRstStreamFrame();
-  bool ProcessConnectionCloseFrame();
-  bool ProcessGoAwayFrame();
+  bool ProcessRstStreamFrame(QuicRstStreamFrame* frame);
+  bool ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame);
+  bool ProcessGoAwayFrame(QuicGoAwayFrame* frame);
 
   bool DecryptPayload(QuicPacketSequenceNumber packet_sequence_number,
                       bool version_flag,
                       const QuicEncryptedPacket& packet);
 
   // Returns the full packet sequence number from the truncated
   // wire format version and the last seen packet sequence number.
   QuicPacketSequenceNumber CalculatePacketSequenceNumberFromWire(
       QuicPacketSequenceNumber packet_sequence_number) const;
 
@@ skipping 52 matching lines @@
   // The time this frames was created.  Time written to the wire will be
   // written as a delta from this value.
   QuicTime creation_time_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_