Do not support Quic timestamp feedback type in the framer.

net/quic/quic_framer.cc

Index: net/quic/quic_framer.cc
diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
index 2eb3d6b859c3b63d9d75f78f53380dedb73ef121..fe705015c1ed98e677ca81155c5c6e6ba9a58ead 100644
--- a/net/quic/quic_framer.cc
+++ b/net/quic/quic_framer.cc
@@ -1418,53 +1418,8 @@ bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
 
   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;
@@ -1787,16 +1742,7 @@ size_t QuicFramer::ComputeFrameLength(
 
       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:
@@ -2093,7 +2039,8 @@ bool QuicFramer::AppendCongestionFeedbackFrame(
 
   switch (frame.type) {
     case kTimestamp: {
-      return AppendTimestampFrame(frame, writer);
+      // Timestamp feedback not supported.
+      return false;
     }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = frame.tcp;
@@ -2112,53 +2059,6 @@ bool QuicFramer::AppendCongestionFeedbackFrame(
   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,