Update from https://crrev.com/312398

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 44 matching lines @@
 // ResetStream        : 0b 00000001 (0x01)
 // ConnectionClose    : 0b 00000010 (0x02)
 // GoAway             : 0b 00000011 (0x03)
 // WindowUpdate       : 0b 00000100 (0x04)
 // Blocked            : 0b 00000101 (0x05)
 //
 // Special Frame Types encode both a Frame Type and corresponding flags
 // all in the Frame Type byte. Currently defined Special Frame Types are:
 // Stream             : 0b 1xxxxxxx
 // Ack                : 0b 01xxxxxx
-// CongestionFeedback : 0b 001xxxxx
 //
 // Semantics of the flag bits above (the x bits) depends on the frame type.
 
 // Masks to determine if the frame type is a special use
 // and for specific special frame types.
 const uint8 kQuicFrameTypeSpecialMask = 0xE0;  // 0b 11100000
 const uint8 kQuicFrameTypeStreamMask = 0x80;
 const uint8 kQuicFrameTypeAckMask = 0x40;
-const uint8 kQuicFrameTypeCongestionFeedbackMask = 0x20;
 
 // Stream frame relative shifts and masks for interpreting the stream flags.
 // StreamID may be 1, 2, 3, or 4 bytes.
 const uint8 kQuicStreamIdShift = 2;
 const uint8 kQuicStreamIDLengthMask = 0x03;
 
 // Offset may be 0, 2, 3, 4, 5, 6, 7, 8 bytes.
 const uint8 kQuicStreamOffsetShift = 3;
 const uint8 kQuicStreamOffsetMask = 0x07;
 
@@ skipping 267 matching lines @@
           return kNoPacket;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFrameAndTypeByte(
                 header, *frame.ack_frame, &writer)) {
           LOG(DFATAL) << "AppendAckFrameAndTypeByte failed";
           return kNoPacket;
         }
         break;
-      case CONGESTION_FEEDBACK_FRAME:
-        if (!AppendCongestionFeedbackFrame(
-                *frame.congestion_feedback_frame, &writer)) {
-          LOG(DFATAL) << "AppendCongestionFeedbackFrame failed";
-          return kNoPacket;
-        }
-        break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(
                 header, *frame.stop_waiting_frame, &writer)) {
           LOG(DFATAL) << "AppendStopWaitingFrame failed";
           return kNoPacket;
         }
         break;
       case PING_FRAME:
         // Ping has no payload.
         break;
@@ skipping 738 matching lines @@
           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;
       }
 
-      // Congestion Feedback Frame
-      if (frame_type & kQuicFrameTypeCongestionFeedbackMask) {
-        if (quic_version_ > QUIC_VERSION_22) {
-          set_detailed_error("Congestion Feedback Frame has been deprecated.");
-          DLOG(WARNING) << "Congestion Feedback Frame has been deprecated.";
-        }
-        QuicCongestionFeedbackFrame frame;
-        if (!ProcessCongestionFeedbackFrame(&frame)) {
-          return RaiseError(QUIC_INVALID_CONGESTION_FEEDBACK_DATA);
-        }
-        if (!visitor_->OnCongestionFeedbackFrame(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
       // of the known ones. Error.
       set_detailed_error("Illegal frame type.");
       DLOG(WARNING) << "Illegal frame type: "
                     << static_cast<int>(frame_type);
       return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
 
     switch (frame_type) {
       case PADDING_FRAME:
@@ skipping 244 matching lines @@
       return false;
     }
 
     ack_frame->revived_packets.insert(revived_packet);
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessTimestampsInAckFrame(QuicAckFrame* ack_frame) {
-  if (version() > QUIC_VERSION_22 && !ack_frame->is_truncated) {
+  if (!ack_frame->is_truncated) {
     uint8 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 delta_from_largest_observed;
       if (!reader_->ReadBytes(&delta_from_largest_observed,
                               PACKET_1BYTE_SEQUENCE_NUMBER)) {
@@ skipping 56 matching lines @@
     set_detailed_error("Unable to read least unacked delta.");
     return false;
   }
   DCHECK_GE(header.packet_sequence_number, least_unacked_delta);
   stop_waiting->least_unacked =
       header.packet_sequence_number - least_unacked_delta;
 
   return true;
 }
 
-bool QuicFramer::ProcessCongestionFeedbackFrame(
-    QuicCongestionFeedbackFrame* frame) {
-  uint8 feedback_type;
-  if (!reader_->ReadBytes(&feedback_type, 1)) {
-    set_detailed_error("Unable to read congestion feedback type.");
-    return false;
-  }
-  frame->type =
-      static_cast<CongestionFeedbackType>(feedback_type);
-
-  switch (frame->type) {
-    case kTCP: {
-      CongestionFeedbackMessageTCP* tcp = &frame->tcp;
-      uint16 receive_window = 0;
-      if (!reader_->ReadUInt16(&receive_window)) {
-        set_detailed_error("Unable to read receive window.");
-        return false;
-      }
-      // Simple bit packing, don't send the 4 least significant bits.
-      tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4;
-      break;
-    }
-    default:
-      set_detailed_error("Illegal congestion feedback type.");
-      DLOG(WARNING) << "Illegal congestion feedback type: "
-                    << frame->type;
-      return RaiseError(QUIC_INVALID_FRAME_DATA);
-  }
-
-  return true;
-}
-
 bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame* frame) {
   if (!reader_->ReadUInt32(&frame->stream_id)) {
     set_detailed_error("Unable to read stream_id.");
     return false;
   }
 
   if (!reader_->ReadUInt64(&frame->byte_offset)) {
     set_detailed_error("Unable to read rst stream sent byte offset.");
     return false;
   }
@@ skipping 254 matching lines @@
   if (!ack_info.nack_ranges.empty()) {
     ack_size += kNumberOfNackRangesSize  + kNumberOfRevivedPacketsSize;
     ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) *
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
     ack_size += min(ack.revived_packets.size(),
                     kMaxRevivedPackets) * largest_observed_length;
   }
 
   // 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 (version() > QUIC_VERSION_22 &&
-      ack_info.nack_ranges.size() <= kMaxNackRanges) {
+  if (ack_info.nack_ranges.size() <= kMaxNackRanges) {
     // 1 byte for the number of timestamps.
     ack_size += 1;
     if (ack.received_packet_times.size() > 0) {
       // 1 byte for sequence number, 4 bytes for timestamp for the first
       // packet.
       ack_size += 5;
 
       // 1 byte for sequence number, 2 bytes for timestamp for the other
       // packets.
       ack_size += 3 * (ack.received_packet_times.size() - 1);
@@ skipping 11 matching lines @@
   switch (frame.type) {
     case STREAM_FRAME:
       return GetMinStreamFrameSize(frame.stream_frame->stream_id,
                                    frame.stream_frame->offset,
                                    last_frame_in_packet,
                                    is_in_fec_group) +
           frame.stream_frame->data.TotalBufferSize();
     case ACK_FRAME: {
       return GetAckFrameSize(*frame.ack_frame, sequence_number_length);
     }
-    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 kTCP:
-          len += 2;  // Receive window.
-          break;
-        default:
-          set_detailed_error("Illegal feedback type.");
-          DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type;
-          break;
-      }
-      return len;
-    }
     case STOP_WAITING_FRAME:
       return GetStopWaitingFrameSize(sequence_number_length);
     case PING_FRAME:
       // Ping has no payload.
       return kQuicFrameTypeSize;
     case RST_STREAM_FRAME:
       return GetMinRstStreamFrameSize() +
           frame.rst_stream_frame->error_details.size();
     case CONNECTION_CLOSE_FRAME:
       return GetMinConnectionCloseFrameSize() +
@@ skipping 41 matching lines @@
       }
 
       // stream id 2 bits.
       type_byte <<= kQuicStreamIdShift;
       type_byte |= GetStreamIdSize(frame.stream_frame->stream_id) - 1;
       type_byte |= kQuicFrameTypeStreamMask;  // Set Stream Frame Type to 1.
       break;
     }
     case ACK_FRAME:
       return true;
-    case CONGESTION_FEEDBACK_FRAME: {
-      // TODO(ianswett): Use extra 5 bits in the congestion feedback framing.
-      type_byte = kQuicFrameTypeCongestionFeedbackMask;
-      break;
-    }
     default:
       type_byte = static_cast<uint8>(frame.type);
       break;
   }
 
   return writer->WriteUInt8(type_byte);
 }
 
 // static
 bool QuicFramer::AppendPacketSequenceNumber(
@@ skipping 139 matching lines @@
     DCHECK_LE(0u, frame.delta_time_largest_observed.ToMicroseconds());
     delta_time_largest_observed_us =
         frame.delta_time_largest_observed.ToMicroseconds();
   }
 
   if (!writer->WriteUFloat16(delta_time_largest_observed_us)) {
     return false;
   }
 
   // Timestamp goes at the end of the required fields.
-  if (version() > QUIC_VERSION_22 && !truncated) {
+  if (!truncated) {
     if (!AppendTimestampToAckFrame(frame, writer)) {
       return false;
     }
   }
 
   if (ack_info.nack_ranges.empty()) {
     return true;
   }
 
   const uint8 num_missing_ranges =
@@ skipping 38 matching lines @@
     LOG_IF(DFATAL, !ContainsKey(frame.missing_packets, *iter));
     if (!AppendPacketSequenceNumber(largest_observed_length,
                                     *iter, writer)) {
       return false;
     }
   }
 
   return true;
 }
 
-bool QuicFramer::AppendCongestionFeedbackFrame(
-    const QuicCongestionFeedbackFrame& frame,
-    QuicDataWriter* writer) {
-  if (!writer->WriteBytes(&frame.type, 1)) {
-    return false;
-  }
-
-  switch (frame.type) {
-    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 (!writer->WriteUInt16(receive_window)) {
-        return false;
-      }
-      break;
-    }
-    default:
-      return false;
-  }
-
-  return true;
-}
-
 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
                                            QuicDataWriter* writer) {
   DCHECK_GE(version(), QUIC_VERSION_23);
   DCHECK_GE(numeric_limits<uint8>::max(), frame.received_packet_times.size());
   // num_received_packets is only 1 byte.
   if (frame.received_packet_times.size() > numeric_limits<uint8>::max()) {
     return false;
   }
 
   uint8 num_received_packets = frame.received_packet_times.size();
@@ skipping 158 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(nullptr);
   return false;
 }
 
 }  // namespace net