Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

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 73 matching lines @@
 const uint8_t kQuicStreamDataLengthShift = 1;
 const uint8_t kQuicStreamDataLengthMask = 0x01;
 
 // Fin bit may be set or not.
 const uint8_t kQuicStreamFinShift = 1;
 const uint8_t kQuicStreamFinMask = 0x01;
 
 // packet number size shift used in AckFrames.
 const uint8_t kQuicSequenceNumberLengthShift = 2;
 
-// Acks may be truncated.
-const uint8_t kQuicAckTruncatedShift = 1;
-const uint8_t kQuicAckTruncatedMask = 0x01;
-
-// Acks may not have any nacks.
-const uint8_t kQuicHasNacksMask = 0x01;
 // Acks may have only one ack block.
 const uint8_t kQuicHasMultipleAckBlocksMask = 0x01;
 const uint8_t kQuicHasMultipleAckBlocksShift = 1;
 
 // Returns the absolute value of the difference between |a| and |b|.
 QuicPacketNumber Delta(QuicPacketNumber a, QuicPacketNumber b) {
   // Since these are unsigned numbers, we can't just return abs(a - b)
   if (a < b) {
     return b - a;
   }
@@ skipping 21 matching lines @@
       return PACKET_6BYTE_PACKET_NUMBER;
   }
 }
 
 }  // namespace
 
 QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
                        QuicTime creation_time,
                        Perspective perspective)
     : visitor_(nullptr),
-      entropy_calculator_(nullptr),
       error_(QUIC_NO_ERROR),
       last_packet_number_(0),
       largest_packet_number_(0),
       last_path_id_(kInvalidPathId),
       last_serialized_connection_id_(0),
       supported_versions_(supported_versions),
       decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_latch_(false),
       perspective_(perspective),
@@ skipping 16 matching lines @@
          GetStreamOffsetSize(offset) +
          (last_frame_in_packet ? 0 : kQuicStreamPayloadLengthSize);
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize(
     QuicVersion version,
     QuicPacketNumberLength largest_observed_length) {
   size_t min_size = kQuicFrameTypeSize + largest_observed_length +
                     kQuicDeltaTimeLargestObservedSize;
-  if (version <= QUIC_VERSION_33) {
-    return min_size + kQuicEntropyHashSize;
-  }
   return min_size + kQuicNumTimestampsSize;
 }
 
 // static
 size_t QuicFramer::GetStopWaitingFrameSize(
     QuicVersion version,
     QuicPacketNumberLength packet_number_length) {
   size_t min_size = kQuicFrameTypeSize + packet_number_length;
-  if (version <= QUIC_VERSION_33) {
-    return min_size + kQuicEntropyHashSize;
-  }
   return min_size;
 }
 
 // static
 size_t QuicFramer::GetRstStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize +
          kQuicErrorCodeSize;
 }
 
 // static
@@ skipping 115 matching lines @@
           GetMinAckFrameSize(quic_version_, PACKET_6BYTE_PACKET_NUMBER);
   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) << "Truncating large frame, free bytes: " << free_bytes;
     return free_bytes;
   }
   return 0;
 }
 
-QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) {}
-
-QuicFramer::AckFrameInfo::AckFrameInfo(const AckFrameInfo& other) = default;
-
-QuicFramer::AckFrameInfo::~AckFrameInfo() {}
-
-QuicFramer::AckBlock::AckBlock(uint8_t gap, QuicPacketNumber length)
-    : gap(gap), length(length) {}
-
-QuicFramer::AckBlock::AckBlock(const AckBlock& other) = default;
-
-QuicFramer::AckBlock::~AckBlock() {}
-
 QuicFramer::NewAckFrameInfo::NewAckFrameInfo()
     : max_block_length(0), first_block_length(0), num_ack_blocks(0) {}
 
 QuicFramer::NewAckFrameInfo::NewAckFrameInfo(const NewAckFrameInfo& other) =
     default;
 
 QuicFramer::NewAckFrameInfo::~NewAckFrameInfo() {}
 
-// static
-QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
-    const QuicPacketHeader& header) {
-  return header.entropy_flag << (header.packet_number % 8);
-}
-
 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 11 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 (quic_version_ <= QUIC_VERSION_33) {
-          if (!AppendAckFrameAndTypeByte(header, *frame.ack_frame, &writer)) {
-            QUIC_BUG << "AppendAckFrameAndTypeByte failed"
-                     << " header: " << header
-                     << " ack_fame: " << *frame.ack_frame;
-            return 0;
-          }
-        } else {
-          if (!AppendNewAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
-            QUIC_BUG << "AppendNewAckFrameAndTypeByte failed";
-            return 0;
-          }
+        if (!AppendNewAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
+          QUIC_BUG << "AppendNewAckFrameAndTypeByte failed";
+          return 0;
         }
         break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(header, *frame.stop_waiting_frame,
                                     &writer)) {
           QUIC_BUG << "AppendStopWaitingFrame failed";
           return 0;
         }
         break;
       case MTU_DISCOVERY_FRAME:
@@ skipping 207 matching lines @@
   }
 
   size_t decrypted_length = 0;
   if (!DecryptPayload(encrypted_reader, header, packet, decrypted_buffer,
                       buffer_length, &decrypted_length)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   QuicDataReader reader(decrypted_buffer, decrypted_length);
-  if (quic_version_ <= QUIC_VERSION_33) {
-    if (!ProcessAuthenticatedHeader(&reader, &header)) {
-      DVLOG(1) << "Unable to process packet header.  Stopping parsing.";
-      return false;
-    }
-  }
 
   // Set the last packet number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   SetLastPacketNumber(header);
 
   if (!visitor_->OnPacketHeader(header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
@@ skipping 73 matching lines @@
   }
 
   switch (header.public_header.connection_id_length) {
     case PACKET_0BYTE_CONNECTION_ID:
       if (!writer->WriteUInt8(public_flags |
                               PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
         return false;
       }
       break;
     case PACKET_8BYTE_CONNECTION_ID:
-      if (quic_version_ > QUIC_VERSION_32) {
-        public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
-        if (!FLAGS_quic_remove_v33_hacks2 &&
-            perspective_ == Perspective::IS_CLIENT) {
-          public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
-        }
-
-      } else {
+      public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
+      if (!FLAGS_quic_remove_v33_hacks2 &&
+          perspective_ == Perspective::IS_CLIENT) {
         public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
       }
       if (!writer->WriteUInt8(public_flags) ||
           !writer->WriteUInt64(header.public_header.connection_id)) {
         return false;
       }
       break;
   }
   last_serialized_connection_id_ = header.public_header.connection_id;
 
   if (header.public_header.version_flag) {
     DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
     QuicTag tag = QuicVersionToQuicTag(quic_version_);
     writer->WriteUInt32(tag);
     DVLOG(1) << "version = " << quic_version_ << ", tag = '"
-             << QuicUtils::TagToString(tag) << "'";
+             << QuicTagToString(tag) << "'";
   }
 
   if (header.public_header.multipath_flag &&
       !writer->WriteUInt8(header.path_id)) {
     return false;
   }
 
   if (header.public_header.nonce != nullptr &&
       !writer->WriteBytes(header.public_header.nonce,
                           kDiversificationNonceSize)) {
     return false;
   }
 
   if (!AppendPacketSequenceNumber(header.public_header.packet_number_length,
                                   header.packet_number, writer)) {
     return false;
   }
-  if (quic_version_ > QUIC_VERSION_33) {
-    return true;
-  }
-
-  uint8_t private_flags = 0;
-  if (header.entropy_flag) {
-    private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
-  }
-  if (!writer->WriteUInt8(private_flags)) {
-    return false;
-  }
 
   return true;
 }
 
 const QuicTime::Delta QuicFramer::CalculateTimestampFromWire(
     uint32_t time_delta_us) {
   // The new time_delta might have wrapped to the next epoch, or it
   // might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch. Select the time closest to the previous
   // time.
@@ skipping 134 matching lines @@
     last_version_tag_ = version_tag;
     QuicVersion version = QuicTagToQuicVersion(version_tag);
     if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
       set_detailed_error("Illegal public flags value.");
       return false;
     }
     public_header->versions.push_back(version);
   }
 
   // A nonce should only be present in packets from the server to the client,
-  // which are neither version negotiation nor public reset packets
-  // and only for versions after QUIC_VERSION_32. Earlier versions will
-  // set this bit when indicating an 8-byte connection ID, which should
-  // not be interpreted as indicating a nonce is present.
-  if (quic_version_ > QUIC_VERSION_32 &&
-      public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
+  // which are neither version negotiation nor public reset packets.
+  if (public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
       !(public_flags & PACKET_PUBLIC_FLAGS_VERSION) &&
       !(public_flags & PACKET_PUBLIC_FLAGS_RST) &&
       // The nonce flag from a client is ignored and is assumed to be an older
       // client indicating an eight-byte connection ID.
       perspective_ == Perspective::IS_CLIENT) {
     if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_.data()),
                            last_nonce_.size())) {
       set_detailed_error("Unable to read nonce.");
       return false;
     }
@@ skipping 31 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::AckFrameInfo QuicFramer::GetAckFrameInfo(
-    const QuicAckFrame& frame) {
-  AckFrameInfo ack_info;
-  if (frame.packets.Empty()) {
-    return ack_info;
-  }
-  DCHECK_GE(frame.largest_observed, frame.packets.Max());
-  QuicPacketNumber last_largest_missing = 0;
-  for (const Interval<QuicPacketNumber>& interval : frame.packets) {
-    for (QuicPacketNumber interval_start = interval.min();
-         interval_start < interval.max();
-         interval_start += (1ull + std::numeric_limits<uint8_t>::max())) {
-      uint8_t cur_range_length =
-          interval.max() - interval_start > std::numeric_limits<uint8_t>::max()
-              ? std::numeric_limits<uint8_t>::max()
-              : (interval.max() - interval_start) - 1;
-      ack_info.nack_ranges[interval_start] = cur_range_length;
-    }
-    ack_info.max_delta =
-        max(ack_info.max_delta, last_largest_missing == 0
-                                    ? QuicPacketNumber{0}
-                                    : (interval.min() - last_largest_missing));
-    last_largest_missing = interval.max() - 1;
-  }
-  // Include the range to the largest observed.
-  ack_info.max_delta =
-      max(ack_info.max_delta, frame.largest_observed - last_largest_missing);
-  return ack_info;
-}
-
-// static
 QuicFramer::NewAckFrameInfo QuicFramer::GetNewAckFrameInfo(
     const QuicAckFrame& frame) {
   NewAckFrameInfo 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();
@@ skipping 44 matching lines @@
     set_detailed_error("packet numbers cannot be 0.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedHeader(*header)) {
     return false;
   }
   return true;
 }
 
-bool QuicFramer::ProcessAuthenticatedHeader(QuicDataReader* reader,
-                                            QuicPacketHeader* header) {
-  uint8_t private_flags;
-  if (!reader->ReadBytes(&private_flags, 1)) {
-    set_detailed_error("Unable to read private flags.");
-    return RaiseError(QUIC_INVALID_PACKET_HEADER);
-  }
-
-  if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
-    set_detailed_error("Illegal private flags value.");
-    return RaiseError(QUIC_INVALID_PACKET_HEADER);
-  }
-
-  header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
-  header->entropy_hash = GetPacketEntropyHash(*header);
-  return true;
-}
-
 bool QuicFramer::ProcessPathId(QuicDataReader* reader, QuicPathId* path_id) {
   if (!reader->ReadBytes(path_id, 1)) {
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessPacketSequenceNumber(
     QuicDataReader* reader,
@@ skipping 36 matching lines @@
           DVLOG(1) << "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 (quic_version_ <= QUIC_VERSION_33) {
-          if (!ProcessAckFrame(reader, frame_type, &frame)) {
-            return RaiseError(QUIC_INVALID_ACK_DATA);
-          }
-        } else {
-          if (!ProcessNewAckFrame(reader, frame_type, &frame)) {
-            return RaiseError(QUIC_INVALID_ACK_DATA);
-          }
+        if (!ProcessNewAckFrame(reader, frame_type, &frame)) {
+          return RaiseError(QUIC_INVALID_ACK_DATA);
         }
         if (!visitor_->OnAckFrame(frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
       // This was a special frame type that did not match any
@@ skipping 172 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::ProcessAckFrame(QuicDataReader* reader,
-                                 uint8_t frame_type,
-                                 QuicAckFrame* ack_frame) {
-  // Determine the three lengths from the frame type: largest observed length,
-  // missing packet number length, and missing range length.
-  const QuicPacketNumberLength missing_packet_number_length =
-      ReadSequenceNumberLength(frame_type);
-  frame_type >>= kQuicSequenceNumberLengthShift;
-  const QuicPacketNumberLength largest_observed_packet_number_length =
-      ReadSequenceNumberLength(frame_type);
-  frame_type >>= kQuicSequenceNumberLengthShift;
-  ack_frame->is_truncated = frame_type & kQuicAckTruncatedMask;
-  frame_type >>= kQuicAckTruncatedShift;
-  bool has_nacks = frame_type & kQuicHasNacksMask;
-
-  if (!reader->ReadBytes(&ack_frame->entropy_hash, 1)) {
-    set_detailed_error("Unable to read entropy hash for received packets.");
-    return false;
-  }
-
-  if (!reader->ReadBytes(&ack_frame->largest_observed,
-                         largest_observed_packet_number_length)) {
-    set_detailed_error("Unable to read largest observed.");
-    return false;
-  }
-
-  uint64_t ack_delay_time_us;
-  if (!reader->ReadUFloat16(&ack_delay_time_us)) {
-    set_detailed_error("Unable to read ack delay time.");
-    return false;
-  }
-
-  if (ack_delay_time_us == kUFloat16MaxValue) {
-    ack_frame->ack_delay_time = QuicTime::Delta::Infinite();
-  } else {
-    ack_frame->ack_delay_time =
-        QuicTime::Delta::FromMicroseconds(ack_delay_time_us);
-  }
-
-  if (!ProcessTimestampsInAckFrame(reader, ack_frame)) {
-    return false;
-  }
-
-  if (!has_nacks) {
-    return true;
-  }
-
-  uint8_t num_missing_ranges;
-  if (!reader->ReadBytes(&num_missing_ranges, 1)) {
-    set_detailed_error("Unable to read num missing packet ranges.");
-    return false;
-  }
-
-  QuicPacketNumber last_packet_number = ack_frame->largest_observed;
-  for (size_t i = 0; i < num_missing_ranges; ++i) {
-    QuicPacketNumber missing_delta = 0;
-    if (!reader->ReadBytes(&missing_delta, missing_packet_number_length)) {
-      set_detailed_error("Unable to read missing packet number delta.");
-      return false;
-    }
-    last_packet_number -= missing_delta;
-    QuicPacketNumber range_length = 0;
-    if (!reader->ReadBytes(&range_length, PACKET_1BYTE_PACKET_NUMBER)) {
-      set_detailed_error("Unable to read missing packet number range.");
-      return false;
-    }
-    ack_frame->packets.Add(last_packet_number - range_length,
-                           last_packet_number + 1);
-    // Subtract an extra 1 to ensure ranges are represented efficiently and
-    // can't overlap by 1 packet number.  This allows a missing_delta of 0
-    // to represent an adjacent nack range.
-    last_packet_number -= (range_length + 1);
-  }
-
-  return true;
-}
-
 bool QuicFramer::ProcessNewAckFrame(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;
-  ack_frame->missing = false;
 
   if (!reader->ReadBytes(&ack_frame->largest_observed, largest_acked_length)) {
     set_detailed_error("Unable to read largest acked.");
     return false;
   }
 
   uint64_t ack_delay_time_us;
   if (!reader->ReadUFloat16(&ack_delay_time_us)) {
     set_detailed_error("Unable to read ack delay time.");
     return false;
@@ skipping 45 matching lines @@
 
   if (!ProcessTimestampsInAckFrame(reader, ack_frame)) {
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessTimestampsInAckFrame(QuicDataReader* reader,
                                              QuicAckFrame* ack_frame) {
-  if (ack_frame->is_truncated) {
-    return true;
-  }
   uint8_t num_received_packets;
   if (!reader->ReadBytes(&num_received_packets, 1)) {
     set_detailed_error("Unable to read num received packets.");
     return false;
   }
 
   if (num_received_packets > 0) {
     uint8_t delta_from_largest_observed;
     if (!reader->ReadBytes(&delta_from_largest_observed,
                            PACKET_1BYTE_PACKET_NUMBER)) {
@@ skipping 38 matching lines @@
       ack_frame->received_packet_times.push_back(
           std::make_pair(seq_num, creation_time_ + last_timestamp_));
     }
   }
   return true;
 }
 
 bool QuicFramer::ProcessStopWaitingFrame(QuicDataReader* reader,
                                          const QuicPacketHeader& header,
                                          QuicStopWaitingFrame* stop_waiting) {
-  if (quic_version_ <= QUIC_VERSION_33) {
-    if (!reader->ReadBytes(&stop_waiting->entropy_hash, 1)) {
-      set_detailed_error("Unable to read entropy hash for sent packets.");
-      return false;
-    }
-  }
-
   QuicPacketNumber least_unacked_delta = 0;
   if (!reader->ReadBytes(&least_unacked_delta,
                          header.public_header.packet_number_length)) {
     set_detailed_error("Unable to read least unacked delta.");
     return false;
   }
   DCHECK_GE(header.packet_number, least_unacked_delta);
   stop_waiting->least_unacked = header.packet_number - least_unacked_delta;
 
   return true;
@@ skipping 247 matching lines @@
   if (success) {
     visitor_->OnDecryptedPacket(decrypter_level_);
   } else if (alternative_decrypter_.get() != nullptr) {
     if (header.public_header.nonce != nullptr) {
       DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
       alternative_decrypter_->SetDiversificationNonce(
           *header.public_header.nonce);
     }
     bool try_alternative_decryption = true;
     if (alternative_decrypter_level_ == ENCRYPTION_INITIAL) {
-      if (perspective_ == Perspective::IS_CLIENT &&
-          quic_version_ > QUIC_VERSION_32) {
+      if (perspective_ == Perspective::IS_CLIENT) {
         if (header.public_header.nonce == nullptr) {
           // Can not use INITIAL decryption without a diversification nonce.
           try_alternative_decryption = false;
         }
       } else {
         DCHECK(header.public_header.nonce == nullptr);
       }
     }
 
     if (try_alternative_decryption) {
@@ skipping 33 matching lines @@
     return 0;
   }
 
   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;
-  if (quic_version_ <= QUIC_VERSION_33) {
-    AckFrameInfo ack_info = GetAckFrameInfo(ack);
-    QuicPacketNumberLength largest_observed_length =
-        GetMinSequenceNumberLength(ack.largest_observed);
-    QuicPacketNumberLength missing_packet_number_length =
-        GetMinSequenceNumberLength(ack_info.max_delta);
-
-    ack_size = GetMinAckFrameSize(quic_version_, largest_observed_length);
-    if (!ack_info.nack_ranges.empty()) {
-      ack_size += kNumberOfNackRangesSize;
-      ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) *
-                  (missing_packet_number_length + PACKET_1BYTE_PACKET_NUMBER);
-    }
-
-    // In version 23, if the ack will be truncated due to too many nack ranges,
-    // then do not include the number of timestamps (1 byte).
-    if (ack_info.nack_ranges.size() <= kMaxNackRanges) {
-      // 1 byte for the number of timestamps.
-      ack_size += 1;
-      ack_size += GetAckFrameTimeStampSize(ack);
-    }
-
-    return ack_size;
-  }
 
   NewAckFrameInfo ack_info = GetNewAckFrameInfo(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;
@@ skipping 159 matching lines @@
     return false;
   }
   return true;
 }
 
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version);
   quic_version_ = version;
 }
 
-bool QuicFramer::AppendAckFrameAndTypeByte(const QuicPacketHeader& header,
-                                           const QuicAckFrame& frame,
-                                           QuicDataWriter* writer) {
-  AckFrameInfo ack_info = GetAckFrameInfo(frame);
-  QuicPacketNumber ack_largest_observed = frame.largest_observed;
-  QuicPacketNumberLength largest_observed_length =
-      GetMinSequenceNumberLength(ack_largest_observed);
-  QuicPacketNumberLength missing_packet_number_length =
-      GetMinSequenceNumberLength(ack_info.max_delta);
-  // Determine whether we need to truncate ranges.
-  size_t available_range_bytes =
-      writer->capacity() - writer->length() - kNumberOfNackRangesSize -
-      GetMinAckFrameSize(quic_version_, largest_observed_length);
-  size_t max_num_ranges =
-      available_range_bytes /
-      (missing_packet_number_length + PACKET_1BYTE_PACKET_NUMBER);
-  max_num_ranges = min(kMaxNackRanges, max_num_ranges);
-  bool truncated = ack_info.nack_ranges.size() > max_num_ranges;
-  DVLOG_IF(1, truncated) << "Truncating ack from "
-                         << ack_info.nack_ranges.size() << " ranges to "
-                         << max_num_ranges;
-  // Write out the type byte by setting the low order bits and doing shifts
-  // to make room for the next bit flags to be set.
-  // Whether there are any nacks.
-  uint8_t type_byte = ack_info.nack_ranges.empty() ? 0 : kQuicHasNacksMask;
-
-  // truncating bit.
-  type_byte <<= kQuicAckTruncatedShift;
-  type_byte |= truncated ? kQuicAckTruncatedMask : 0;
-
-  // Largest observed packet number length.
-  type_byte <<= kQuicSequenceNumberLengthShift;
-  type_byte |= GetSequenceNumberFlags(largest_observed_length);
-
-  // Missing packet number length.
-  type_byte <<= kQuicSequenceNumberLengthShift;
-  type_byte |= GetSequenceNumberFlags(missing_packet_number_length);
-
-  type_byte |= kQuicFrameTypeAckMask;
-
-  if (!writer->WriteUInt8(type_byte)) {
-    QUIC_BUG << "type byte failed";
-    return false;
-  }
-
-  QuicPacketEntropyHash ack_entropy_hash = frame.entropy_hash;
-  NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin();
-  if (truncated) {
-    // Skip the nack ranges which the truncated ack won't include and set
-    // a correct largest observed for the truncated ack.
-    for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges);
-         ++i) {
-      ++ack_iter;
-    }
-    // If the last range is followed by acks, include them.
-    // If the last range is followed by another range, specify the end of the
-    // range as the largest_observed.
-    ack_largest_observed = ack_iter->first - 1;
-    // Also update the entropy so it matches the largest observed.
-    ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed);
-    ++ack_iter;
-  }
-
-  if (!writer->WriteUInt8(ack_entropy_hash)) {
-    QUIC_BUG << "hash failed.";
-    return false;
-  }
-
-  if (!AppendPacketSequenceNumber(largest_observed_length, ack_largest_observed,
-                                  writer)) {
-    QUIC_BUG << "AppendPacketSequenceNumber failed. "
-             << "largest_observed_length: " << largest_observed_length
-             << " ack_largest_observed: " << ack_largest_observed;
-    return false;
-  }
-
-  uint64_t ack_delay_time_us = kUFloat16MaxValue;
-  if (!frame.ack_delay_time.IsInfinite()) {
-    DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
-    ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
-  }
-
-  if (!writer->WriteUFloat16(ack_delay_time_us)) {
-    QUIC_BUG << "ack delay time failed.";
-    return false;
-  }
-
-  // Timestamp goes at the end of the required fields.
-  if (!truncated) {
-    if (!AppendTimestampToAckFrame(frame, writer)) {
-      QUIC_BUG << "AppendTimestampToAckFrame failed";
-      return false;
-    }
-  }
-
-  if (ack_info.nack_ranges.empty()) {
-    return true;
-  }
-
-  const uint8_t num_missing_ranges =
-      static_cast<uint8_t>(min(ack_info.nack_ranges.size(), max_num_ranges));
-  if (!writer->WriteBytes(&num_missing_ranges, 1)) {
-    QUIC_BUG << "num_missing_ranges failed: "
-             << static_cast<uint32_t>(num_missing_ranges);
-    return false;
-  }
-
-  int num_ranges_written = 0;
-  QuicPacketNumber last_sequence_written = ack_largest_observed;
-  for (; ack_iter != ack_info.nack_ranges.rend(); ++ack_iter) {
-    // Calculate the delta to the last number in the range.
-    QuicPacketNumber missing_delta =
-        last_sequence_written - (ack_iter->first + ack_iter->second);
-    if (!AppendPacketSequenceNumber(missing_packet_number_length, missing_delta,
-                                    writer)) {
-      QUIC_BUG << "AppendPacketSequenceNumber failed: "
-               << "missing_packet_number_length: "
-               << missing_packet_number_length << " missing_delta "
-               << missing_delta;
-      return false;
-    }
-    if (!AppendPacketSequenceNumber(PACKET_1BYTE_PACKET_NUMBER,
-                                    ack_iter->second, writer)) {
-      QUIC_BUG << "AppendPacketSequenceNumber failed";
-      return false;
-    }
-    // Subtract 1 so a missing_delta of 0 means an adjacent range.
-    last_sequence_written = ack_iter->first - 1;
-    ++num_ranges_written;
-  }
-  DCHECK_EQ(num_missing_ranges, num_ranges_written);
-
-  return true;
-}
-
 bool QuicFramer::AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
                                               QuicDataWriter* writer) {
   const NewAckFrameInfo new_ack_info = GetNewAckFrameInfo(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 =
@@ skipping 201 matching lines @@
 }
 
 bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
                                         const QuicStopWaitingFrame& frame,
                                         QuicDataWriter* writer) {
   DCHECK_GE(header.packet_number, frame.least_unacked);
   const QuicPacketNumber least_unacked_delta =
       header.packet_number - frame.least_unacked;
   const QuicPacketNumber length_shift =
       header.public_header.packet_number_length * 8;
-  if (quic_version_ <= QUIC_VERSION_33) {
-    if (!writer->WriteUInt8(frame.entropy_hash)) {
-      QUIC_BUG << " hash failed";
-      return false;
-    }
-  }
 
   if (least_unacked_delta >> length_shift > 0) {
     QUIC_BUG << "packet_number_length "
              << header.public_header.packet_number_length
              << " is too small for least_unacked_delta: " << least_unacked_delta
              << " packet_number:" << header.packet_number
              << " least_unacked:" << frame.least_unacked
              << " version:" << quic_version_;
     return false;
   }
@@ skipping 77 matching lines @@
 bool QuicFramer::AppendPathCloseFrame(const QuicPathCloseFrame& frame,
                                       QuicDataWriter* writer) {
   uint8_t path_id = static_cast<uint8_t>(frame.path_id);
   if (!writer->WriteUInt8(path_id)) {
     return false;
   }
   return true;
 }
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
-  DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
+  DVLOG(1) << "Error: " << QuicErrorCodeToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net