Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

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_QUIC_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
-#include "net/quic/core/quic_protocol.h"
+#include "net/quic/core/quic_packets.h"
 
 namespace net {
 
 namespace test {
 class QuicFramerPeer;
 }  // namespace test
 
 class QuicDataReader;
 class QuicDataWriter;
 class QuicDecrypter;
@@ skipping 308 matching lines @@
   // Called when a PATH_CLOSED frame has been sent/received on |path_id|.
   void OnPathClosed(QuicPathId path_id);
 
   QuicTag last_version_tag() { return last_version_tag_; }
 
  private:
   friend class test::QuicFramerPeer;
 
   typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
 
-  // TODO(rch): Rename this to remove "New" from the name here, and elsewhere.
-  struct NewAckFrameInfo {
-    NewAckFrameInfo();
-    NewAckFrameInfo(const NewAckFrameInfo& other);
-    ~NewAckFrameInfo();
+  struct AckFrameInfo {
+    AckFrameInfo();
+    AckFrameInfo(const AckFrameInfo& other);
+    ~AckFrameInfo();
 
     // The maximum ack block length.
     QuicPacketNumber max_block_length;
     // Length of first ack block.
     QuicPacketNumber first_block_length;
     // Number of ACK blocks needed for the ACK frame.
     size_t num_ack_blocks;
   };
 
   bool ProcessDataPacket(QuicDataReader* reader,
@@ skipping 18 matching lines @@
 
   bool ProcessPathId(QuicDataReader* reader, QuicPathId* path_id);
   bool ProcessPacketSequenceNumber(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 ProcessNewAckFrame(QuicDataReader* reader,
-                          uint8_t frame_type,
-                          QuicAckFrame* 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,
                                QuicStopWaitingFrame* stop_waiting);
   bool ProcessRstStreamFrame(QuicDataReader* reader, QuicRstStreamFrame* frame);
   bool ProcessConnectionCloseFrame(QuicDataReader* reader,
                                    QuicConnectionCloseFrame* frame);
   bool ProcessGoAwayFrame(QuicDataReader* reader, QuicGoAwayFrame* frame);
   bool ProcessWindowUpdateFrame(QuicDataReader* reader,
                                 QuicWindowUpdateFrame* frame);
@@ skipping 29 matching lines @@
   const QuicTime::Delta CalculateTimestampFromWire(uint32_t time_delta_us);
 
   // Computes the wire size in bytes of time stamps in |ack|.
   size_t GetAckFrameTimeStampSize(const QuicAckFrame& ack);
 
   // Computes the wire size in bytes of the |ack| frame.
   size_t GetAckFrameSize(const QuicAckFrame& ack,
                          QuicPacketNumberLength packet_number_length);
 
   // Computes the wire size in bytes of the |ack| frame.
-  size_t GetNewAckFrameSize(const QuicAckFrame& ack);
+  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);
 
   // 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(
       QuicPacketNumberLength packet_number_length);
 
-  static NewAckFrameInfo GetNewAckFrameInfo(const QuicAckFrame& frame);
+  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 AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
-                                    QuicDataWriter* builder);
+  bool AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
+                                 QuicDataWriter* builder);
   bool AppendTimestampToAckFrame(const QuicAckFrame& frame,
                                  QuicDataWriter* builder);
   bool AppendStopWaitingFrame(const QuicPacketHeader& header,
                               const QuicStopWaitingFrame& frame,
                               QuicDataWriter* builder);
   bool AppendRstStreamFrame(const QuicRstStreamFrame& frame,
                             QuicDataWriter* builder);
   bool AppendConnectionCloseFrame(const QuicConnectionCloseFrame& frame,
                                   QuicDataWriter* builder);
   bool AppendGoAwayFrame(const QuicGoAwayFrame& frame, QuicDataWriter* writer);
@@ skipping 65 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_QUIC_FRAMER_H_