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 965 matching lines @@
         ++cur_range_length;
       } else {
         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 413 matching lines @@
     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 kInterArrival: {
-      CongestionFeedbackMessageInterArrival* inter_arrival =
-          &frame->inter_arrival;
+    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));
 
-        inter_arrival->received_packet_times.insert(
+        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;
-          inter_arrival->received_packet_times.insert(
+          timestamp->received_packet_times.insert(
               make_pair(packet, time_received.Add(
                   QuicTime::Delta::FromMicroseconds(time_delta_us))));
         }
       }
       break;
     }
     case kTCP: {
       CongestionFeedbackMessageTCP* tcp = &frame->tcp;
-      // TODO(ianswett): Remove receive window, since it's constant.
       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:
@@ skipping 298 matching lines @@
     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 kInterArrival: {
-          const CongestionFeedbackMessageInterArrival& inter_arrival =
-              congestion_feedback.inter_arrival;
+        case kTimestamp: {
+          const CongestionFeedbackMessageTimestamp& timestamp =
+              congestion_feedback.timestamp;
           len += 1;  // Number received packets.
-          if (inter_arrival.received_packet_times.size() > 0) {
+          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 *
-                (inter_arrival.received_packet_times.size() - 1);
+                (timestamp.received_packet_times.size() - 1);
           }
           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 kInterArrival: {
-      const CongestionFeedbackMessageInterArrival& inter_arrival =
-          frame.inter_arrival;
-      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;
-      }
-      // TODO(ianswett): Make num_received_packets a varint.
-      uint8 num_received_packets =
-          inter_arrival.received_packet_times.size();
-      if (!writer->WriteBytes(&num_received_packets, 1)) {
-        return false;
-      }
-      if (num_received_packets > 0) {
-        TimeMap::const_iterator it =
-            inter_arrival.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 != inter_arrival.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;
-          }
-        }
-      }
-      break;
+    case kTimestamp: {
+      return AppendTimestampFrame(frame, writer);
     }
     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