Land Recent QUIC Changes

net/quic/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/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 1410 matching lines @@
     }
     for (size_t i = 0; i <= range_length; ++i) {
       received_info->missing_packets.insert(last_sequence_number - i);
     }
     // Subtract an extra 1 to ensure ranges are represented efficiently and
     // can't overlap by 1 sequence number.  This allows a missing_delta of 0
     // to represent an adjacent nack range.
     last_sequence_number -= (range_length + 1);
   }
 
-  if (quic_version_ > QUIC_VERSION_14) {
+  if (quic_version_ != QUIC_VERSION_13) {
     // Parse the revived packets list.
     uint8 num_revived_packets;
     if (!reader_->ReadBytes(&num_revived_packets, 1)) {
       set_detailed_error("Unable to read num revived packets.");
       return false;
     }
 
     for (size_t i = 0; i < num_revived_packets; ++i) {
       QuicPacketSequenceNumber revived_packet = 0;
       if (!reader_->ReadBytes(&revived_packet,
@@ skipping 36 matching lines @@
     set_detailed_error("Unable to read congestion feedback type.");
     return false;
   }
   frame->type =
       static_cast<CongestionFeedbackType>(feedback_type);
 
   switch (frame->type) {
     case kInterArrival: {
       CongestionFeedbackMessageInterArrival* inter_arrival =
           &frame->inter_arrival;
-      if (quic_version_ <= QUIC_VERSION_14) {
+      if (quic_version_ == QUIC_VERSION_13) {
         uint16 unused_accumulated_number_of_lost_packets;
         if (!reader_->ReadUInt16(
                 &unused_accumulated_number_of_lost_packets)) {
           set_detailed_error(
               "Unable to read accumulated number of lost packets.");
           return false;
         }
       }
       uint8 num_received_packets;
       if (!reader_->ReadBytes(&num_received_packets, 1)) {
@@ skipping 46 matching lines @@
       uint32 bitrate = 0;
       if (!reader_->ReadUInt32(&bitrate)) {
         set_detailed_error("Unable to read bitrate.");
         return false;
       }
       frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate);
       break;
     }
     case kTCP: {
       CongestionFeedbackMessageTCP* tcp = &frame->tcp;
-      if (quic_version_ <= QUIC_VERSION_14) {
+      if (quic_version_ == QUIC_VERSION_13) {
         uint16 unused_accumulated_number_of_lost_packets;
         if (!reader_->ReadUInt16(&unused_accumulated_number_of_lost_packets)) {
           set_detailed_error(
               "Unable to read accumulated number of lost packets.");
           return false;
         }
       }
       // TODO(ianswett): Remove receive window, since it's constant.
       uint16 receive_window = 0;
       if (!reader_->ReadUInt16(&receive_window)) {
@@ skipping 276 matching lines @@
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack.received_info.largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
 
   size_t ack_size = GetMinAckFrameSize(quic_version_,
                                        sequence_number_length,
                                        largest_observed_length);
   if (!ack_info.nack_ranges.empty()) {
     ack_size += kNumberOfMissingPacketsSize  +
-        (quic_version_ <= QUIC_VERSION_14 ? 0 : kNumberOfRevivedPacketsSize);
+        (quic_version_ == QUIC_VERSION_13 ? 0 : kNumberOfRevivedPacketsSize);
     ack_size += ack_info.nack_ranges.size() *
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
     ack_size +=
         ack.received_info.revived_packets.size() * largest_observed_length;
   }
   return ack_size;
 }
 
 size_t QuicFramer::ComputeFrameLength(
     const QuicFrame& frame,
@@ skipping 12 matching lines @@
     case CONGESTION_FEEDBACK_FRAME: {
       size_t len = kQuicFrameTypeSize;
       const QuicCongestionFeedbackFrame& congestion_feedback =
           *frame.congestion_feedback_frame;
       len += 1;  // Congestion feedback type.
 
       switch (congestion_feedback.type) {
         case kInterArrival: {
           const CongestionFeedbackMessageInterArrival& inter_arrival =
               congestion_feedback.inter_arrival;
-          if (quic_version_ <= QUIC_VERSION_14) {
+          if (quic_version_ == QUIC_VERSION_13) {
             len += 2;  // Accumulated number of lost packets.
           }
           len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
             len += PACKET_6BYTE_SEQUENCE_NUMBER;  // Smallest received.
             len += 8;  // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
             len += PACKET_6BYTE_SEQUENCE_NUMBER *
                 (inter_arrival.received_packet_times.size() - 1);
           }
           break;
         }
         case kFixRate:
           len += 4;  // Bitrate.
           break;
         case kTCP:
-          if (quic_version_ <= QUIC_VERSION_14) {
+          if (quic_version_ == QUIC_VERSION_13) {
             len += 2;  // Accumulated number of lost packets.
           }
           len += 2;  // Receive window.
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
       return len;
@@ skipping 139 matching lines @@
       frame.received_info.largest_observed;
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack_largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
   // Determine whether we need to truncate ranges.
   size_t available_range_bytes = writer->capacity() - writer->length() -
       GetMinAckFrameSize(quic_version_,
                          header.public_header.sequence_number_length,
                          largest_observed_length) -
-      (quic_version_ <= QUIC_VERSION_14 ? 0 : kNumberOfRevivedPacketsSize);
+      (quic_version_ == QUIC_VERSION_13 ? 0 : kNumberOfRevivedPacketsSize);
   size_t max_num_ranges = available_range_bytes /
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
   max_num_ranges =
       min(static_cast<size_t>(numeric_limits<uint8>::max()), 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
@@ skipping 88 matching lines @@
     if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER,
                                     ack_iter->second, writer)) {
       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);
 
-  if (quic_version_ > QUIC_VERSION_14) {
+  if (quic_version_ != QUIC_VERSION_13) {
     // Append revived packets.
     // If not all the revived packets fit, only mention the ones that do.
     uint8 num_revived_packets =
         min(received_info.revived_packets.size(),
             static_cast<size_t>(numeric_limits<uint8>::max()));
     num_revived_packets = min(
         static_cast<size_t>(num_revived_packets),
         (writer->capacity() - writer->length()) / largest_observed_length);
     if (!writer->WriteBytes(&num_revived_packets, 1)) {
       return false;
@@ skipping 17 matching lines @@
     const QuicCongestionFeedbackFrame& frame,
     QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.type, 1)) {
     return false;
   }
 
   switch (frame.type) {
     case kInterArrival: {
       const CongestionFeedbackMessageInterArrival& inter_arrival =
           frame.inter_arrival;
-      if (quic_version_ <= QUIC_VERSION_14) {
+      if (quic_version_ == QUIC_VERSION_13) {
         // accumulated_number_of_lost_packets is removed.  Always write 0.
         if (!writer->WriteUInt16(0)) {
           return false;
         }
       }
       DCHECK_GE(numeric_limits<uint8>::max(),
                 inter_arrival.received_packet_times.size());
       if (inter_arrival.received_packet_times.size() >
           numeric_limits<uint8>::max()) {
         return false;
@@ skipping 45 matching lines @@
       if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) {
         return false;
       }
       break;
     }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = frame.tcp;
       DCHECK_LE(tcp.receive_window, 1u << 20);
       // Simple bit packing, don't send the 4 least significant bits.
       uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4);
-      if (quic_version_ <= QUIC_VERSION_14) {
+      if (quic_version_ == QUIC_VERSION_13) {
         // accumulated_number_of_lost_packets is removed.  Always write 0.
         if (!writer->WriteUInt16(0)) {
           return false;
         }
       }
       if (!writer->WriteUInt16(receive_window)) {
         return false;
       }
       break;
     }
@@ skipping 111 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net