Landing 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 957 matching lines @@
     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() &&
           *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] =
+            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] = 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) {
@@ skipping 414 matching lines @@
   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 kTimestamp: {
-      CongestionFeedbackMessageTimestamp* timestamp = &frame->timestamp;
-      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 > 0u) {
-        uint64 smallest_received;
-        if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                         &smallest_received)) {
-          set_detailed_error("Unable to read smallest received.");
-          return false;
-        }
-
-        uint64 time_received_us;
-        if (!reader_->ReadUInt64(&time_received_us)) {
-          set_detailed_error("Unable to read time received.");
-          return false;
-        }
-        QuicTime time_received = creation_time_.Add(
-            QuicTime::Delta::FromMicroseconds(time_received_us));
-
-        timestamp->received_packet_times.insert(
-            make_pair(smallest_received, time_received));
-
-        for (uint8 i = 0; i < num_received_packets - 1; ++i) {
-          uint16 sequence_delta;
-          if (!reader_->ReadUInt16(&sequence_delta)) {
-            set_detailed_error(
-                "Unable to read sequence delta in received packets.");
-            return false;
-          }
-
-          int32 time_delta_us;
-          if (!reader_->ReadBytes(&time_delta_us, sizeof(time_delta_us))) {
-            set_detailed_error(
-                "Unable to read time delta in received packets.");
-            return false;
-          }
-          QuicPacketSequenceNumber packet = smallest_received + sequence_delta;
-          timestamp->received_packet_times.insert(
-              make_pair(packet, time_received.Add(
-                  QuicTime::Delta::FromMicroseconds(time_delta_us))));
-        }
-      }
-      break;
+      set_detailed_error("Timestamp feedback not supported.");
+      return false;
     }
     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;
@@ skipping 302 matching lines @@
       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 kTimestamp: {
-          const CongestionFeedbackMessageTimestamp& timestamp =
-              congestion_feedback.timestamp;
-          len += 1;  // Number received packets.
-          if (!timestamp.received_packet_times.empty()) {
-            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 *
-                (timestamp.received_packet_times.size() - 1);
-          }
+          set_detailed_error("Timestamp feedback not supported.");
           break;
         }
         case kTCP:
           len += 2;  // Receive window.
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
@@ skipping 276 matching lines @@
 
 bool QuicFramer::AppendCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& frame,
     QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.type, 1)) {
     return false;
   }
 
   switch (frame.type) {
     case kTimestamp: {
-      return AppendTimestampFrame(frame, writer);
+      // Timestamp feedback not supported.
+      return false;
     }
     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::AppendTimestampFrame(
-    const QuicCongestionFeedbackFrame& frame,
-    QuicDataWriter* writer) {
-  const CongestionFeedbackMessageTimestamp& timestamp = frame.timestamp;
-  DCHECK_GE(numeric_limits<uint8>::max(),
-            timestamp.received_packet_times.size());
-  if (timestamp.received_packet_times.size() > numeric_limits<uint8>::max()) {
-    return false;
-  }
-  uint8 num_received_packets = timestamp.received_packet_times.size();
-  if (!writer->WriteBytes(&num_received_packets, 1)) {
-    return false;
-  }
-  if (num_received_packets > 0) {
-    TimeMap::const_iterator it = timestamp.received_packet_times.begin();
-
-    QuicPacketSequenceNumber lowest_sequence = it->first;
-    if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                    lowest_sequence, writer)) {
-      return false;
-    }
-
-    QuicTime lowest_time = it->second;
-    if (!writer->WriteUInt64(
-            lowest_time.Subtract(creation_time_).ToMicroseconds())) {
-      return false;
-    }
-
-    for (++it; it != timestamp.received_packet_times.end(); ++it) {
-      QuicPacketSequenceNumber sequence_delta = it->first - lowest_sequence;
-      DCHECK_GE(numeric_limits<uint16>::max(), sequence_delta);
-      if (sequence_delta > numeric_limits<uint16>::max()) {
-        return false;
-      }
-      if (!writer->WriteUInt16(static_cast<uint16>(sequence_delta))) {
-        return false;
-      }
-
-      int32 time_delta_us = it->second.Subtract(lowest_time).ToMicroseconds();
-      if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
 bool QuicFramer::AppendStopWaitingFrame(
     const QuicPacketHeader& header,
     const QuicStopWaitingFrame& frame,
     QuicDataWriter* writer) {
   DCHECK_GE(header.packet_sequence_number, frame.least_unacked);
   const QuicPacketSequenceNumber least_unacked_delta =
       header.packet_sequence_number - frame.least_unacked;
   const QuicPacketSequenceNumber length_shift =
       header.public_header.sequence_number_length * 8;
   if (!writer->WriteUInt8(frame.entropy_hash)) {
@@ skipping 92 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