Landing Recent QUIC changes until 3:35 PM, Apr 26, 2017 UTC-4

net/quic/core/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_CORE_QUIC_FRAMER_H_
 #define NET_QUIC_CORE_QUIC_FRAMER_H_
 
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/core/quic_packets.h"
+#include "net/quic/platform/api/quic_endian.h"
 #include "net/quic/platform/api/quic_export.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 
 namespace net {
 
 namespace test {
 class QuicFramerPeer;
 }  // namespace test
 
 class QuicDataReader;
@@ skipping 280 matching lines @@
                         char* buffer,
                         size_t buffer_len);
 
   // Returns the maximum length of plaintext that can be encrypted
   // to ciphertext no larger than |ciphertext_size|.
   size_t GetMaxPlaintextSize(size_t ciphertext_size);
 
   const std::string& detailed_error() { return detailed_error_; }
 
   // The minimum packet number length required to represent |packet_number|.
-  static QuicPacketNumberLength GetMinSequenceNumberLength(
+  static QuicPacketNumberLength GetMinPacketNumberLength(
       QuicPacketNumber packet_number);
 
   void SetSupportedVersions(const QuicVersionVector& versions) {
     supported_versions_ = versions;
     quic_version_ = versions[0];
   }
 
+  // Returns byte order to read/write integers and floating numbers.
+  Endianness endianness() const;
+
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
   Perspective perspective() const { return perspective_; }
 
   QuicTag last_version_tag() { return last_version_tag_; }
 
  private:
   friend class test::QuicFramerPeer;
 
   typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
@@ skipping 24 matching lines @@
                                        QuicPacketPublicHeader* public_header);
 
   bool ProcessPublicHeader(QuicDataReader* reader,
                            QuicPacketPublicHeader* header);
 
   // Processes the unauthenticated portion of the header into |header| from
   // the current QuicDataReader.  Returns true on success, false on failure.
   bool ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
                                     QuicPacketHeader* header);
 
-  bool ProcessPacketSequenceNumber(QuicDataReader* reader,
-                                   QuicPacketNumberLength packet_number_length,
-                                   QuicPacketNumber base_packet_number,
-                                   QuicPacketNumber* packet_number);
+  // First processes possibly truncated packet number. Calculates the full
+  // packet number from the truncated one and the last seen packet number, and
+  // stores it to |packet_number|.
+  bool ProcessAndCalculatePacketNumber(
+      QuicDataReader* reader,
+      QuicPacketNumberLength packet_number_length,
+      QuicPacketNumber base_packet_number,
+      QuicPacketNumber* packet_number);
   bool ProcessFrameData(QuicDataReader* reader, const QuicPacketHeader& header);
   bool ProcessStreamFrame(QuicDataReader* reader,
                           uint8_t frame_type,
                           QuicStreamFrame* frame);
   bool ProcessAckFrame(QuicDataReader* reader,
                        uint8_t frame_type,
                        QuicAckFrame* frame);
   bool ProcessTimestampsInAckFrame(QuicDataReader* reader, QuicAckFrame* frame);
   bool ProcessStopWaitingFrame(QuicDataReader* reader,
                                const QuicPacketHeader& public_header,
@@ skipping 37 matching lines @@
                          QuicPacketNumberLength packet_number_length);
 
   // Computes the wire size in bytes of the |ack| frame.
   size_t GetAckFrameSize(const QuicAckFrame& ack);
 
   // Computes the wire size in bytes of the payload of |frame|.
   size_t ComputeFrameLength(const QuicFrame& frame,
                             bool last_frame_in_packet,
                             QuicPacketNumberLength packet_number_length);
 
-  static bool AppendPacketSequenceNumber(
-      QuicPacketNumberLength packet_number_length,
-      QuicPacketNumber packet_number,
-      QuicDataWriter* writer);
+  static bool AppendPacketNumber(QuicPacketNumberLength packet_number_length,
+                                 QuicPacketNumber packet_number,
+                                 QuicDataWriter* writer);
+  static bool AppendStreamId(size_t stream_id_length,
+                             QuicStreamId stream_id,
+                             QuicDataWriter* writer);
+  static bool AppendStreamOffset(size_t offset_length,
+                                 QuicStreamOffset offset,
+                                 QuicDataWriter* writer);
 
   // Appends a single ACK block to |writer| and returns true if the block was
   // successfully appended.
   static bool AppendAckBlock(uint8_t gap,
                              QuicPacketNumberLength length_length,
                              QuicPacketNumber length,
                              QuicDataWriter* writer);
 
-  static uint8_t GetSequenceNumberFlags(
+  static uint8_t GetPacketNumberFlags(
       QuicPacketNumberLength packet_number_length);
 
   static AckFrameInfo GetAckFrameInfo(const QuicAckFrame& frame);
 
   // The Append* methods attempt to write the provided header or frame using the
   // |writer|, and return true if successful.
 
   bool AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
                                  QuicDataWriter* builder);
   bool AppendTimestampToAckFrame(const QuicAckFrame& frame,
@@ skipping 64 matching lines @@
   QuicTime::Delta last_timestamp_;
   // The diversification nonce from the last received packet.
   DiversificationNonce last_nonce_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_FRAMER_H_