Revert 204046 "Land Recent QUIC changes."

trunk/src/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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 107 matching lines @@
   */
 }
 
 QuicConnection::~QuicConnection() {
   STLDeleteValues(&unacked_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
-  DLOG(INFO) << ENDPOINT << "write_blocked: " << write_blocked_;
+  LOG(ERROR) << "Quic connection " << write_blocked_;
 }
 
 bool QuicConnection::SelectMutualVersion(
     const QuicTagVector& available_versions) {
   // TODO(satyamshekhar): Make this generic.
   if (std::find(available_versions.begin(), available_versions.end(),
                 kQuicVersion1) == available_versions.end()) {
     return false;
   }
 
@@ skipping 96 matching lines @@
     DLOG(WARNING) << ENDPOINT << "The server already supports our version. "
                   << "It should have accepted our connection.";
     // Just drop the connection.
     CloseConnection(QUIC_INVALID_VERSION_NEGOTIATION_PACKET, false);
     return;
   }
 
   if (!SelectMutualVersion(packet.versions)) {
     SendConnectionCloseWithDetails(QUIC_INVALID_VERSION,
                                    "no common version found");
-    return;
   }
 
   version_negotiation_state_ = NEGOTIATED_VERSION;
   RetransmitUnackedPackets(ALL_PACKETS);
 }
 
 void QuicConnection::OnRevivedPacket() {
 }
 
 bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) {
@@ skipping 99 matching lines @@
 
   received_truncated_ack_ =
       incoming_ack.received_info.missing_packets.size() >=
       QuicFramer::GetMaxUnackedPackets(last_header_);
 
   UpdatePacketInformationReceivedByPeer(incoming_ack);
   UpdatePacketInformationSentByPeer(incoming_ack);
   congestion_manager_.OnIncomingAckFrame(incoming_ack,
                                          time_of_last_received_packet_);
 
-  // Now the we have received an ack, we might be able to send packets which are
-  // queued locally, or drain streams which are blocked.
-  QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
-      time_of_last_received_packet_, NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA);
-  if (delay.IsZero()) {
-    helper_->UnregisterSendAlarmIfRegistered();
-    if (!write_blocked_) {
-      OnCanWrite();
+  // Now the we have received an ack, we might be able to send queued packets.
+  if (!queued_packets_.empty()) {
+    QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
+        time_of_last_received_packet_, NOT_RETRANSMISSION,
+        HAS_RETRANSMITTABLE_DATA);
+    if (delay.IsZero()) {
+      helper_->UnregisterSendAlarmIfRegistered();
+      if (!write_blocked_) {
+        OnCanWrite();
+      }
+    } else if (!delay.IsInfinite()) {
+      helper_->SetSendAlarm(time_of_last_received_packet_.Add(delay));
     }
-  } else if (!delay.IsInfinite()) {
-    helper_->SetSendAlarm(time_of_last_received_packet_.Add(delay));
   }
   return connected_;
 }
 
 bool QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnCongestionFeedbackFrame(feedback);
   }
@@ skipping 67 matching lines @@
           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;
   }
 
   return true;
 }
 
-void QuicConnection::HandleAckForSentPackets(const QuicAckFrame& incoming_ack,
-                                             SequenceNumberSet* acked_packets) {
+void QuicConnection::UpdatePacketInformationReceivedByPeer(
+    const QuicAckFrame& incoming_ack) {
+  SequenceNumberSet acked_packets;
+
+  // ValidateAck should fail if largest_observed ever shrinks.
+  DCHECK_LE(peer_largest_observed_packet_,
+            incoming_ack.received_info.largest_observed);
+  peer_largest_observed_packet_ = incoming_ack.received_info.largest_observed;
+
+  if (incoming_ack.received_info.missing_packets.empty()) {
+    least_packet_awaited_by_peer_ = peer_largest_observed_packet_ + 1;
+  } else {
+    least_packet_awaited_by_peer_ =
+        *(incoming_ack.received_info.missing_packets.begin());
+  }
+
+  entropy_manager_.ClearSentEntropyBefore(least_packet_awaited_by_peer_ - 1);
+
   int retransmitted_packets = 0;
   // Go through the packets we have not received an ack for and see if this
   // incoming_ack shows they've been seen by the peer.
   UnackedPacketMap::iterator it = unacked_packets_.begin();
   while (it != unacked_packets_.end()) {
     QuicPacketSequenceNumber sequence_number = it->first;
     if (sequence_number > peer_largest_observed_packet_) {
       break;
     }
     RetransmittableFrames* unacked = it->second;
     if (!IsAwaitingPacket(incoming_ack.received_info, sequence_number)) {
       // Packet was acked, so remove it from our unacked packet list.
       DVLOG(1) << ENDPOINT <<"Got an ack for packet " << sequence_number;
-      acked_packets->insert(sequence_number);
+      acked_packets.insert(sequence_number);
       delete unacked;
-      unacked_packets_.erase(it++);
+      UnackedPacketMap::iterator it_tmp = it;
+      ++it;
+      unacked_packets_.erase(it_tmp);
       retransmission_map_.erase(sequence_number);
     } else {
       // This is a packet which we planned on retransmitting and has not been
       // seen at the time of this ack being sent out.  See if it's our new
       // lowest unacked packet.
       DVLOG(1) << ENDPOINT << "still missing packet " << sequence_number;
       ++it;
       // The peer got packets after this sequence number.  This is an explicit
       // nack.
       RetransmissionMap::iterator retransmission_it =
           retransmission_map_.find(sequence_number);
       ++(retransmission_it->second.number_nacks);
       if (retransmission_it->second.number_nacks >=
              kNumberOfNacksBeforeRetransmission &&
           retransmitted_packets < kMaxRetransmissionsPerAck) {
         ++retransmitted_packets;
         DVLOG(1) << ENDPOINT << "Trying to retransmit packet "
                  << sequence_number
                  << " as it has been nacked 3 or more times.";
         // TODO(satyamshekhar): save in a vector and retransmit after the
         // loop.
         RetransmitPacket(sequence_number);
       }
     }
   }
-}
-
-void QuicConnection::HandleAckForSentFecPackets(
-    const QuicAckFrame& incoming_ack, SequenceNumberSet* acked_packets) {
-  UnackedPacketMap::iterator it = unacked_fec_packets_.begin();
-  while (it != unacked_fec_packets_.end()) {
-    QuicPacketSequenceNumber sequence_number = it->first;
-    if (sequence_number > peer_largest_observed_packet_) {
-      break;
-    }
-    if (!IsAwaitingPacket(incoming_ack.received_info, sequence_number)) {
-      DVLOG(1) << ENDPOINT << "Got an ack for fec packet: " << sequence_number;
-      acked_packets->insert(sequence_number);
-      unacked_fec_packets_.erase(it++);
-    } else {
-      DVLOG(1) << ENDPOINT << "Still missing ack for fec packet: "
-               << sequence_number;
-      ++it;
-    }
-  }
-}
-
-void QuicConnection::UpdatePacketInformationReceivedByPeer(
-    const QuicAckFrame& incoming_ack) {
-  // ValidateAck should fail if largest_observed ever shrinks.
-  DCHECK_LE(peer_largest_observed_packet_,
-            incoming_ack.received_info.largest_observed);
-  peer_largest_observed_packet_ = incoming_ack.received_info.largest_observed;
-
-  if (incoming_ack.received_info.missing_packets.empty()) {
-    least_packet_awaited_by_peer_ = peer_largest_observed_packet_ + 1;
-  } else {
-    least_packet_awaited_by_peer_ =
-        *(incoming_ack.received_info.missing_packets.begin());
-  }
-
-  entropy_manager_.ClearSentEntropyBefore(least_packet_awaited_by_peer_ - 1);
-
-  SequenceNumberSet acked_packets;
-  HandleAckForSentPackets(incoming_ack, &acked_packets);
-  HandleAckForSentFecPackets(incoming_ack, &acked_packets);
-
   if (acked_packets.size() > 0) {
     visitor_->OnAck(acked_packets);
   }
 }
 
 bool QuicConnection::DontWaitForPacketsBefore(
     QuicPacketSequenceNumber least_unacked) {
   size_t missing_packets_count =
       outgoing_ack_.received_info.missing_packets.size();
   outgoing_ack_.received_info.missing_packets.erase(
@@ skipping 418 matching lines @@
   return true;
 }
 
 bool QuicConnection::IsRetransmission(
     QuicPacketSequenceNumber sequence_number) {
   RetransmissionMap::iterator it = retransmission_map_.find(sequence_number);
   return it != retransmission_map_.end() &&
       it->second.number_retransmissions > 0;
 }
 
-void QuicConnection::SetupRetransmission(
+void QuicConnection::MaybeSetupRetransmission(
     QuicPacketSequenceNumber sequence_number) {
   RetransmissionMap::iterator it = retransmission_map_.find(sequence_number);
   if (it == retransmission_map_.end()) {
     DVLOG(1) << ENDPOINT << "Will not retransmit packet " << sequence_number;
     return;
   }
 
   RetransmissionInfo retransmission_info = it->second;
   QuicTime::Delta retransmission_delay =
       congestion_manager_.GetRetransmissionDelay(
           unacked_packets_.size(),
           retransmission_info.number_retransmissions);
-
-  retransmission_timeouts_.push(RetransmissionTime(
-      sequence_number,
-      clock_->ApproximateNow().Add(retransmission_delay),
-      false));
+  retransmission_info.scheduled_time =
+      clock_->ApproximateNow().Add(retransmission_delay);
+  retransmission_timeouts_.push(retransmission_info);
 
   // Do not set the retransmisson alarm if we're already handling the
   // retransmission alarm because the retransmission alarm will be reset when
   // OnRetransmissionTimeout completes.
   if (!handling_retransmission_timeout_) {
     helper_->SetRetransmissionAlarm(retransmission_delay);
   }
   // TODO(satyamshekhar): restore packet reordering with Ian's TODO in
   // SendStreamData().
 }
 
-void QuicConnection::SetupAbandonFecTimer(
-    QuicPacketSequenceNumber sequence_number) {
-  DCHECK(ContainsKey(unacked_fec_packets_, sequence_number));
-  QuicTime::Delta retransmission_delay =
-      QuicTime::Delta::FromMilliseconds(
-          congestion_manager_.DefaultRetransmissionTime().ToMilliseconds() * 3);
-  retransmission_timeouts_.push(RetransmissionTime(
-      sequence_number,
-      clock_->ApproximateNow().Add(retransmission_delay),
-      true));
-}
-
 void QuicConnection::DropPacket(QuicPacketSequenceNumber sequence_number) {
   UnackedPacketMap::iterator unacked_it =
       unacked_packets_.find(sequence_number);
   // Packet was not meant to be retransmitted.
   if (unacked_it == unacked_packets_.end()) {
     DCHECK(!ContainsKey(retransmission_map_, sequence_number));
     return;
   }
   // Delete the unacked packet.
   delete unacked_it->second;
@@ skipping 70 matching lines @@
   }
   if (!retransmission) {
     time_of_last_sent_packet_ = now;
   }
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // Set the retransmit alarm only when we have sent the packet to the client
   // and not when it goes to the pending queue, otherwise we will end up adding
   // an entry to retransmission_timeout_ every time we attempt a write.
-  if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
-    SetupRetransmission(sequence_number);
-  } else if (packet->is_fec_packet()) {
-    SetupAbandonFecTimer(sequence_number);
-  }
+  MaybeSetupRetransmission(sequence_number);
 
   congestion_manager_.SentPacket(sequence_number, now, packet->length(),
                                  retransmission);
 
   stats_.bytes_sent += encrypted->length();
   ++stats_.packets_sent;
 
   if (retransmission == IS_RETRANSMISSION) {
     stats_.bytes_retransmitted += encrypted->length();
     ++stats_.packets_retransmitted;
@@ skipping 13 matching lines @@
     // original.
     serialized_packet.retransmittable_frames->set_encryption_level(
         encryption_level_);
     unacked_packets_.insert(
         make_pair(serialized_packet.sequence_number,
                   serialized_packet.retransmittable_frames));
     // All unacked packets might be retransmitted.
     retransmission_map_.insert(
         make_pair(serialized_packet.sequence_number,
                   RetransmissionInfo(serialized_packet.sequence_number)));
-  } else if (serialized_packet.packet->is_fec_packet()) {
-    unacked_fec_packets_.insert(make_pair(
-        serialized_packet.sequence_number,
-        serialized_packet.retransmittable_frames));
   }
   return SendOrQueuePacket(encryption_level_,
                            serialized_packet.sequence_number,
                            serialized_packet.packet,
                            serialized_packet.entropy_hash,
                            serialized_packet.retransmittable_frames != NULL ?
                                HAS_RETRANSMITTABLE_DATA :
                                NO_RETRANSMITTABLE_DATA);
 }
 
@@ skipping 49 matching lines @@
   if (congestion_manager_.GenerateCongestionFeedback(
           &outgoing_congestion_feedback_)) {
     DVLOG(1) << ENDPOINT << "Sending feedback "
              << outgoing_congestion_feedback_;
     send_feedback = true;
   }
 
   packet_generator_.SetShouldSendAck(send_feedback);
 }
 
-void QuicConnection::MaybeAbandonFecPacket(
-    QuicPacketSequenceNumber sequence_number) {
-  if (!ContainsKey(unacked_fec_packets_, sequence_number)) {
-    DVLOG(2) << ENDPOINT << "no need to abandon fec packet: "
-             << sequence_number << "; it's already acked'";
-    return;
-  }
-  congestion_manager_.AbandoningPacket(sequence_number);
-  // TODO(satyashekhar): Should this decrease the congestion window?
-}
-
 QuicTime QuicConnection::OnRetransmissionTimeout() {
   // This guards against registering the alarm later than we should.
   //
   // If we have packet A and B in the list and we call
   // MaybeRetransmitPacketForRTO on A, that may trigger a call to
   // SetRetransmissionAlarm if A is retransmitted as C.  In that case we
   // don't want to register the alarm under SetRetransmissionAlarm; we
   // want to set it to the RTO of B when we return from this function.
   handling_retransmission_timeout_ = true;
 
   for (size_t i = 0; i < max_packets_per_retransmission_alarm_ &&
            !retransmission_timeouts_.empty(); ++i) {
-    RetransmissionTime retransmission_time = retransmission_timeouts_.top();
-    DCHECK(retransmission_time.scheduled_time.IsInitialized());
-    if (retransmission_time.scheduled_time > clock_->ApproximateNow()) {
+    RetransmissionInfo retransmission_info = retransmission_timeouts_.top();
+    DCHECK(retransmission_info.scheduled_time.IsInitialized());
+    if (retransmission_info.scheduled_time > clock_->ApproximateNow()) {
       break;
     }
     retransmission_timeouts_.pop();
-
-    if (retransmission_time.for_fec) {
-      MaybeAbandonFecPacket(retransmission_time.sequence_number);
-      continue;
-    } else if (
-        !MaybeRetransmitPacketForRTO(retransmission_time.sequence_number)) {
+    if (!MaybeRetransmitPacketForRTO(retransmission_info.sequence_number)) {
       DLOG(INFO) << ENDPOINT << "MaybeRetransmitPacketForRTO failed: "
                  << "adding an extra delay for "
-                 << retransmission_time.sequence_number;
-      retransmission_time.scheduled_time = clock_->ApproximateNow().Add(
+                 << retransmission_info.sequence_number;
+      retransmission_info.scheduled_time = clock_->ApproximateNow().Add(
           congestion_manager_.DefaultRetransmissionTime());
-      retransmission_timeouts_.push(retransmission_time);
+      retransmission_timeouts_.push(retransmission_info);
     }
   }
 
   handling_retransmission_timeout_ = false;
 
   if (retransmission_timeouts_.empty()) {
     return QuicTime::Zero();
   }
 
   // We have packets remaining.  Return the absolute RTO of the oldest packet
@@ skipping 152 matching lines @@
     delete fec_group;
     it = next;
   }
 }
 
 bool QuicConnection::HasQueuedData() const {
   return !queued_packets_.empty() || packet_generator_.HasQueuedFrames();
 }
 
 void QuicConnection::SetIdleNetworkTimeout(QuicTime::Delta timeout) {
-  if (timeout < idle_network_timeout_) {
+  // if (timeout < idle_network_timeout_) {
     idle_network_timeout_ = timeout;
     CheckForTimeout();
-  } else {
-     idle_network_timeout_ = timeout;
-  }
+  // } else {
+  //   idle_network_timeout_ = timeout;
+  // }
 }
 
 void QuicConnection::SetOverallConnectionTimeout(QuicTime::Delta timeout) {
-  if (timeout < overall_connection_timeout_) {
+  // if (timeout < overall_connection_timeout_) {
     overall_connection_timeout_ = timeout;
     CheckForTimeout();
-  } else {
-    overall_connection_timeout_ = timeout;
-  }
+  // } else {
+  //   overall_connection_timeout_ = timeout;
+  // }
 }
 
 bool QuicConnection::CheckForTimeout() {
   QuicTime now = clock_->ApproximateNow();
   QuicTime time_of_last_packet = std::max(time_of_last_received_packet_,
                                           time_of_last_sent_packet_);
 
-  // |delta| can be < 0 as |now| is approximate time but |time_of_last_packet|
-  // is accurate time. However, this should not change the behavior of
-  // timeout handling.
   QuicTime::Delta delta = now.Subtract(time_of_last_packet);
   DVLOG(1) << ENDPOINT << "last packet "
            << time_of_last_packet.ToDebuggingValue()
            << " now:" << now.ToDebuggingValue()
            << " delta:" << delta.ToMicroseconds()
            << " network_timeout: " << idle_network_timeout_.ToMicroseconds();
   if (delta >= idle_network_timeout_) {
     DVLOG(1) << ENDPOINT << "Connection timedout due to no network activity.";
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
@@ skipping 20 matching lines @@
     if (connection_timeout < timeout) {
       timeout = connection_timeout;
     }
   }
 
   helper_->SetTimeoutAlarm(timeout);
   return false;
 }
 
 }  // namespace net