Change the wire format of the ack frame to include a compressed version

of the previous CongestionFeedback Timestamp frame.
Adds QUIC_VERSION_23. Deprecate CongestionFeedbackFrame

1 bytes - num_received_packets
First packet:
1 byte - distance from the largest observed in sequence number space.
4 bytes - mod of microseconds since the connection's creation when the
  packet arrived.  (1.1hrs in us)
Every other packet:
1 byte - distance from the largest observed in sequence number space.
2 bytes - mod of microseconds since the previous timestamp

Merge internal change: 73740829

The following are chromium specific changes:
+ Changed ACK frame not to send CongestionFeedback frame
+ Added received_packet_times to ACK frame.
+ The timestamp that is sent is relative to creation time, thus passed
  MockClock's now() as argument to AckFrame and it is used to pass
  QuicFramer's creation time and received_packet_times.

R=cyr@google.com, ianswett@google.com, rch@chromium.org

Review URL: https://codereview.chromium.org/478153003

Cr-Commit-Position: refs/heads/master@{#291830}

net/quic/congestion_control/receive_algorithm_interface.cc

@@ -14,9 +14,6 @@ ReceiveAlgorithmInterface* ReceiveAlgorithmInterface::Create(
   switch (type) {
     case kTCP:
       return new TcpReceiver();
-    case kTimestamp:
-      LOG(DFATAL) << "Timestamp congestion feedback is not supported";
-      return NULL;
   }
   return NULL;
 }

net/quic/crypto/crypto_protocol.h

@@ -49,7 +49,6 @@ const QuicTag kSRBF = TAG('S', 'R', 'B', 'F');   // Socket receive buffer
 
 // Congestion control feedback types
 const QuicTag kQBIC = TAG('Q', 'B', 'I', 'C');   // TCP cubic
-const QuicTag kTSTP = TAG('T', 'S', 'T', 'P');   // Timestamp
 
 // Connection options (COPT) values
 const QuicTag kTBBR = TAG('T', 'B', 'B', 'R');   // Reduced Buffer Bloat TCP

net/quic/quic_config_test.cc

@@ -80,7 +80,6 @@ TEST_F(QuicConfigTest, ToHandshakeMessage) {
 TEST_F(QuicConfigTest, ProcessClientHello) {
   QuicConfig client_config;
   QuicTagVector cgst;
-  cgst.push_back(kTSTP);
   cgst.push_back(kQBIC);
   client_config.set_congestion_feedback(cgst, kQBIC);
   client_config.set_idle_connection_state_lifetime(
@@ -256,7 +255,7 @@ TEST_F(QuicConfigTest, MultipleNegotiatedValuesInVectorTag) {
   QuicConfig server_config;
   QuicTagVector cgst;
   cgst.push_back(kQBIC);
-  cgst.push_back(kTSTP);
+  cgst.push_back(kTBBR);
   server_config.set_congestion_feedback(cgst, kQBIC);
 
   CryptoHandshakeMessage msg;
@@ -271,8 +270,8 @@ TEST_F(QuicConfigTest, NoOverLapInCGST) {
   QuicConfig server_config;
   server_config.SetDefaults();
   QuicTagVector cgst;
-  cgst.push_back(kTSTP);
-  server_config.set_congestion_feedback(cgst, kTSTP);
+  cgst.push_back(kTBBR);
+  server_config.set_congestion_feedback(cgst, kTBBR);
 
   CryptoHandshakeMessage msg;
   string error_details;

net/quic/quic_connection.cc

@@ -211,7 +211,7 @@ QuicConnection::QuicConnection(QuicConnectionId connection_id,
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       pending_version_negotiation_packet_(false),
-      received_packet_manager_(kTCP, &stats_),
+      received_packet_manager_(&stats_),
       ack_queued_(false),
       stop_waiting_count_(0),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
@@ -269,7 +269,6 @@ QuicConnection::~QuicConnection() {
 void QuicConnection::SetFromConfig(const QuicConfig& config) {
   SetIdleNetworkTimeout(config.idle_connection_state_lifetime());
   sent_packet_manager_.SetFromConfig(config);
-  // TODO(satyamshekhar): Set congestion control and ICSL also.
 }
 
 bool QuicConnection::SelectMutualVersion(
@@ -1574,15 +1573,16 @@ void QuicConnection::SendPing() {
 void QuicConnection::SendAck() {
   ack_alarm_->Cancel();
   stop_waiting_count_ = 0;
-  // TODO(rch): delay this until the CreateFeedbackFrame
-  // method is invoked.  This requires changes SetShouldSendAck
-  // to be a no-arg method, and re-jiggering its implementation.
   bool send_feedback = false;
-  if (received_packet_manager_.GenerateCongestionFeedback(
-          &outgoing_congestion_feedback_)) {
-    DVLOG(1) << ENDPOINT << "Sending feedback: "
-             << outgoing_congestion_feedback_;
-    send_feedback = true;
+
+  // Deprecating the Congestion Feedback Frame after QUIC_VERSION_22.
+  if (version() <= QUIC_VERSION_22) {
+    if (received_packet_manager_.GenerateCongestionFeedback(
+            &outgoing_congestion_feedback_)) {
+      DVLOG(1) << ENDPOINT << "Sending feedback: "
+               << outgoing_congestion_feedback_;
+      send_feedback = true;
+    }
   }
 
   packet_generator_.SetShouldSendAck(send_feedback, true);

net/quic/quic_connection_logger.cc

@@ -122,19 +122,6 @@ base::Value* NetLogQuicCongestionFeedbackFrameCallback(
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   switch (frame->type) {
-    case kTimestamp: {
-      dict->SetString("type", "Timestamp");
-      base::ListValue* received = new base::ListValue();
-      dict->Set("received_packets", received);
-      for (TimeMap::const_iterator it =
-               frame->timestamp.received_packet_times.begin();
-           it != frame->timestamp.received_packet_times.end(); ++it) {
-        string value = base::Uint64ToString(it->first) + "@" +
-            base::Uint64ToString(it->second.ToDebuggingValue());
-        received->AppendString(value);
-      }
-      break;
-    }
     case kTCP:
       dict->SetString("type", "TCP");
       dict->SetInteger("receive_window", frame->tcp.receive_window);

net/quic/quic_connection_test.cc

@@ -2568,11 +2568,20 @@ TEST_P(QuicConnectionTest, WithQuicCongestionFeedbackFrame) {
   QuicCongestionFeedbackFrame info;
   info.type = kTCP;
   info.tcp.receive_window = 0x4030;
-  SetFeedback(&info);
 
-  SendAckPacketToPeer();
-  ASSERT_FALSE(writer_->feedback_frames().empty());
-  ASSERT_EQ(kTCP, writer_->feedback_frames()[0].type);
+  // After QUIC_VERSION_22, do not send TCP Congestion Feedback Frames anymore.
+  if (version() > QUIC_VERSION_22) {
+    SendAckPacketToPeer();
+    ASSERT_TRUE(writer_->feedback_frames().empty());
+  } else {
+    // Only SetFeedback in this case because SetFeedback will create a receive
+    // algorithm which is how the received_packet_manager checks if it should be
+    // creating TCP Congestion Feedback Frames.
+    SetFeedback(&info);
+    SendAckPacketToPeer();
+    ASSERT_FALSE(writer_->feedback_frames().empty());
+    ASSERT_EQ(kTCP, writer_->feedback_frames()[0].type);
+  }
 }
 
 TEST_P(QuicConnectionTest, UpdateQuicCongestionFeedbackFrame) {

net/quic/quic_framer.h

@@ -45,6 +45,8 @@ const size_t kQuicEntropyHashSize = 1;
 // Size in bytes reserved for the delta time of the largest observed
 // sequence number in ack frames.
 const size_t kQuicDeltaTimeLargestObservedSize = 2;
+// Size in bytes reserved for the number of received packets with timestamps.
+const size_t kQuicNumTimestampsSize = 1;
 // Size in bytes reserved for the number of missing packets in ack frames.
 const size_t kNumberOfNackRangesSize = 1;
 // Maximum number of missing packet ranges that can fit within an ack frame.
@@ -409,9 +411,10 @@ class NET_EXPORT_PRIVATE QuicFramer {
   bool ProcessFrameData(const QuicPacketHeader& header);
   bool ProcessStreamFrame(uint8 frame_type, QuicStreamFrame* frame);
   bool ProcessAckFrame(uint8 frame_type, QuicAckFrame* frame);
+  bool ProcessTimestampsInAckFrame(QuicAckFrame* frame);
   bool ProcessStopWaitingFrame(const QuicPacketHeader& public_header,
                                QuicStopWaitingFrame* stop_waiting);
-  bool ProcessQuicCongestionFeedbackFrame(
+  bool ProcessCongestionFeedbackFrame(
       QuicCongestionFeedbackFrame* congestion_feedback);
   bool ProcessRstStreamFrame(QuicRstStreamFrame* frame);
   bool ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame);
@@ -428,6 +431,10 @@ class NET_EXPORT_PRIVATE QuicFramer {
       QuicSequenceNumberLength sequence_number_length,
       QuicPacketSequenceNumber packet_sequence_number) const;
 
+  // Returns the QuicTime::Delta corresponding to the time from when the framer
+  // was created.
+  const QuicTime::Delta CalculateTimestampFromWire(uint32 time_delta_us);
+
   // Computes the wire size in bytes of the |ack| frame, assuming no truncation.
   size_t GetAckFrameSize(const QuicAckFrame& ack,
                          QuicSequenceNumberLength sequence_number_length);
@@ -463,6 +470,8 @@ class NET_EXPORT_PRIVATE QuicFramer {
                                  QuicDataWriter* builder);
   bool AppendCongestionFeedbackFrame(const QuicCongestionFeedbackFrame& frame,
                                      QuicDataWriter* builder);
+  bool AppendTimestampToAckFrame(const QuicAckFrame& frame,
+                                 QuicDataWriter* builder);
   bool AppendStopWaitingFrame(const QuicPacketHeader& header,
                               const QuicStopWaitingFrame& frame,
                               QuicDataWriter* builder);
@@ -527,6 +536,9 @@ class NET_EXPORT_PRIVATE QuicFramer {
   // The time this framer was created.  Time written to the wire will be
   // written as a delta from this value.
   QuicTime creation_time_;
+  // The time delta computed for the last timestamp frame. This is relative to
+  // the creation_time.
+  QuicTime::Delta last_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };

net/quic/quic_http_stream_test.cc

@@ -150,12 +150,13 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
         read_buffer_(new IOBufferWithSize(4096)),
         connection_id_(2),
         stream_id_(kClientDataStreamId1),
-        maker_(GetParam(), connection_id_),
+        maker_(GetParam(), connection_id_, &clock_),
         random_generator_(0) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
     peer_addr_ = IPEndPoint(ip, 443);
     self_addr_ = IPEndPoint(ip, 8435);
+    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
   }
 
   ~QuicHttpStreamTest() {
@@ -243,7 +244,6 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
     stream_.reset(use_closing_stream_ ?
                   new AutoClosingStream(session_->GetWeakPtr()) :
                   new QuicHttpStream(session_->GetWeakPtr()));
-    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
   }
 
   void SetRequest(const std::string& method,

net/quic/quic_network_transaction_unittest.cc

@@ -107,8 +107,8 @@ class QuicNetworkTransactionTest
       public ::testing::WithParamInterface<QuicVersion> {
  protected:
   QuicNetworkTransactionTest()
-      : maker_(GetParam(), 0),
-        clock_(new MockClock),
+      : clock_(new MockClock),
+        maker_(GetParam(), 0, clock_),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
@@ -304,11 +304,11 @@ class QuicNetworkTransactionTest
     socket_factory_.AddSocketDataProvider(&hanging_data_);
   }
 
+  MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   QuicTestPacketMaker maker_;
   scoped_refptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
-  MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;

net/quic/quic_packet_creator.cc

@@ -379,19 +379,20 @@ SerializedPacket QuicPacketCreator::SerializePacket() {
   size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(max_packet_length_);
   DCHECK_GE(max_plaintext_size, packet_size_);
-  // ACK Frames will be truncated only if they're the only frame in the packet,
-  // and if packet_size_ was set to max_plaintext_size. If truncation occurred,
-  // then GetSerializedFrameLength will have returned all bytes free.
-  bool possibly_truncated = packet_size_ == max_plaintext_size &&
-                            queued_frames_.size() == 1 &&
-                            queued_frames_.back().type == ACK_FRAME;
+  // ACK Frames will be truncated due to length only if they're the only frame
+  // in the packet, and if packet_size_ was set to max_plaintext_size. If
+  // truncation due to length occurred, then GetSerializedFrameLength will have
+  // returned all bytes free.
+  bool possibly_truncated_by_length = packet_size_ == max_plaintext_size &&
+      queued_frames_.size() == 1 &&
+      queued_frames_.back().type == ACK_FRAME;
   SerializedPacket serialized =
       framer_->BuildDataPacket(header, queued_frames_, packet_size_);
   LOG_IF(DFATAL, !serialized.packet)
       << "Failed to serialize " << queued_frames_.size() << " frames.";
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
-  if (!possibly_truncated) {
+  if (!possibly_truncated_by_length) {
     DCHECK_EQ(packet_size_, serialized.packet->length());
   }
   packet_size_ = 0;

net/quic/quic_protocol.cc

@@ -171,6 +171,8 @@ QuicTag QuicVersionToQuicTag(const QuicVersion version) {
       return MakeQuicTag('Q', '0', '2', '1');
     case QUIC_VERSION_22:
       return MakeQuicTag('Q', '0', '2', '2');
+    case QUIC_VERSION_23:
+      return MakeQuicTag('Q', '0', '2', '3');
     default:
       // This shold be an ERROR because we should never attempt to convert an
       // invalid QuicVersion to be written to the wire.
@@ -203,6 +205,7 @@ string QuicVersionToString(const QuicVersion version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_20);
     RETURN_STRING_LITERAL(QUIC_VERSION_21);
     RETURN_STRING_LITERAL(QUIC_VERSION_22);
+    RETURN_STRING_LITERAL(QUIC_VERSION_23);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
@@ -274,11 +277,6 @@ CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
     : receive_window(0) {
 }
 
-CongestionFeedbackMessageTimestamp::CongestionFeedbackMessageTimestamp() {
-}
-
-CongestionFeedbackMessageTimestamp::~CongestionFeedbackMessageTimestamp() {}
-
 QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() : type(kTCP) {}
 
 QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() {}
@@ -383,7 +381,6 @@ ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
 
 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
   os << "entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
-     << " is_truncated: " << ack_frame.is_truncated
      << " largest_observed: " << ack_frame.largest_observed
      << " delta_time_largest_observed: "
      << ack_frame.delta_time_largest_observed.ToMicroseconds()
@@ -392,11 +389,18 @@ ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
        it != ack_frame.missing_packets.end(); ++it) {
     os << *it << " ";
   }
-  os << " ] revived_packets: [ ";
+  os << " ] is_truncated: " << ack_frame.is_truncated;
+  os << " revived_packets: [ ";
   for (SequenceNumberSet::const_iterator it = ack_frame.revived_packets.begin();
        it != ack_frame.revived_packets.end(); ++it) {
     os << *it << " ";
   }
+  os << " ] received_packets: [ ";
+  for (PacketTimeList::const_iterator it =
+           ack_frame.received_packet_times.begin();
+           it != ack_frame.received_packet_times.end(); ++it) {
+    os << it->first << " at " << it->second.ToDebuggingValue() << " ";
+  }
   os << " ]";
   return os;
 }
@@ -504,17 +508,6 @@ ostream& operator<<(ostream& os,
                     const QuicCongestionFeedbackFrame& congestion_frame) {
   os << "type: " << congestion_frame.type;
   switch (congestion_frame.type) {
-    case kTimestamp: {
-      const CongestionFeedbackMessageTimestamp& timestamp =
-          congestion_frame.timestamp;
-      os << " received packets: [ ";
-      for (TimeMap::const_iterator it = timestamp.received_packet_times.begin();
-           it != timestamp.received_packet_times.end(); ++it) {
-        os << it->first << "@" << it->second.ToDebuggingValue() << " ";
-      }
-      os << "]";
-      break;
-    }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
       os << " receive_window: " << tcp.receive_window;

net/quic/quic_protocol.h

@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 #include <limits>
+#include <list>
 #include <map>
 #include <ostream>
 #include <set>
@@ -291,6 +292,7 @@ enum QuicVersion {
   QUIC_VERSION_20 = 20,  // Independent stream/connection flow control windows.
   QUIC_VERSION_21 = 21,  // Headers/crypto streams are flow controlled.
   QUIC_VERSION_22 = 22,  // Send Server Config Update messages on crypto stream.
+  QUIC_VERSION_23 = 23,  // Timestamp in the ack frame.
 };
 
 // This vector contains QUIC versions which we currently support.
@@ -300,7 +302,8 @@ enum QuicVersion {
 //
 // IMPORTANT: if you are adding to this list, follow the instructions at
 // http://sites/quic/adding-and-removing-versions
-static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_22,
+static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_23,
+                                                     QUIC_VERSION_22,
                                                      QUIC_VERSION_21,
                                                      QUIC_VERSION_20,
                                                      QUIC_VERSION_19,
@@ -644,8 +647,8 @@ struct NET_EXPORT_PRIVATE QuicStreamFrame {
 // TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing
 // is finalized.
 typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet;
-// TODO(pwestin): Add a way to enforce the max size of this map.
-typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap;
+
+typedef std::list<std::pair<QuicPacketSequenceNumber, QuicTime>> PacketTimeList;
 
 struct NET_EXPORT_PRIVATE QuicStopWaitingFrame {
   QuicStopWaitingFrame();
@@ -696,6 +699,9 @@ struct NET_EXPORT_PRIVATE QuicAckFrame {
   // Packets which have been revived via FEC.
   // All of these must also be in missing_packets.
   SequenceNumberSet revived_packets;
+
+  // List of <sequence_number, time> for when packets arrived.
+  PacketTimeList received_packet_times;
 };
 
 // True if the sequence number is greater than largest_observed or is listed
@@ -714,9 +720,9 @@ void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
 // kTCP MUST be supported by all QUIC implementations to guarantee 100%
 // compatibility.
+// TODO(cyr): Remove this when removing QUIC_VERSION_22.
 enum CongestionFeedbackType {
   kTCP,  // Used to mimic TCP.
-  kTimestamp,  // Use additional inter arrival timestamp information.
 };
 
 // Defines for all types of congestion control algorithms that can be used in
@@ -734,21 +740,14 @@ enum LossDetectionType {
   kTime,  // Time based loss detection.
 };
 
+// TODO(cyr): Remove this when removing QUIC_VERSION_22.
 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP {
   CongestionFeedbackMessageTCP();
 
   QuicByteCount receive_window;
 };
 
-struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTimestamp {
-  CongestionFeedbackMessageTimestamp();
-  ~CongestionFeedbackMessageTimestamp();
-
-  // The set of received packets since the last feedback was sent, along with
-  // their arrival times.
-  TimeMap received_packet_times;
-};
-
+// TODO(cyr): Remove this when removing QUIC_VERSION_22.
 struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame {
   QuicCongestionFeedbackFrame();
   ~QuicCongestionFeedbackFrame();
@@ -760,7 +759,6 @@ struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame {
   // This should really be a union, but since the timestamp struct
   // is non-trivial, C++ prohibits it.
   CongestionFeedbackMessageTCP tcp;
-  CongestionFeedbackMessageTimestamp timestamp;
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
@@ -861,7 +859,10 @@ struct NET_EXPORT_PRIVATE QuicFrame {
   explicit QuicFrame(QuicPaddingFrame* padding_frame);
   explicit QuicFrame(QuicStreamFrame* stream_frame);
   explicit QuicFrame(QuicAckFrame* frame);
+
+  // TODO(cyr): Remove this when removing QUIC_VERSION_22.
   explicit QuicFrame(QuicCongestionFeedbackFrame* frame);
+
   explicit QuicFrame(QuicRstStreamFrame* frame);
   explicit QuicFrame(QuicConnectionCloseFrame* frame);
   explicit QuicFrame(QuicStopWaitingFrame* frame);
@@ -878,8 +879,11 @@ struct NET_EXPORT_PRIVATE QuicFrame {
     QuicPaddingFrame* padding_frame;
     QuicStreamFrame* stream_frame;
     QuicAckFrame* ack_frame;
+
+    // TODO(cyr): Remove this when removing QUIC_VERSION_22.
     QuicCongestionFeedbackFrame* congestion_feedback_frame;
     QuicStopWaitingFrame* stop_waiting_frame;
+
     QuicPingFrame* ping_frame;
     QuicRstStreamFrame* rst_stream_frame;
     QuicConnectionCloseFrame* connection_close_frame;

net/quic/quic_received_packet_manager.cc

@@ -7,11 +7,13 @@
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/linked_hash_map.h"
+#include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_connection_stats.h"
 
 using std::make_pair;
 using std::max;
 using std::min;
+using std::numeric_limits;
 
 namespace net {
 
@@ -128,11 +130,10 @@ AdvanceFirstGapAndGarbageCollectEntropyMap() {
 }
 
 QuicReceivedPacketManager::QuicReceivedPacketManager(
-    CongestionFeedbackType congestion_type,
     QuicConnectionStats* stats)
     : peer_least_packet_awaiting_ack_(0),
       time_largest_observed_(QuicTime::Zero()),
-      receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)),
+      receive_algorithm_(ReceiveAlgorithmInterface::Create(kTCP)),
       stats_(stats) {
   ack_frame_.largest_observed = 0;
   ack_frame_.entropy_hash = 0;
@@ -178,6 +179,9 @@ void QuicReceivedPacketManager::RecordPacketReceived(
   receive_algorithm_->RecordIncomingPacket(
       bytes, sequence_number, receipt_time);
 
+  received_packet_times_.push_back(
+      std::make_pair(sequence_number, receipt_time));
+
   ack_frame_.revived_packets.erase(sequence_number);
 }
 
@@ -216,6 +220,15 @@ void QuicReceivedPacketManager::UpdateReceivedPacketInfo(
 
   ack_frame->delta_time_largest_observed =
       approximate_now.Subtract(time_largest_observed_);
+
+  // Remove all packets that are too far from largest_observed to express.
+  received_packet_times_.remove_if(
+      [this] (std::pair<QuicPacketSequenceNumber, QuicTime> p)
+      { return ack_frame_.largest_observed - p.first >=
+        numeric_limits<uint8>::max();});
+
+  ack_frame->received_packet_times = received_packet_times_;
+  received_packet_times_.clear();
 }
 
 bool QuicReceivedPacketManager::GenerateCongestionFeedback(

net/quic/quic_received_packet_manager.h

@@ -11,6 +11,7 @@
 #include <deque>
 
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
+#include "net/quic/quic_config.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 
@@ -94,8 +95,7 @@ class NET_EXPORT_PRIVATE QuicReceivedPacketManager :
     DISALLOW_COPY_AND_ASSIGN(EntropyTracker);
   };
 
-  explicit QuicReceivedPacketManager(CongestionFeedbackType congestion_type,
-                                     QuicConnectionStats* stats);
+  explicit QuicReceivedPacketManager(QuicConnectionStats* stats);
   virtual ~QuicReceivedPacketManager();
 
   // Updates the internal state concerning which packets have been received.
@@ -172,6 +172,8 @@ class NET_EXPORT_PRIVATE QuicReceivedPacketManager :
 
   QuicConnectionStats* stats_;
 
+  PacketTimeList received_packet_times_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicReceivedPacketManager);
 };
 

net/quic/quic_received_packet_manager_test.cc

@@ -188,7 +188,7 @@ TEST(EntropyTrackerTest, SetCumulativeEntropyUpTo) {
 
 class QuicReceivedPacketManagerTest : public ::testing::Test {
  protected:
-  QuicReceivedPacketManagerTest() : received_manager_(kTCP, &stats_) {}
+  QuicReceivedPacketManagerTest() : received_manager_(&stats_) {}
 
   void RecordPacketReceipt(QuicPacketSequenceNumber sequence_number,
                            QuicPacketEntropyHash entropy_hash) {

net/quic/quic_stream_factory_test.cc

@@ -90,8 +90,8 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicStreamFactoryTest()
       : random_generator_(0),
-        maker_(GetParam(), 0),
         clock_(new MockClock()),
+        maker_(GetParam(), 0, clock_),
         cert_verifier_(CertVerifier::CreateDefault()),
         channel_id_service_(new ChannelIDService(
             new DefaultChannelIDStore(NULL),
@@ -187,8 +187,8 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
   DeterministicMockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
-  QuicTestPacketMaker maker_;
   MockClock* clock_;  // Owned by factory_.
+  QuicTestPacketMaker maker_;
   scoped_ptr<CertVerifier> cert_verifier_;
   scoped_ptr<ChannelIDService> channel_id_service_;
   TransportSecurityState transport_security_state_;

net/quic/test_tools/mock_crypto_client_stream.cc

@@ -81,7 +81,10 @@ void MockCryptoClientStream::SendOnCryptoHandshakeEvent(
 void MockCryptoClientStream::SetConfigNegotiated() {
   ASSERT_FALSE(session()->config()->negotiated());
   QuicTagVector cgst;
-  cgst.push_back(kTSTP);
+  // TODO(rtenneti): Enable the following code after BBR code is checked in.
+#if 0
+  cgst.push_back(kTBBR);
+#endif
   cgst.push_back(kQBIC);
   session()->config()->set_congestion_feedback(cgst, kQBIC);
   session()->config()->set_idle_connection_state_lifetime(

net/quic/test_tools/quic_test_packet_maker.cc

@@ -4,18 +4,24 @@
 
 #include "net/quic/test_tools/quic_test_packet_maker.h"
 
+#include <list>
+
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
+using std::make_pair;
+
 namespace net {
 namespace test {
 
 QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version,
-                                         QuicConnectionId connection_id)
+                                         QuicConnectionId connection_id,
+                                         MockClock* clock)
     : version_(version),
       connection_id_(connection_id),
+      clock_(clock),
       spdy_request_framer_(SPDY3),
       spdy_response_framer_(SPDY3) {
 }
@@ -63,10 +69,16 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.delta_time_largest_observed = QuicTime::Delta::Zero();
+  if (version_ > QUIC_VERSION_22) {
+    for (QuicPacketSequenceNumber i = least_unacked; i <= largest_received;
+         ++i) {
+      ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
+    }
+  }
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack));
   QuicCongestionFeedbackFrame feedback;
-  if (send_feedback) {
+  if (send_feedback && version_ <= QUIC_VERSION_22) {
     feedback.type = kTCP;
     feedback.tcp.receive_window = 256000;
 
@@ -80,7 +92,7 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
   QuicRstStreamFrame rst(stream_id, error_code, 0);
   frames.push_back(QuicFrame(&rst));
 
-  QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(), false);
+  QuicFramer framer(SupportedVersions(version_), clock_->Now(), false);
   scoped_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames).packet);
   return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(
@@ -122,15 +134,20 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket(
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.delta_time_largest_observed = QuicTime::Delta::Zero();
+  if (version_ > QUIC_VERSION_22) {
+    for (QuicPacketSequenceNumber i = least_unacked; i <= largest_received;
+         ++i) {
+      ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
+    }
+  }
 
-  QuicCongestionFeedbackFrame feedback;
-  feedback.type = kTCP;
-  feedback.tcp.receive_window = 256000;
-
-  QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(), false);
+  QuicFramer framer(SupportedVersions(version_), clock_->Now(), false);
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack));
-  if (send_feedback) {
+  QuicCongestionFeedbackFrame feedback;
+  if (send_feedback && version_ <= QUIC_VERSION_22) {
+    feedback.type = kTCP;
+    feedback.tcp.receive_window = 256000;
     frames.push_back(QuicFrame(&feedback));
   }
 

net/quic/test_tools/quic_test_packet_maker.h

@@ -10,6 +10,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "net/base/request_priority.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
@@ -19,7 +20,9 @@ namespace test {
 
 class QuicTestPacketMaker {
  public:
-  QuicTestPacketMaker(QuicVersion version, QuicConnectionId connection_id);
+  QuicTestPacketMaker(QuicVersion version,
+                      QuicConnectionId connection_id,
+                      MockClock* clock);
   ~QuicTestPacketMaker();
 
   scoped_ptr<QuicEncryptedPacket> MakeRstPacket(
@@ -77,6 +80,7 @@ class QuicTestPacketMaker {
 
   QuicVersion version_;
   QuicConnectionId connection_id_;
+  MockClock* clock_;  // Owned by QuicStreamFactory.
   SpdyFramer spdy_request_framer_;
   SpdyFramer spdy_response_framer_;
   MockRandom random_generator_;