Land Recent QUIC Changes.

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 350 matching lines @@
 
 bool QuicConnection::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   return true;
 }
 
 bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) {
   if (debug_visitor_) {
     debug_visitor_->OnPacketHeader(header);
   }
 
+  if (header.fec_flag && framer_.version() <= QUIC_VERSION_14) {
+    DLOG(WARNING) << "Ignoring FEC packets for versions prior to 15.";
+    return false;
+  }
+
   if (!ProcessValidatedPacket()) {
     return false;
   }
 
   // Will be decrement below if we fall through to return true;
   ++stats_.packets_dropped;
 
   if (header.public_header.guid != guid_) {
     DVLOG(1) << ENDPOINT << "Ignoring packet from unexpected GUID: "
                << header.public_header.guid << " instead of " << guid_;
@@ skipping 85 matching lines @@
     return false;
   }
 
   last_ack_frames_.push_back(incoming_ack);
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
 
-  received_packet_manager_.UpdatePacketInformationReceivedByPeer(incoming_ack);
-  received_packet_manager_.UpdatePacketInformationSentByPeer(incoming_ack);
+  received_packet_manager_.UpdatePacketInformationReceivedByPeer(
+      incoming_ack.received_info);
+  received_packet_manager_.UpdatePacketInformationSentByPeer(
+      incoming_ack.sent_info);
   // Possibly close any FecGroups which are now irrelevant.
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
 
   sent_entropy_manager_.ClearEntropyBefore(
       received_packet_manager_.least_packet_awaited_by_peer() - 1);
 
   bool reset_retransmission_alarm =
       sent_packet_manager_.OnIncomingAck(incoming_ack.received_info,
                                          time_of_last_received_packet_);
   if (sent_packet_manager_.HasPendingRetransmissions()) {
@@ skipping 79 matching lines @@
   }
 
   if (!sent_entropy_manager_.IsValidEntropy(
           incoming_ack.received_info.largest_observed,
           incoming_ack.received_info.missing_packets,
           incoming_ack.received_info.entropy_hash)) {
     DLOG(ERROR) << ENDPOINT << "Peer sent invalid entropy.";
     return false;
   }
 
+  for (SequenceNumberSet::const_iterator iter =
+           incoming_ack.received_info.revived_packets.begin();
+       iter != incoming_ack.received_info.revived_packets.end(); ++iter) {
+    if (!ContainsKey(incoming_ack.received_info.missing_packets, *iter)) {
+      DLOG(ERROR) << ENDPOINT
+                  << "Peer specified revived packet which was not missing.";
+      return false;
+    }
+  }
   return true;
 }
 
 void QuicConnection::OnFecData(const QuicFecData& fec) {
   DCHECK_EQ(IN_FEC_GROUP, last_header_.is_in_fec_group);
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   if (group != NULL) {
-    group->UpdateFec(last_header_.packet_sequence_number,
-                     last_header_.entropy_flag, fec);
+    group->UpdateFec(last_header_.packet_sequence_number, fec);
   }
 }
 
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Stream reset with error "
              << QuicUtils::StreamErrorToString(frame.error_code);
@@ skipping 41 matching lines @@
              << " stream frames for " << last_header_.public_header.guid;
 
   MaybeQueueAck();
 
   // Discard the packet if the visitor fails to process the stream frames.
   if (!last_stream_frames_.empty() &&
       !visitor_->OnStreamFrames(last_stream_frames_)) {
     return;
   }
 
-  received_packet_manager_.RecordPacketReceived(last_size_,
-                                                last_header_,
-                                                time_of_last_received_packet_,
-                                                last_packet_revived_);
+  if (last_packet_revived_) {
+    received_packet_manager_.RecordPacketRevived(
+        last_header_.packet_sequence_number);
+  } else {
+    received_packet_manager_.RecordPacketReceived(
+        last_size_, last_header_, time_of_last_received_packet_);
+  }
   for (size_t i = 0; i < last_stream_frames_.size(); ++i) {
     stats_.stream_bytes_received +=
         last_stream_frames_[i].data.TotalBufferSize();
   }
 
   // Process stream resets, then acks, then congestion feedback.
   for (size_t i = 0; i < last_goaway_frames_.size(); ++i) {
     visitor_->OnGoAway(last_goaway_frames_[i]);
   }
   for (size_t i = 0; i < last_rst_frames_.size(); ++i) {
@@ skipping 1003 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net