Update from https://crrev.com/306655

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 763 matching lines @@
   if (header.fec_flag) {
     private_flags |= PACKET_PRIVATE_FLAGS_FEC;
   }
   if (!writer->WriteUInt8(private_flags)) {
     return false;
   }
 
   // The FEC group number is the sequence number of the first fec
   // protected packet, or 0 if this packet is not protected.
   if (header.is_in_fec_group == IN_FEC_GROUP) {
-    DCHECK_GE(header.packet_sequence_number, header.fec_group);
-    DCHECK_GT(255u, header.packet_sequence_number - header.fec_group);
+    DCHECK_LE(header.fec_group, header.packet_sequence_number);
+    DCHECK_LT(header.packet_sequence_number - header.fec_group, 255u);
     // Offset from the current packet sequence number to the first fec
     // protected packet.
     uint8 first_fec_protected_packet_offset =
-        header.packet_sequence_number - header.fec_group;
+        static_cast<uint8>(header.packet_sequence_number - header.fec_group);
     if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
       return false;
     }
   }
 
   return true;
 }
 
 const QuicTime::Delta QuicFramer::CalculateTimestampFromWire(
     uint32 time_delta_us) {
@@ skipping 180 matching lines @@
   AckFrameInfo ack_info;
   if (frame.missing_packets.empty()) {
     return ack_info;
   }
   DCHECK_GE(frame.largest_observed, *frame.missing_packets.rbegin());
   size_t cur_range_length = 0;
   SequenceNumberSet::const_iterator iter = frame.missing_packets.begin();
   QuicPacketSequenceNumber last_missing = *iter;
   ++iter;
   for (; iter != frame.missing_packets.end(); ++iter) {
-    if (cur_range_length != numeric_limits<uint8>::max() &&
+    if (cur_range_length < numeric_limits<uint8>::max() &&
         *iter == (last_missing + 1)) {
       ++cur_range_length;
     } else {
-      ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length;
+      ack_info.nack_ranges[last_missing - cur_range_length] =
+          static_cast<uint8>(cur_range_length);
       cur_range_length = 0;
     }
     ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing);
     last_missing = *iter;
   }
   // Include the last nack range.
-  ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length;
+  ack_info.nack_ranges[last_missing - cur_range_length] =
+      static_cast<uint8>(cur_range_length);
   // Include the range to the largest observed.
   ack_info.max_delta =
       max(ack_info.max_delta, frame.largest_observed - last_missing);
   return ack_info;
 }
 
 bool QuicFramer::ProcessPacketHeader(
     QuicPacketHeader* header,
     const QuicEncryptedPacket& packet) {
   if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length,
@@ skipping 885 matching lines @@
       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 = frame.type;
+      type_byte = static_cast<uint8>(frame.type);
       break;
   }
 
   return writer->WriteUInt8(type_byte);
 }
 
 // static
 bool QuicFramer::AppendPacketSequenceNumber(
     QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number,
@@ skipping 32 matching lines @@
     QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
     LOG(DFATAL) << "Writing stream id size failed.";
     return false;
   }
   if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
     LOG(DFATAL) << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
-    if (!writer->WriteUInt16(frame.data.TotalBufferSize())) {
+    if ((frame.data.TotalBufferSize() > std::numeric_limits<uint16>::max()) ||
+        !writer->WriteUInt16(
+            static_cast<uint16>(frame.data.TotalBufferSize()))) {
       LOG(DFATAL) << "Writing stream frame length failed";
       return false;
     }
   }
 
   if (!writer->WriteIOVector(frame.data)) {
     LOG(DFATAL) << "Writing frame data failed.";
     return false;
   }
   return true;
@@ skipping 93 matching lines @@
     if (!AppendTimestampToAckFrame(frame, writer)) {
       return false;
     }
   }
 
   if (ack_info.nack_ranges.empty()) {
     return true;
   }
 
   const uint8 num_missing_ranges =
-      min(ack_info.nack_ranges.size(), max_num_ranges);
+      static_cast<uint8>(min(ack_info.nack_ranges.size(), max_num_ranges));
   if (!writer->WriteBytes(&num_missing_ranges, 1)) {
     return false;
   }
 
   int num_ranges_written = 0;
   QuicPacketSequenceNumber 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.
     QuicPacketSequenceNumber missing_delta =
         last_sequence_written - (ack_iter->first + ack_iter->second);
     if (!AppendPacketSequenceNumber(missing_sequence_number_length,
                                     missing_delta, writer)) {
       return false;
     }
     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);
 
   // Append revived packets.
   // If not all the revived packets fit, only mention the ones that do.
-  uint8 num_revived_packets = min(frame.revived_packets.size(),
-                                  kMaxRevivedPackets);
-  num_revived_packets = min(
+  uint8 num_revived_packets =
+      static_cast<uint8>(min(frame.revived_packets.size(), kMaxRevivedPackets));
+  num_revived_packets = static_cast<uint8>(min(
       static_cast<size_t>(num_revived_packets),
-      (writer->capacity() - writer->length()) / largest_observed_length);
+      (writer->capacity() - writer->length()) / largest_observed_length));
   if (!writer->WriteBytes(&num_revived_packets, 1)) {
     return false;
   }
 
   SequenceNumberSet::const_iterator iter = frame.revived_packets.begin();
   for (int i = 0; i < num_revived_packets; ++i, ++iter) {
     LOG_IF(DFATAL, !ContainsKey(frame.missing_packets, *iter));
     if (!AppendPacketSequenceNumber(largest_observed_length,
                                     *iter, writer)) {
       return false;
@@ skipping 199 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