Landing 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 136 matching lines @@
     connection_->SendPing();
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(PingAlarm);
 };
 
-QuicConnection::PacketType GetPacketType(
-    const RetransmittableFrames* retransmittable_frames) {
-  if (!retransmittable_frames) {
-    return QuicConnection::NORMAL;
-  }
-  for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
-    if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
-      return QuicConnection::CONNECTION_CLOSE;
-    }
-  }
-  return QuicConnection::NORMAL;
-}
-
 }  // namespace
 
 QuicConnection::QueuedPacket::QueuedPacket(SerializedPacket packet,
                                            EncryptionLevel level,
                                            TransmissionType transmission_type)
-  : sequence_number(packet.sequence_number),
-    packet(packet.packet),
+  : serialized_packet(packet),
     encryption_level(level),
-    transmission_type(transmission_type),
-    retransmittable((transmission_type != NOT_RETRANSMISSION ||
-                     packet.retransmittable_frames != NULL) ?
-                         HAS_RETRANSMITTABLE_DATA : NO_RETRANSMITTABLE_DATA),
-    handshake(packet.retransmittable_frames == NULL ?
-      NOT_HANDSHAKE : packet.retransmittable_frames->HasCryptoHandshake()),
-    type(GetPacketType(packet.retransmittable_frames)),
-    length(packet.packet->length()) {
+    transmission_type(transmission_type) {
 }
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicConnection::QuicConnection(QuicConnectionId connection_id,
                                IPEndPoint address,
                                QuicConnectionHelperInterface* helper,
                                const PacketWriterFactory& writer_factory,
                                bool owns_writer,
                                bool is_server,
@@ skipping 59 matching lines @@
 }
 
 QuicConnection::~QuicConnection() {
   if (owns_writer_) {
     delete writer_;
   }
   STLDeleteElements(&undecryptable_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
-    delete it->packet;
+    delete it->serialized_packet.packet;
   }
 }
 
 void QuicConnection::SetFromConfig(const QuicConfig& config) {
   SetIdleNetworkTimeout(config.idle_connection_state_lifetime());
   sent_packet_manager_.SetFromConfig(config);
 }
 
 bool QuicConnection::SelectMutualVersion(
     const QuicVersionVector& available_versions) {
@@ skipping 17 matching lines @@
   // Packets that we cannot decrypt are dropped.
   // TODO(rch): add stats to measure this.
   if (!connected_ || framer->error() == QUIC_DECRYPTION_FAILURE) {
     return;
   }
   SendConnectionCloseWithDetails(framer->error(), framer->detailed_error());
 }
 
 void QuicConnection::OnPacket() {
   DCHECK(last_stream_frames_.empty() &&
+         last_ack_frames_.empty() &&
+         last_congestion_frames_.empty() &&
+         last_stop_waiting_frames_.empty() &&
+         last_rst_frames_.empty() &&
          last_goaway_frames_.empty() &&
          last_window_update_frames_.empty() &&
          last_blocked_frames_.empty() &&
-         last_rst_frames_.empty() &&
-         last_ack_frames_.empty() &&
-         last_congestion_frames_.empty() &&
-         last_stop_waiting_frames_.empty());
+         last_ping_frames_.empty() &&
+         last_close_frames_.empty());
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 
   DVLOG(1) << ENDPOINT << "Connection " << connection_id()
@@ skipping 36 matching lines @@
       // Might be old packets that were sent by the client before the version
       // was negotiated. Drop these.
       return false;
 
     default:
       DCHECK(false);
   }
 
   version_negotiation_state_ = NEGOTIATED_VERSION;
   visitor_->OnSuccessfulVersionNegotiation(received_version);
+  if (debug_visitor_.get() != NULL) {
+    debug_visitor_->OnSuccessfulVersionNegotiation(received_version);
+  }
   DVLOG(1) << ENDPOINT << "version negotiated " << received_version;
 
   // Store the new version.
   framer_.set_version(received_version);
 
   // TODO(satyamshekhar): Store the sequence number of this packet and close the
   // connection if we ever received a packet with incorrect version and whose
   // sequence number is greater.
   return true;
 }
@@ skipping 106 matching lines @@
                       << " without version flag before version negotiated.";
         // Packets should have the version flag till version negotiation is
         // done.
         CloseConnection(QUIC_INVALID_VERSION, false);
         return false;
       } else {
         DCHECK_EQ(1u, header.public_header.versions.size());
         DCHECK_EQ(header.public_header.versions[0], version());
         version_negotiation_state_ = NEGOTIATED_VERSION;
         visitor_->OnSuccessfulVersionNegotiation(version());
+        if (debug_visitor_.get() != NULL) {
+          debug_visitor_->OnSuccessfulVersionNegotiation(version());
+        }
       }
     } else {
       DCHECK(!header.public_header.version_flag);
       // If the client gets a packet without the version flag from the server
       // it should stop sending version since the version negotiation is done.
       packet_generator_.StopSendingVersion();
       version_negotiation_state_ = NEGOTIATED_VERSION;
       visitor_->OnSuccessfulVersionNegotiation(version());
+      if (debug_visitor_.get() != NULL) {
+        debug_visitor_->OnSuccessfulVersionNegotiation(version());
+      }
     }
   }
 
   DCHECK_EQ(NEGOTIATED_VERSION, version_negotiation_state_);
 
   --stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Received packet header: " << header;
   last_header_ = header;
   DCHECK(connected_);
   return true;
@@ skipping 100 matching lines @@
 
   last_stop_waiting_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnPingFrame(frame);
   }
+  last_ping_frames_.push_back(frame);
   return true;
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.largest_observed > packet_generator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
                 << incoming_ack.largest_observed << " vs "
                 << packet_generator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
@@ skipping 141 matching lines @@
 
 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_sequence_number
-           << " with " << last_ack_frames_.size() << " acks, "
+           << " with " << last_stream_frames_.size()<< " stream frames "
+           << last_ack_frames_.size() << " acks, "
            << last_congestion_frames_.size() << " congestions, "
            << last_stop_waiting_frames_.size() << " stop_waiting, "
+           << last_rst_frames_.size() << " rsts, "
            << last_goaway_frames_.size() << " goaways, "
            << last_window_update_frames_.size() << " window updates, "
            << last_blocked_frames_.size() << " blocked, "
-           << last_rst_frames_.size() << " rsts, "
+           << last_ping_frames_.size() << " pings, "
            << last_close_frames_.size() << " closes, "
-           << last_stream_frames_.size()
-           << " stream frames for "
-           << last_header_.public_header.connection_id;
+           << "for " << last_header_.public_header.connection_id;
 
   // Call MaybeQueueAck() before recording the received packet, since we want
   // to trigger an ack if the newly received packet was previously missing.
   MaybeQueueAck();
 
   // 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(
@@ skipping 72 matching lines @@
     }
   }
 
   if (ack_queued_) {
     ack_alarm_->Cancel();
   }
 }
 
 void QuicConnection::ClearLastFrames() {
   last_stream_frames_.clear();
+  last_ack_frames_.clear();
+  last_congestion_frames_.clear();
+  last_stop_waiting_frames_.clear();
+  last_rst_frames_.clear();
   last_goaway_frames_.clear();
   last_window_update_frames_.clear();
   last_blocked_frames_.clear();
-  last_rst_frames_.clear();
-  last_ack_frames_.clear();
-  last_stop_waiting_frames_.clear();
-  last_congestion_frames_.clear();
+  last_ping_frames_.clear();
+  last_close_frames_.clear();
 }
 
 QuicAckFrame* QuicConnection::CreateAckFrame() {
   QuicAckFrame* outgoing_ack = new QuicAckFrame();
   received_packet_manager_.UpdateReceivedPacketInfo(
       outgoing_ack, clock_->ApproximateNow());
   DVLOG(1) << ENDPOINT << "Creating ack frame: " << *outgoing_ack;
   return outgoing_ack;
 }
 
 QuicCongestionFeedbackFrame* QuicConnection::CreateFeedbackFrame() {
   return new QuicCongestionFeedbackFrame(outgoing_congestion_feedback_);
 }
 
 QuicStopWaitingFrame* QuicConnection::CreateStopWaitingFrame() {
   QuicStopWaitingFrame stop_waiting;
   UpdateStopWaiting(&stop_waiting);
   return new QuicStopWaitingFrame(stop_waiting);
 }
 
 bool QuicConnection::ShouldLastPacketInstigateAck() const {
   if (!last_stream_frames_.empty() ||
       !last_goaway_frames_.empty() ||
       !last_rst_frames_.empty() ||
       !last_window_update_frames_.empty() ||
-      !last_blocked_frames_.empty()) {
+      !last_blocked_frames_.empty() ||
+      !last_ping_frames_.empty()) {
     return true;
   }
 
   if (!last_ack_frames_.empty() && last_ack_frames_.back().is_truncated) {
     return true;
   }
   return false;
 }
 
 void QuicConnection::UpdateStopWaitingCount() {
@@ skipping 278 matching lines @@
 }
 
 void QuicConnection::WriteQueuedPackets() {
   DCHECK(!writer_->IsWriteBlocked());
 
   if (pending_version_negotiation_packet_) {
     SendVersionNegotiationPacket();
   }
 
   QueuedPacketList::iterator packet_iterator = queued_packets_.begin();
-  while (!writer_->IsWriteBlocked() &&
-         packet_iterator != queued_packets_.end()) {
-    if (WritePacket(*packet_iterator)) {
-      delete packet_iterator->packet;
-      packet_iterator = queued_packets_.erase(packet_iterator);
-    } else {
-      // Continue, because some queued packets may still be writable.
-      // This can happen if a retransmit send fails.
-      ++packet_iterator;
-    }
+  while (packet_iterator != queued_packets_.end() &&
+         WritePacket(*packet_iterator)) {
+    delete packet_iterator->serialized_packet.packet;
+    packet_iterator = queued_packets_.erase(packet_iterator);
   }
 }
 
 void QuicConnection::WritePendingRetransmissions() {
   // Keep writing as long as there's a pending retransmission which can be
   // written.
   while (sent_packet_manager_.HasPendingRetransmissions()) {
     const QuicSentPacketManager::PendingRetransmission pending =
         sent_packet_manager_.NextPendingRetransmission();
-    if (GetPacketType(&pending.retransmittable_frames) == NORMAL &&
-        !CanWrite(HAS_RETRANSMITTABLE_DATA)) {
+    if (!CanWrite(HAS_RETRANSMITTABLE_DATA)) {
       break;
     }
 
     // Re-packetize the frames with a new sequence number for retransmission.
     // Retransmitted data packets do not use FEC, even when it's enabled.
     // Retransmitted packets use the same sequence number length as the
     // original.
     // Flush the packet generator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
@@ skipping 63 matching lines @@
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
     DVLOG(1) << "Delaying sending.";
     return false;
   }
   send_alarm_->Cancel();
   return true;
 }
 
-bool QuicConnection::WritePacket(QueuedPacket packet) {
-  QuicPacketSequenceNumber sequence_number = packet.sequence_number;
+bool QuicConnection::WritePacket(const QueuedPacket& packet) {
+  QuicPacketSequenceNumber sequence_number =
+      packet.serialized_packet.sequence_number;
   if (ShouldDiscardPacket(packet.encryption_level,
                           sequence_number,
-                          packet.retransmittable)) {
+                          IsRetransmittable(packet))) {
     ++stats_.packets_discarded;
     return true;
   }
-
-  // If the packet is CONNECTION_CLOSE, we need to try to send it immediately
-  // and encrypt it to hand it off to TimeWaitListManager.
-  // If the packet is QUEUED, we don't re-consult the congestion control.
-  // This ensures packets are sent in sequence number order.
-  // TODO(ianswett): The congestion control should have been consulted before
-  // serializing the packet, so this could be turned into a LOG_IF(DFATAL).
-  if (packet.type == NORMAL && !CanWrite(packet.retransmittable)) {
+  // Connection close packets are encypted and saved, so don't exit early.
+  if (writer_->IsWriteBlocked() && !IsConnectionClose(packet)) {
     return false;
   }
 
   // Some encryption algorithms require the packet sequence numbers not be
   // repeated.
   DCHECK_LE(sequence_number_of_last_sent_packet_, sequence_number);
   sequence_number_of_last_sent_packet_ = sequence_number;
 
   QuicEncryptedPacket* encrypted = framer_.EncryptPacket(
-      packet.encryption_level, sequence_number, *packet.packet);
+      packet.encryption_level,
+      sequence_number,
+      *packet.serialized_packet.packet);
   if (encrypted == NULL) {
     LOG(DFATAL) << ENDPOINT << "Failed to encrypt packet number "
                 << sequence_number;
     // CloseConnection does not send close packet, so no infinite loop here.
     CloseConnection(QUIC_ENCRYPTION_FAILURE, false);
     return false;
   }
 
   // Connection close packets are eventually owned by TimeWaitListManager.
   // Others are deleted at the end of this call.
   scoped_ptr<QuicEncryptedPacket> encrypted_deleter;
-  if (packet.type == CONNECTION_CLOSE) {
+  if (IsConnectionClose(packet)) {
     DCHECK(connection_close_packet_.get() == NULL);
     connection_close_packet_.reset(encrypted);
     // This assures we won't try to write *forced* packets when blocked.
     // Return true to stop processing.
     if (writer_->IsWriteBlocked()) {
       visitor_->OnWriteBlocked();
       return true;
     }
   } else {
     encrypted_deleter.reset(encrypted);
   }
 
   if (!FLAGS_quic_allow_oversized_packets_for_test) {
     DCHECK_LE(encrypted->length(), kMaxPacketSize);
   }
   DCHECK_LE(encrypted->length(), packet_generator_.max_packet_length());
-  DVLOG(1) << ENDPOINT << "Sending packet " << sequence_number
-           << " : " << (packet.packet->is_fec_packet() ? "FEC " :
-               (packet.retransmittable == HAS_RETRANSMITTABLE_DATA
-                    ? "data bearing " : " ack only "))
+  DVLOG(1) << ENDPOINT << "Sending packet " << sequence_number << " : "
+           << (packet.serialized_packet.packet->is_fec_packet() ? "FEC " :
+               (IsRetransmittable(packet) == HAS_RETRANSMITTABLE_DATA
+                ? "data bearing " : " ack only "))
            << ", encryption level: "
            << QuicUtils::EncryptionLevelToString(packet.encryption_level)
-           << ", length:" << packet.packet->length() << ", encrypted length:"
+           << ", length:"
+           << packet.serialized_packet.packet->length()
+           << ", encrypted length:"
            << encrypted->length();
   DVLOG(2) << ENDPOINT << "packet(" << sequence_number << "): " << std::endl
-           << QuicUtils::StringToHexASCIIDump(packet.packet->AsStringPiece());
+           << QuicUtils::StringToHexASCIIDump(
+               packet.serialized_packet.packet->AsStringPiece());
 
   WriteResult result = writer_->WritePacket(encrypted->data(),
                                             encrypted->length(),
                                             self_address().address(),
                                             peer_address());
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
   if (debug_visitor_.get() != NULL) {
     // Pass the write result to the visitor.
@@ skipping 22 matching lines @@
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // TODO(ianswett): Change the sequence number length and other packet creator
   // options by a more explicit API than setting a struct value directly,
   // perhaps via the NetworkChangeVisitor.
   packet_generator_.UpdateSequenceNumberLength(
       sent_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.GetCongestionWindow());
 
-  bool reset_retransmission_alarm =
-      sent_packet_manager_.OnPacketSent(sequence_number,
-                                        now,
-                                        encrypted->length(),
-                                        packet.transmission_type,
-                                        packet.retransmittable);
+  bool reset_retransmission_alarm = sent_packet_manager_.OnPacketSent(
+      sequence_number,
+      now,
+      encrypted->length(),
+      packet.transmission_type,
+      IsRetransmittable(packet));
 
   if (reset_retransmission_alarm || !retransmission_alarm_->IsSet()) {
     retransmission_alarm_->Update(sent_packet_manager_.GetRetransmissionTime(),
                                   QuicTime::Delta::FromMilliseconds(1));
   }
 
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
   if (packet.transmission_type != NOT_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
@@ skipping 75 matching lines @@
   visitor_->OnCongestionWindowChange(clock_->ApproximateNow());
 }
 
 void QuicConnection::OnHandshakeComplete() {
   sent_packet_manager_.SetHandshakeConfirmed();
 }
 
 bool QuicConnection::SendOrQueuePacket(EncryptionLevel level,
                                        const SerializedPacket& packet,
                                        TransmissionType transmission_type) {
+  // The caller of this function is responsible for checking CanWrite().
   if (packet.packet == NULL) {
     LOG(DFATAL) << "NULL packet passed in to SendOrQueuePacket";
     return true;
   }
 
   sent_entropy_manager_.RecordPacketEntropyHash(packet.sequence_number,
                                                 packet.entropy_hash);
   QueuedPacket queued_packet(packet, level, transmission_type);
-  // If there are already queued packets, put this at the end,
-  // unless it's ConnectionClose, in which case it is written immediately.
-  if ((queued_packet.type == CONNECTION_CLOSE || queued_packets_.empty()) &&
-      WritePacket(queued_packet)) {
+  LOG_IF(DFATAL, !queued_packets_.empty() && !writer_->IsWriteBlocked())
+      << "Packets should only be left queued if we're write blocked.";
+  if (WritePacket(queued_packet)) {
     delete packet.packet;
     return true;
   }
-  queued_packet.type = QUEUED;
   queued_packets_.push_back(queued_packet);
   return false;
 }
 
 void QuicConnection::UpdateStopWaiting(QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.GetCumulativeEntropy(
       stop_waiting->least_unacked - 1);
 }
 
@@ skipping 432 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());
 }
 
+HasRetransmittableData QuicConnection::IsRetransmittable(
+    QueuedPacket packet) {
+  // TODO(cyr): Understand why the first check here is necessary. Without it,
+  // DiscardRetransmit test fails.
+  if (packet.transmission_type != NOT_RETRANSMISSION ||
+      packet.serialized_packet.retransmittable_frames != NULL) {
+    return HAS_RETRANSMITTABLE_DATA;
+  } else {
+    return NO_RETRANSMITTABLE_DATA;
+  }
+}
+
+bool QuicConnection::IsConnectionClose(
+    QueuedPacket packet) {
+  RetransmittableFrames* retransmittable_frames =
+      packet.serialized_packet.retransmittable_frames;
+  if (!retransmittable_frames) {
+    return false;
+  }
+  for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
+    if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace net