Remove FEC code from receive path.

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>
@@ skipping 13 matching lines @@
 #include "net/base/address_family.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_bandwidth.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_config.h"
-#include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_packet_generator.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using base::StringPrintf;
 using base::hash_map;
 using base::hash_set;
 using std::list;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::numeric_limits;
 using std::set;
 using std::string;
 using std::vector;
 
 namespace net {
 
 class QuicDecrypter;
 class QuicEncrypter;
 
 namespace {
 
 // The largest gap in packets we'll accept without closing the connection.
 // This will likely have to be tuned.
 const QuicPacketNumber kMaxPacketGap = 5000;
 
-// Limit the number of FEC groups to two.  If we get enough out of order packets
-// that this becomes limiting, we can revisit.
-const size_t kMaxFecGroups = 2;
-
 // Maximum number of acks received before sending an ack in response.
 const QuicPacketCount kMaxPacketsReceivedBeforeAckSend = 20;
 
 // Maximum number of retransmittable packets received before sending an ack.
 const QuicPacketCount kDefaultRetransmittablePacketsBeforeAck = 2;
 // Minimum number of packets received before ack decimation is enabled.
 // This intends to avoid the beginning of slow start, when CWNDs may be
 // rapidly increasing.
 const QuicPacketCount kMinReceivedBeforeAckDecimation = 100;
 // Wait for up to 10 retransmittable packets before sending an ack.
@@ skipping 164 matching lines @@
       owns_writer_(owns_writer),
       encryption_level_(ENCRYPTION_NONE),
       has_forward_secure_encrypter_(false),
       first_required_forward_secure_packet_(0),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       connection_id_(connection_id),
       peer_address_(address),
       migrating_peer_port_(0),
       last_packet_decrypted_(false),
-      last_packet_revived_(false),
       last_size_(0),
       last_decrypted_packet_level_(ENCRYPTION_NONE),
       should_last_packet_instigate_acks_(false),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       save_crypto_packets_as_termination_packets_(false),
       silent_close_enabled_(false),
       received_packet_manager_(&stats_),
@@ skipping 70 matching lines @@
 }
 
 QuicConnection::~QuicConnection() {
   if (owns_writer_) {
     delete writer_;
   }
   STLDeleteElements(&undecryptable_packets_);
   if (termination_packets_.get() != nullptr) {
     STLDeleteElements(termination_packets_.get());
   }
-  STLDeleteValues(&group_map_);
   ClearQueuedPackets();
 }
 
 void QuicConnection::ClearQueuedPackets() {
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     // Delete the buffer before calling ClearSerializedPacket, which sets
     // encrypted_buffer to nullptr.
     delete[] it->encrypted_buffer;
     QuicUtils::ClearSerializedPacket(&(*it));
@@ skipping 89 matching lines @@
   // Packets that we can not or have not decrypted are dropped.
   // TODO(rch): add stats to measure this.
   if (!connected_ || last_packet_decrypted_ == false) {
     return;
   }
   SendConnectionCloseWithDetails(framer->error(), framer->detailed_error());
 }
 
 void QuicConnection::OnPacket() {
   last_packet_decrypted_ = false;
-  last_packet_revived_ = false;
 }
 
 void QuicConnection::OnPublicResetPacket(const QuicPublicResetPacket& packet) {
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.  (Check for a bug regression.)
   DCHECK_EQ(connection_id_, packet.public_header.connection_id);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
@@ skipping 97 matching lines @@
     return;
   }
 
   DVLOG(1) << ENDPOINT
            << "Negotiated version: " << QuicVersionToString(version());
   server_supported_versions_ = packet.versions;
   version_negotiation_state_ = NEGOTIATION_IN_PROGRESS;
   RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
 }
 
-void QuicConnection::OnRevivedPacket() {}
-
 bool QuicConnection::OnUnauthenticatedPublicHeader(
     const QuicPacketPublicHeader& header) {
   if (header.connection_id == connection_id_) {
     return true;
   }
 
   ++stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Ignoring packet from unexpected ConnectionId: "
            << header.connection_id << " instead of " << connection_id_;
   if (debug_visitor_ != nullptr) {
@@ skipping 66 matching lines @@
 
   MaybeMigrateConnectionToNewPeerAddress();
 
   --stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Received packet header: " << header;
   last_header_ = header;
   DCHECK(connected_);
   return true;
 }
 
-void QuicConnection::OnFecProtectedPayload(StringPiece payload) {
-  DCHECK_EQ(IN_FEC_GROUP, last_header_.is_in_fec_group);
-  DCHECK_NE(0u, last_header_.fec_group);
-  QuicFecGroup* group = GetFecGroup();
-  if (group != nullptr) {
-    group->Update(last_decrypted_packet_level_, last_header_, payload);
-  }
-}
-
 bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnStreamFrame(frame);
   }
   if (frame.stream_id != kCryptoStreamId &&
       last_decrypted_packet_level_ == ENCRYPTION_NONE) {
     QUIC_BUG << ENDPOINT
              << "Received an unencrypted data frame: closing connection"
              << " packet_number:" << last_header_.packet_number
@@ skipping 55 matching lines @@
 
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
   SetRetransmissionAlarm();
 }
 
 void QuicConnection::ProcessStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   largest_seen_packet_with_stop_waiting_ = last_header_.packet_number;
   received_packet_manager_.UpdatePacketInformationSentByPeer(stop_waiting);
-  // Possibly close any FecGroups which are now irrelevant.
-  CloseFecGroupsBefore(stop_waiting.least_unacked + 1);
 }
 
 bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
   DCHECK(connected_);
 
   if (last_header_.packet_number <= largest_seen_packet_with_stop_waiting_) {
     DVLOG(1) << ENDPOINT << "Received an old stop waiting frame: ignoring";
     return true;
   }
 
@@ skipping 59 matching lines @@
 
   if (!sent_entropy_manager_.IsValidEntropy(incoming_ack.largest_observed,
                                             incoming_ack.missing_packets,
                                             incoming_ack.entropy_hash)) {
     LOG(WARNING) << ENDPOINT << "Peer sent invalid entropy."
                  << " largest_observed:" << incoming_ack.largest_observed
                  << " last_received:" << last_header_.packet_number;
     return "Invalid entropy";
   }
 
-  if (incoming_ack.latest_revived_packet != 0 &&
-      !incoming_ack.missing_packets.Contains(
-          incoming_ack.latest_revived_packet)) {
-    LOG(WARNING) << ENDPOINT
-                 << "Peer specified revived packet which was not missing."
-                 << " revived_packet:" << incoming_ack.latest_revived_packet;
-    return "Invalid revived packet";
-  }
   return nullptr;
 }
 
 const char* QuicConnection::ValidateStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   if (stop_waiting.least_unacked <
       received_packet_manager_.peer_least_packet_awaiting_ack()) {
     DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
                 << stop_waiting.least_unacked << " vs "
                 << received_packet_manager_.peer_least_packet_awaiting_ack();
     // We never process old ack frames, so this number should only increase.
     return "Least unacked too small";
   }
 
   if (stop_waiting.least_unacked > last_header_.packet_number) {
     DLOG(ERROR) << ENDPOINT
                 << "Peer sent least_unacked:" << stop_waiting.least_unacked
                 << " greater than the enclosing packet number:"
                 << last_header_.packet_number;
     return "Least unacked too large";
   }
 
   return nullptr;
 }
 
-void QuicConnection::OnFecData(StringPiece redundancy) {
-  DCHECK_EQ(IN_FEC_GROUP, last_header_.is_in_fec_group);
-  DCHECK_NE(0u, last_header_.fec_group);
-  QuicFecGroup* group = GetFecGroup();
-  if (group != nullptr) {
-    group->UpdateFec(last_decrypted_packet_level_, last_header_, redundancy);
-  }
-}
-
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DVLOG(1) << ENDPOINT
            << "RST_STREAM_FRAME received for stream: " << frame.stream_id
            << " with error: "
            << QuicUtils::StreamErrorToString(frame.error_code);
   visitor_->OnRstStream(frame);
@@ skipping 71 matching lines @@
   return connected_;
 }
 
 void QuicConnection::OnPacketComplete() {
   // Don't do anything if this packet closed the connection.
   if (!connected_) {
     ClearLastFrames();
     return;
   }
 
-  DVLOG(1) << ENDPOINT << (last_packet_revived_ ? "Revived" : "Got")
-           << " packet " << last_header_.packet_number << " for "
+  DVLOG(1) << ENDPOINT << "Got packet " << last_header_.packet_number << " for "
            << last_header_.public_header.connection_id;
 
   // An ack will be sent if a missing retransmittable packet was received;
   const bool was_missing =
       should_last_packet_instigate_acks_ &&
       received_packet_manager_.IsMissing(last_header_.packet_number);
 
-  // Record received or revived packet to populate ack info correctly before
-  // processing stream frames, since the processing may result in a response
-  // packet with a bundled ack.
-  if (last_packet_revived_) {
-    received_packet_manager_.RecordPacketRevived(last_header_.packet_number);
-  } else {
-    received_packet_manager_.RecordPacketReceived(
-        last_size_, last_header_, time_of_last_received_packet_);
-  }
+  // Record received to populate ack info correctly before processing stream
+  // frames, since the processing may result in a response packet with a bundled
+  // ack.
+  received_packet_manager_.RecordPacketReceived(last_size_, last_header_,
+                                                time_of_last_received_packet_);
 
   // Process stop waiting frames here, instead of inline, because the packet
   // needs to be considered 'received' before the entropy can be updated.
   if (last_stop_waiting_frame_.least_unacked > 0) {
     ProcessStopWaitingFrame(last_stop_waiting_frame_);
     if (!connected_) {
       return;
     }
   }
 
   MaybeQueueAck(was_missing);
 
   ClearLastFrames();
   MaybeCloseIfTooManyOutstandingPackets();
-  MaybeProcessRevivedPacket();
 }
 
 void QuicConnection::MaybeQueueAck(bool was_missing) {
   ++num_packets_received_since_last_ack_sent_;
   // Always send an ack every 20 packets in order to allow the peer to discard
   // information from the SentPacketManager and provide an RTT measurement.
   if (num_packets_received_since_last_ack_sent_ >=
       kMaxPacketsReceivedBeforeAckSend) {
     ack_queued_ = true;
   }
@@ skipping 364 matching lines @@
 }
 
 void QuicConnection::WriteAndBundleAcksIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     ScopedPacketBundler bundler(this, ack_queued_ ? SEND_ACK : NO_ACK);
     OnCanWrite();
   }
 }
 
 bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) {
+  if (header.fec_flag) {
+    // Drop any FEC packet.
+    return false;
+  }
+
   if (FLAGS_check_peer_address_change_after_decryption) {
     if (perspective_ == Perspective::IS_SERVER &&
         IsInitializedIPEndPoint(self_address_) &&
         IsInitializedIPEndPoint(last_packet_destination_address_) &&
         (!(self_address_ == last_packet_destination_address_))) {
       SendConnectionCloseWithDetails(
           QUIC_ERROR_MIGRATING_ADDRESS,
           "Self address migration is not supported at the server.");
       return false;
     }
@@ skipping 549 matching lines @@
       // undecryptable packets as the argument to OnUndecryptablePacket so that
       // we just need to call OnUndecryptablePacket once?
       for (size_t i = 0; i < undecryptable_packets_.size(); ++i) {
         debug_visitor_->OnUndecryptablePacket();
       }
     }
     STLDeleteElements(&undecryptable_packets_);
   }
 }
 
-void QuicConnection::MaybeProcessRevivedPacket() {
-  QuicFecGroup* group = GetFecGroup();
-  if (!connected_ || group == nullptr || !group->CanRevive()) {
-    return;
-  }
-  QuicPacketHeader revived_header;
-  char revived_payload[kMaxPacketSize];
-  size_t len = group->Revive(&revived_header, revived_payload, kMaxPacketSize);
-  if (!received_packet_manager_.IsAwaitingPacket(
-          revived_header.packet_number)) {
-    // Close this FEC group because all packets in the group has been received.
-    group_map_.erase(last_header_.fec_group);
-    delete group;
-    return;
-  }
-  revived_header.public_header.connection_id = connection_id_;
-  revived_header.public_header.connection_id_length =
-      last_header_.public_header.connection_id_length;
-  revived_header.public_header.version_flag = false;
-  revived_header.public_header.reset_flag = false;
-  revived_header.public_header.packet_number_length =
-      last_header_.public_header.packet_number_length;
-  revived_header.fec_flag = false;
-  revived_header.is_in_fec_group = NOT_IN_FEC_GROUP;
-  revived_header.fec_group = 0;
-  group_map_.erase(last_header_.fec_group);
-  last_decrypted_packet_level_ = group->EffectiveEncryptionLevel();
-  DCHECK_LT(last_decrypted_packet_level_, NUM_ENCRYPTION_LEVELS);
-  delete group;
-
-  last_packet_revived_ = true;
-  if (debug_visitor_ != nullptr) {
-    debug_visitor_->OnRevivedPacket(revived_header,
-                                    StringPiece(revived_payload, len));
-  }
-
-  ++stats_.packets_revived;
-  framer_.ProcessRevivedPacket(&revived_header,
-                               StringPiece(revived_payload, len));
-}
-
-QuicFecGroup* QuicConnection::GetFecGroup() {
-  QuicFecGroupNumber fec_group_num = last_header_.fec_group;
-  if (fec_group_num == 0 ||
-      (fec_group_num <
-           received_packet_manager_.peer_least_packet_awaiting_ack() &&
-       !ContainsKey(group_map_, fec_group_num))) {
-    // If the group number is below peer_least_packet_awaiting_ack and this
-    // group does not exist, which means this group has missing packets below
-    // |peer_least_packet_awaiting_ack| which we would never receive, so return
-    // nullptr.
-    return nullptr;
-  }
-  if (!ContainsKey(group_map_, fec_group_num)) {
-    if (group_map_.size() >= kMaxFecGroups) {  // Too many groups
-      if (fec_group_num < group_map_.begin()->first) {
-        // The group being requested is a group we've seen before and deleted.
-        // Don't recreate it.
-        return nullptr;
-      }
-      // Clear the lowest group number.
-      delete group_map_.begin()->second;
-      group_map_.erase(group_map_.begin());
-    }
-    group_map_[fec_group_num] = new QuicFecGroup(fec_group_num);
-  }
-  return group_map_[fec_group_num];
-}
-
 void QuicConnection::SendConnectionCloseWithDetails(QuicErrorCode error,
                                                     const string& details) {
   if (!connected_) {
     DVLOG(1) << "Connection is already closed.";
     return;
   }
   // If we're write blocked, WritePacket() will not send, but will capture the
   // serialized packet.
   SendConnectionClosePacket(error, details);
   CloseConnection(error, ConnectionCloseSource::FROM_SELF);
@@ skipping 53 matching lines @@
 
   DVLOG(1) << ENDPOINT << "Going away with error "
            << QuicUtils::ErrorToString(error) << " (" << error << ")";
 
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicGoAwayFrame(error, last_good_stream_id, reason)));
 }
 
-void QuicConnection::CloseFecGroupsBefore(QuicPacketNumber packet_number) {
-  FecGroupMap::iterator it = group_map_.begin();
-  while (it != group_map_.end()) {
-    // If the group doesn't protect this packet we can ignore it.
-    if (!it->second->IsWaitingForPacketBefore(packet_number)) {
-      ++it;
-      continue;
-    }
-    QuicFecGroup* fec_group = it->second;
-    DCHECK(!fec_group->CanRevive());
-    FecGroupMap::iterator next = it;
-    ++next;
-    group_map_.erase(it);
-    delete fec_group;
-    it = next;
-  }
-}
-
 QuicByteCount QuicConnection::max_packet_length() const {
   return packet_generator_.GetMaxPacketLength();
 }
 
 void QuicConnection::SetMaxPacketLength(QuicByteCount length) {
   return packet_generator_.SetMaxPacketLength(LimitMaxPacketSize(length),
                                               /*force=*/false);
 }
 
 bool QuicConnection::HasQueuedData() const {
@@ skipping 347 matching lines @@
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net