Remove the "New" prefix from various Ack-related structs/methods in QuicFramer now that there are o…

net/quic/core/quic_framer.cc

 // 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.
 
 #include "net/quic/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 297 matching lines @@
   if (can_truncate) {
     // Truncate the frame so the packet will not exceed kMaxPacketSize.
     // Note that we may not use every byte of the writer in this case.
     DVLOG(1) << ENDPOINT
              << "Truncating large frame, free bytes: " << free_bytes;
     return free_bytes;
   }
   return 0;
 }
 
-QuicFramer::NewAckFrameInfo::NewAckFrameInfo()
+QuicFramer::AckFrameInfo::AckFrameInfo()
     : max_block_length(0), first_block_length(0), num_ack_blocks(0) {}
 
-QuicFramer::NewAckFrameInfo::NewAckFrameInfo(const NewAckFrameInfo& other) =
-    default;
+QuicFramer::AckFrameInfo::AckFrameInfo(const AckFrameInfo& other) = default;
 
-QuicFramer::NewAckFrameInfo::~NewAckFrameInfo() {}
+QuicFramer::AckFrameInfo::~AckFrameInfo() {}
 
 size_t QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
                                    const QuicFrames& frames,
                                    char* buffer,
                                    size_t packet_length) {
   QuicDataWriter writer(packet_length, buffer);
   if (!AppendPacketHeader(header, &writer)) {
     QUIC_BUG << "AppendPacketHeader failed";
     return 0;
   }
@@ skipping 12 matching lines @@
         writer.WritePadding();
         break;
       case STREAM_FRAME:
         if (!AppendStreamFrame(*frame.stream_frame, no_stream_frame_length,
                                &writer)) {
           QUIC_BUG << "AppendStreamFrame failed";
           return 0;
         }
         break;
       case ACK_FRAME:
-        if (!AppendNewAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
-          QUIC_BUG << "AppendNewAckFrameAndTypeByte failed";
+        if (!AppendAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
+          QUIC_BUG << "AppendAckFrameAndTypeByte failed";
           return 0;
         }
         break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(header, *frame.stop_waiting_frame,
                                     &writer)) {
           QUIC_BUG << "AppendStopWaitingFrame failed";
           return 0;
         }
         break;
@@ skipping 552 matching lines @@
       return PACKET_FLAGS_4BYTE_PACKET;
     case PACKET_6BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_6BYTE_PACKET;
     default:
       QUIC_BUG << "Unreachable case statement.";
       return PACKET_FLAGS_6BYTE_PACKET;
   }
 }
 
 // static
-QuicFramer::NewAckFrameInfo QuicFramer::GetNewAckFrameInfo(
+QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
     const QuicAckFrame& frame) {
-  NewAckFrameInfo new_ack_info;
+  AckFrameInfo new_ack_info;
   if (frame.packets.Empty()) {
     return new_ack_info;
   }
   // The first block is the last interval. It isn't encoded with the gap-length
   // encoding, so skip it.
   new_ack_info.first_block_length = frame.packets.LastIntervalLength();
   auto itr = frame.packets.rbegin();
   QuicPacketNumber previous_start = itr->min();
   new_ack_info.max_block_length = itr->Length();
   ++itr;
@@ skipping 100 matching lines @@
           DVLOG(1) << ENDPOINT << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
       // Ack Frame
       if (frame_type & kQuicFrameTypeAckMask) {
         QuicAckFrame frame;
-        if (!ProcessNewAckFrame(reader, frame_type, &frame)) {
+        if (!ProcessAckFrame(reader, frame_type, &frame)) {
           return RaiseError(QUIC_INVALID_ACK_DATA);
         }
         if (!visitor_->OnAckFrame(frame)) {
           DVLOG(1) << ENDPOINT << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
@@ skipping 175 matching lines @@
       set_detailed_error("Unable to read frame data.");
       return false;
     }
   }
   frame->data_buffer = data.data();
   frame->data_length = static_cast<uint16_t>(data.length());
 
   return true;
 }
 
-bool QuicFramer::ProcessNewAckFrame(QuicDataReader* reader,
-                                    uint8_t frame_type,
-                                    QuicAckFrame* ack_frame) {
+bool QuicFramer::ProcessAckFrame(QuicDataReader* reader,
+                                 uint8_t frame_type,
+                                 QuicAckFrame* ack_frame) {
   // Determine the two lengths from the frame type: largest acked length,
   // ack block length.
   const QuicPacketNumberLength ack_block_length =
       ReadSequenceNumberLength(frame_type);
   frame_type >>= kQuicSequenceNumberLengthShift;
   const QuicPacketNumberLength largest_acked_length =
       ReadSequenceNumberLength(frame_type);
   frame_type >>= kQuicSequenceNumberLengthShift;
   frame_type >>= kQuicHasMultipleAckBlocksShift;
   bool has_ack_blocks = frame_type & kQuicHasMultipleAckBlocksMask;
@@ skipping 435 matching lines @@
   }
 
   return 5 + 3 * (ack.received_packet_times.size() - 1);
 }
 
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
     QuicPacketNumberLength packet_number_length) {
   size_t ack_size = 0;
 
-  NewAckFrameInfo ack_info = GetNewAckFrameInfo(ack);
+  AckFrameInfo ack_info = GetAckFrameInfo(ack);
   QuicPacketNumberLength largest_acked_length =
       GetMinSequenceNumberLength(ack.largest_observed);
   QuicPacketNumberLength ack_block_length =
       GetMinSequenceNumberLength(ack_info.max_block_length);
 
   ack_size = GetMinAckFrameSize(quic_version_, largest_acked_length);
   // First ack block length.
   ack_size += ack_block_length;
   if (ack_info.num_ack_blocks != 0) {
     ack_size += kNumberOfAckBlocksSize;
@@ skipping 157 matching lines @@
     return false;
   }
   return true;
 }
 
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version);
   quic_version_ = version;
 }
 
-bool QuicFramer::AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
-                                              QuicDataWriter* writer) {
-  const NewAckFrameInfo new_ack_info = GetNewAckFrameInfo(frame);
+bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
+                                           QuicDataWriter* writer) {
+  const AckFrameInfo new_ack_info = GetAckFrameInfo(frame);
   QuicPacketNumber largest_acked = frame.largest_observed;
   QuicPacketNumberLength largest_acked_length =
       GetMinSequenceNumberLength(largest_acked);
   QuicPacketNumberLength ack_block_length =
       GetMinSequenceNumberLength(new_ack_info.max_block_length);
   // Calculate available bytes for timestamps and ack blocks.
   int32_t available_timestamp_and_ack_block_bytes =
       writer->capacity() - writer->length() - ack_block_length -
       GetMinAckFrameSize(quic_version_, largest_acked_length) -
       (new_ack_info.num_ack_blocks != 0 ? kNumberOfAckBlocksSize : 0);
@@ skipping 303 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << ENDPOINT << "Error: " << QuicErrorCodeToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net