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 201 matching lines @@
       received_packet_manager_(kTCP, &stats_),
       ack_queued_(false),
       stop_waiting_count_(0),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
       retransmission_alarm_(helper->CreateAlarm(new RetransmissionAlarm(this))),
       send_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       resume_writes_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       timeout_alarm_(helper->CreateAlarm(new TimeoutAlarm(this))),
       ping_alarm_(helper->CreateAlarm(new PingAlarm(this))),
       debug_visitor_(NULL),
-      packet_creator_(connection_id_, &framer_, random_generator_, is_server),
-      packet_generator_(this, NULL, &packet_creator_),
+      packet_generator_(connection_id_, &framer_, random_generator_, this),
       idle_network_timeout_(
           QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
       overall_connection_timeout_(QuicTime::Delta::Infinite()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       sequence_number_of_last_sent_packet_(0),
       sent_packet_manager_(
           is_server, clock_, &stats_, kTCP,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack),
       version_negotiation_state_(START_NEGOTIATION),
@@ skipping 237 matching lines @@
       } 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());
       }
     } 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_creator_.StopSendingVersion();
+      packet_generator_.StopSendingVersion();
       version_negotiation_state_ = NEGOTIATED_VERSION;
       visitor_->OnSuccessfulVersionNegotiation(version());
     }
   }
 
   DCHECK_EQ(NEGOTIATED_VERSION, version_negotiation_state_);
 
   --stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Received packet header: " << header;
   last_header_ = header;
@@ skipping 117 matching lines @@
 bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnPingFrame(frame);
   }
   return true;
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.received_info.largest_observed >
-      packet_creator_.sequence_number()) {
+      packet_generator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
                 << incoming_ack.received_info.largest_observed << " vs "
-                << packet_creator_.sequence_number();
+                << packet_generator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
   if (incoming_ack.received_info.largest_observed <
           received_packet_manager_.peer_largest_observed_packet()) {
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
                 << incoming_ack.received_info.largest_observed << " vs "
                 << received_packet_manager_.peer_largest_observed_packet();
     // A new ack has a diminished largest_observed value.  Error out.
@@ skipping 298 matching lines @@
           *last_ack_frames_.back().received_info.missing_packets.begin()) {
     ++stop_waiting_count_;
   } else {
     stop_waiting_count_ = 0;
   }
 }
 
 QuicPacketSequenceNumber QuicConnection::GetLeastUnacked() const {
   return sent_packet_manager_.HasUnackedPackets() ?
       sent_packet_manager_.GetLeastUnackedSentPacket() :
-      packet_creator_.sequence_number() + 1;
+      packet_generator_.sequence_number() + 1;
 }
 
 void QuicConnection::MaybeSendInResponseToPacket() {
   if (!connected_) {
     return;
   }
   ScopedPacketBundler bundler(this, ack_queued_ ? SEND_ACK : NO_ACK);
 
   // Now that we have received an ack, we might be able to send packets which
   // are queued locally, or drain streams which are blocked.
   if (CanWrite(HAS_RETRANSMITTABLE_DATA)) {
     OnCanWrite();
   }
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
   // TODO(alyssar): implement zero server state negotiation.
   pending_version_negotiation_packet_ = true;
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return;
   }
   scoped_ptr<QuicEncryptedPacket> version_packet(
-      packet_creator_.SerializeVersionNegotiationPacket(
+      packet_generator_.SerializeVersionNegotiationPacket(
           framer_.supported_versions()));
   WriteResult result = writer_->WritePacket(
       version_packet->data(), version_packet->length(),
       self_address().address(), peer_address());
 
   if (result.status == WRITE_STATUS_ERROR) {
     // We can't send an error as the socket is presumably borked.
     CloseConnection(QUIC_PACKET_WRITE_ERROR, false);
     return;
   }
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     if (writer_->IsWriteBlockedDataBuffered()) {
       pending_version_negotiation_packet_ = false;
     }
     return;
   }
 
   pending_version_negotiation_packet_ = false;
 }
 
 QuicConsumedData QuicConnection::SendStreamData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
+    FecProtection fec_protection,
     QuicAckNotifier::DelegateInterface* delegate) {
   if (!fin && data.Empty()) {
     LOG(DFATAL) << "Attempt to send empty stream frame";
   }
 
   // This notifier will be owned by the AckNotifierManager (or deleted below if
   // no data or FIN was consumed).
   QuicAckNotifier* notifier = NULL;
   if (delegate) {
     notifier = new QuicAckNotifier(delegate);
   }
 
   // Opportunistically bundle an ack with every outgoing packet.
   // Particularly, we want to bundle with handshake packets since we don't know
   // which decrypter will be used on an ack packet following a handshake
   // packet (a handshake packet from client to server could result in a REJ or a
   // SHLO from the server, leading to two different decrypters at the server.)
   //
   // TODO(jri): Note that ConsumeData may cause a response packet to be sent.
   // We may end up sending stale ack information if there are undecryptable
   // packets hanging around and/or there are revivable packets which may get
   // handled after this packet is sent. Change ScopedPacketBundler to do the
   // right thing: check ack_queued_, and then check undecryptable packets and
   // also if there is possibility of revival. Only bundle an ack if there's no
   // processing left that may cause received_info_ to change.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   QuicConsumedData consumed_data =
-      packet_generator_.ConsumeData(id, data, offset, fin, notifier);
+      packet_generator_.ConsumeData(id, data, offset, fin, fec_protection,
+                                    notifier);
 
   if (notifier &&
       (consumed_data.bytes_consumed == 0 && !consumed_data.fin_consumed)) {
     // No data was consumed, nor was a fin consumed, so delete the notifier.
     delete notifier;
   }
 
   return consumed_data;
 }
 
@@ skipping 22 matching lines @@
 
 const QuicConnectionStats& QuicConnection::GetStats() {
   // Update rtt and estimated bandwidth.
   stats_.min_rtt_us =
       sent_packet_manager_.GetRttStats()->min_rtt().ToMicroseconds();
   stats_.srtt_us =
       sent_packet_manager_.GetRttStats()->SmoothedRtt().ToMicroseconds();
   stats_.estimated_bandwidth =
       sent_packet_manager_.BandwidthEstimate().ToBytesPerSecond();
   stats_.congestion_window = sent_packet_manager_.GetCongestionWindow();
-  stats_.max_packet_size = packet_creator_.max_packet_length();
+  stats_.max_packet_size = packet_generator_.max_packet_length();
   return stats_;
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
   }
   if (debug_visitor_) {
@@ skipping 109 matching lines @@
              << peer_address_.port() << " to " << migrating_peer_port_
              << ", migrating connection.";
     peer_address_ = IPEndPoint(peer_address_.address(), migrating_peer_port_);
   }
 
   time_of_last_received_packet_ = clock_->Now();
   DVLOG(1) << ENDPOINT << "time of last received packet: "
            << time_of_last_received_packet_.ToDebuggingValue();
 
   if (is_server_ && encryption_level_ == ENCRYPTION_NONE &&
-      last_size_ > packet_creator_.max_packet_length()) {
-    packet_creator_.set_max_packet_length(last_size_);
+      last_size_ > packet_generator_.max_packet_length()) {
+    packet_generator_.set_max_packet_length(last_size_);
   }
   return true;
 }
 
 void QuicConnection::WriteQueuedPackets() {
   DCHECK(!writer_->IsWriteBlocked());
 
   if (pending_version_negotiation_packet_) {
     SendVersionNegotiationPacket();
   }
@@ skipping 24 matching lines @@
     }
 
     // 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 creator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
     Flush();
-    SerializedPacket serialized_packet = packet_creator_.ReserializeAllFrames(
+    SerializedPacket serialized_packet = packet_generator_.ReserializeAllFrames(
         pending.retransmittable_frames.frames(),
         pending.sequence_number_length);
 
     DVLOG(1) << ENDPOINT << "Retransmitting " << pending.sequence_number
              << " as " << serialized_packet.sequence_number;
     if (debug_visitor_) {
       debug_visitor_->OnPacketRetransmitted(
           pending.sequence_number, serialized_packet.sequence_number);
     }
     sent_packet_manager_.OnRetransmittedPacket(
@@ skipping 103 matching lines @@
     // Return true to stop processing.
     if (writer_->IsWriteBlocked()) {
       visitor_->OnWriteBlocked();
       return true;
     }
   } else {
     encrypted_deleter.reset(encrypted);
   }
 
   LOG_IF(DFATAL, encrypted->length() >
-                 packet_creator_.max_packet_length())
+         packet_generator_.max_packet_length())
       << "Writing an encrypted packet larger than max_packet_length:"
-      << packet_creator_.max_packet_length() << " encrypted length: "
+      << packet_generator_.max_packet_length() << " encrypted length: "
       << encrypted->length();
   DVLOG(1) << ENDPOINT << "Sending packet " << sequence_number
            << " : " << (packet.packet->is_fec_packet() ? "FEC " :
                (packet.retransmittable == HAS_RETRANSMITTABLE_DATA
                     ? "data bearing " : " ack only "))
            << ", encryption level: "
            << QuicUtils::EncryptionLevelToString(packet.encryption_level)
            << ", length:" << packet.packet->length() << ", encrypted length:"
            << encrypted->length();
   DVLOG(2) << ENDPOINT << "packet(" << sequence_number << "): " << std::endl
@@ skipping 107 matching lines @@
   QuicTime now = clock_->Now();
   if (transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = now;
   }
   SetPingAlarm();
   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.
-  packet_creator_.UpdateSequenceNumberLength(
+  packet_generator_.UpdateSequenceNumberLength(
       received_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.GetCongestionWindow());
 
   bool reset_retransmission_alarm =
       sent_packet_manager_.OnPacketSent(sequence_number, now, length,
                                         transmission_type, retransmittable);
 
   if (reset_retransmission_alarm || !retransmission_alarm_->IsSet()) {
     retransmission_alarm_->Cancel();
     QuicTime retransmission_time = sent_packet_manager_.GetRetransmissionTime();
@@ skipping 60 matching lines @@
   if (retransmission_alarm_->IsSet()) {
     return;
   }
   if (version() <= QUIC_VERSION_17) {
     // TODO(rch): remove this when we remove version 17.
     // This is a horrible hideous hack which we should not support.
     IOVector data;
     char c_data[] = "C";
     data.Append(c_data, 1);
     QuicConsumedData consumed_data =
-        packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false, NULL);
+        packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false,
+                                      MAY_FEC_PROTECT, NULL);
     if (consumed_data.bytes_consumed == 0) {
       DLOG(ERROR) << "Unable to send ping!?";
     }
   } else {
     packet_generator_.AddControlFrame(QuicFrame(new QuicPingFrame));
   }
 }
 
 void QuicConnection::SendAck() {
   ack_alarm_->Cancel();
@@ skipping 41 matching lines @@
                                   QuicEncrypter* encrypter) {
   framer_.SetEncrypter(level, encrypter);
 }
 
 const QuicEncrypter* QuicConnection::encrypter(EncryptionLevel level) const {
   return framer_.encrypter(level);
 }
 
 void QuicConnection::SetDefaultEncryptionLevel(EncryptionLevel level) {
   encryption_level_ = level;
-  packet_creator_.set_encryption_level(level);
+  packet_generator_.set_encryption_level(level);
 }
 
 void QuicConnection::SetDecrypter(QuicDecrypter* decrypter,
                                   EncryptionLevel level) {
   framer_.SetDecrypter(decrypter, level);
 }
 
 void QuicConnection::SetAlternativeDecrypter(QuicDecrypter* decrypter,
                                              EncryptionLevel level,
                                              bool latch_once_used) {
@@ skipping 170 matching lines @@
     QuicFecGroup* fec_group = it->second;
     DCHECK(!fec_group->CanRevive());
     FecGroupMap::iterator next = it;
     ++next;
     group_map_.erase(it);
     delete fec_group;
     it = next;
   }
 }
 
+size_t QuicConnection::max_packet_length() const {
+  return packet_generator_.max_packet_length();
+}
+
+void QuicConnection::set_max_packet_length(size_t length) {
+  return packet_generator_.set_max_packet_length(length);
+}
+
 void QuicConnection::Flush() {
   packet_generator_.FlushAllQueuedFrames();
 }
 
 bool QuicConnection::HasQueuedData() const {
   return pending_version_negotiation_packet_ ||
       !queued_packets_.empty() || packet_generator_.HasQueuedFrames();
 }
 
 bool QuicConnection::CanWriteStreamData() {
@@ skipping 126 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