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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 51 matching lines @@
   return delta <= kMaxPacketGap;
 }
 
 }  // namespace
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicConnection::QuicConnection(QuicGuid guid,
                                IPEndPoint address,
                                QuicConnectionHelperInterface* helper,
-                               bool is_server)
-    : framer_(kQuicVersion1,
+                               bool is_server,
+                               QuicVersion version)
+    : framer_(version,
               helper->GetClock()->ApproximateNow(),
               is_server),
       helper_(helper),
       encryption_level_(ENCRYPTION_NONE),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       guid_(guid),
       peer_address_(address),
       largest_seen_packet_with_ack_(0),
       peer_largest_observed_packet_(0),
@@ skipping 15 matching lines @@
       version_negotiation_state_(START_NEGOTIATION),
       max_packets_per_retransmission_alarm_(kMaxPacketsPerRetransmissionAlarm),
       is_server_(is_server),
       connected_(true),
       received_truncated_ack_(false),
       send_ack_in_response_to_packet_(false),
       address_migrating_(false) {
   helper_->SetConnection(this);
   helper_->SetTimeoutAlarm(idle_network_timeout_);
   framer_.set_visitor(this);
-  framer_.set_entropy_calculator(&entropy_manager_);
+  framer_.set_received_entropy_calculator(&received_entropy_manager_);
   outgoing_ack_.sent_info.least_unacked = 0;
   outgoing_ack_.sent_info.entropy_hash = 0;
   outgoing_ack_.received_info.largest_observed = 0;
   outgoing_ack_.received_info.entropy_hash = 0;
 
   /*
   if (FLAGS_fake_packet_loss_percentage > 0) {
     int32 seed = RandomBase::WeakSeed32();
     LOG(INFO) << ENDPOINT << "Seeding packet loss with " << seed;
     random_.reset(new MTRandom(seed));
   }
   */
 }
 
 QuicConnection::~QuicConnection() {
   STLDeleteElements(&undecryptable_packets_);
   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_;
 }
 
 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;
+    const QuicVersionVector& available_versions) {
+  // Try to find the highest mutual version by iterating over supported
+  // versions, starting with the highest, and breaking out of the loop once we
+  // find a matching version in the provided available_versions vector.
+  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
+    const QuicVersion& version = kSupportedQuicVersions[i];
+    if (std::find(available_versions.begin(), available_versions.end(),
+                  version) != available_versions.end()) {
+      framer_.set_version(version);
+      return true;
+    }
   }
 
-  // Right now we only support kQuicVersion1 so it's okay not to
-  // update the framer version. When we start supporting more
-  // versions please update.
-  return true;
+  return false;
 }
 
 void QuicConnection::OnError(QuicFramer* framer) {
   // Packets that we cannot decrypt are dropped.
   // TODO(rch): add stats to measure this.
   if (!connected_ || framer->error() == QUIC_DECRYPTION_FAILURE) {
     return;
   }
   SendConnectionClose(framer->error());
 }
 
 void QuicConnection::OnPacket() {
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   if (debug_visitor_) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 }
 
-bool QuicConnection::OnProtocolVersionMismatch(QuicTag received_version) {
+bool QuicConnection::OnProtocolVersionMismatch(QuicVersion received_version) {
   // TODO(satyamshekhar): Implement no server state in this mode.
   if (!is_server_) {
     LOG(DFATAL) << ENDPOINT << "Framer called OnProtocolVersionMismatch. "
                 << "Closing connection.";
     CloseConnection(QUIC_INTERNAL_ERROR, false);
     return false;
   }
   DCHECK_NE(version(), received_version);
 
   if (debug_visitor_) {
@@ skipping 18 matching lines @@
 
     case NEGOTIATED_VERSION:
       // Might be old packets that were sent by the client before the version
       // was negotiated. Drop these.
       return false;
 
     default:
       DCHECK(false);
   }
 
-  // Right now we only support kQuicVersion1 so it's okay not to
-  // update the framer version. When we start supporting more
-  // versions please update.
   version_negotiation_state_ = NEGOTIATED_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;
 }
 
 // Handles version negotiation for client connection.
 void QuicConnection::OnVersionNegotiationPacket(
     const QuicVersionNegotiationPacket& packet) {
   if (is_server_) {
@@ skipping 179 matching lines @@
                 << packet_creator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
   if (incoming_ack.received_info.largest_observed <
       peer_largest_observed_packet_) {
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
                 << incoming_ack.received_info.largest_observed << " vs "
                 << peer_largest_observed_packet_;
-    // We got an error for data we have not sent.  Error out.
+    // A new ack has a diminished largest_observed value.  Error out.
+    // If this was an old packet, we wouldn't even have checked.
     return false;
   }
 
   // We can't have too many unacked packets, or our ack frames go over
   // kMaxPacketSize.
   DCHECK_LE(incoming_ack.received_info.missing_packets.size(),
             QuicFramer::GetMaxUnackedPackets(last_header_));
 
   if (incoming_ack.sent_info.least_unacked < peer_least_packet_awaiting_ack_) {
     DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
@@ skipping 25 matching lines @@
   if (!incoming_ack.received_info.missing_packets.empty() &&
       *incoming_ack.received_info.missing_packets.begin() <
       least_packet_awaited_by_peer_) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
                 << *incoming_ack.received_info.missing_packets.begin()
                 << "smaller than least_packet_awaited_by_peer_: "
                 << least_packet_awaited_by_peer_;
     return false;
   }
 
-  if (!entropy_manager_.IsValidEntropy(
+  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;
   }
 
   return true;
 }
 
@@ skipping 69 matching lines @@
             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);
+  sent_entropy_manager_.ClearEntropyBefore(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);
   }
 }
 
@@ skipping 14 matching lines @@
   DCHECK_LE(peer_least_packet_awaiting_ack_,
             incoming_ack.sent_info.least_unacked);
   if (incoming_ack.sent_info.least_unacked > peer_least_packet_awaiting_ack_) {
     bool missed_packets =
         DontWaitForPacketsBefore(incoming_ack.sent_info.least_unacked);
     if (missed_packets || incoming_ack.sent_info.least_unacked >
         outgoing_ack_.received_info.largest_observed + 1) {
       DVLOG(1) << ENDPOINT << "Updating entropy hashed since we missed packets";
       // There were some missing packets that we won't ever get now. Recalculate
       // the received entropy hash.
-      entropy_manager_.RecalculateReceivedEntropyHash(
+      received_entropy_manager_.RecalculateEntropyHash(
           incoming_ack.sent_info.least_unacked,
           incoming_ack.sent_info.entropy_hash);
     }
     peer_least_packet_awaiting_ack_ = incoming_ack.sent_info.least_unacked;
   }
   DCHECK(outgoing_ack_.received_info.missing_packets.empty() ||
          *outgoing_ack_.received_info.missing_packets.begin() >=
              peer_least_packet_awaiting_ack_);
   // Possibly close any FecGroups which are now irrelevant
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
@@ skipping 97 matching lines @@
     SendAck();
   } else if (!last_stream_frames_.empty()) {
     // TODO(alyssar) this case should really be "if the packet contained any
     // non-ack frame", rather than "if the packet contained a stream frame"
     helper_->SetAckAlarm(congestion_manager_.DefaultRetransmissionTime());
   }
   send_ack_in_response_to_packet_ = !send_ack_in_response_to_packet_;
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
-  QuicTagVector supported_versions;
-  supported_versions.push_back(kQuicVersion1);
+  QuicVersionVector supported_versions;
+  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
+    supported_versions.push_back(kSupportedQuicVersions[i]);
+  }
   QuicEncryptedPacket* encrypted =
       packet_creator_.SerializeVersionNegotiationPacket(supported_versions);
   // TODO(satyamshekhar): implement zero server state negotiation.
   int error;
   helper_->WritePacketToWire(*encrypted, &error);
   delete encrypted;
 }
 
 QuicConsumedData QuicConnection::SendStreamData(QuicStreamId id,
                                                 base::StringPiece data,
@@ skipping 145 matching lines @@
     DVLOG(1) << ENDPOINT << "Removing " << sequence_number
              << " from missing list";
     outgoing_ack_.received_info.missing_packets.erase(sequence_number);
   }
   if (header.packet_sequence_number >
       outgoing_ack_.received_info.largest_observed) {
     outgoing_ack_.received_info.largest_observed =
         header.packet_sequence_number;
     time_largest_observed_ = time_of_last_received_packet_;
   }
-  entropy_manager_.RecordReceivedPacketEntropyHash(sequence_number,
-                                                   header.entropy_hash);
+  received_entropy_manager_.RecordPacketEntropyHash(
+      sequence_number, header.entropy_hash);
 }
 
 bool QuicConnection::MaybeRetransmitPacketForRTO(
     QuicPacketSequenceNumber sequence_number) {
   DCHECK_EQ(ContainsKey(unacked_packets_, sequence_number),
             ContainsKey(retransmission_map_, sequence_number));
 
   if (!ContainsKey(unacked_packets_, sequence_number)) {
     DVLOG(2) << ENDPOINT << "alarm fired for " << sequence_number
              << " but it has been acked or already retransmitted with"
@@ skipping 274 matching lines @@
   return true;
 }
 
 int QuicConnection::WritePacketToWire(QuicPacketSequenceNumber sequence_number,
                                       EncryptionLevel level,
                                       const QuicEncryptedPacket& packet,
                                       int* error) {
   int bytes_written = helper_->WritePacketToWire(packet, error);
   if (debug_visitor_) {
     // WritePacketToWire returned -1, then |error| will be populated with
-    // a NetErrorCode, which we want to pass along to the visitor.
+    // an error code, which we want to pass along to the visitor.
     debug_visitor_->OnPacketSent(sequence_number, level, packet,
                                  bytes_written == -1 ? *error : bytes_written);
   }
   return bytes_written;
 }
 
 bool QuicConnection::OnSerializedPacket(
     const SerializedPacket& serialized_packet) {
   if (serialized_packet.retransmittable_frames != NULL) {
     DCHECK(unacked_packets_.empty() ||
@@ skipping 22 matching lines @@
                            serialized_packet.retransmittable_frames != NULL ?
                                HAS_RETRANSMITTABLE_DATA :
                                NO_RETRANSMITTABLE_DATA);
 }
 
 bool QuicConnection::SendOrQueuePacket(EncryptionLevel level,
                                        QuicPacketSequenceNumber sequence_number,
                                        QuicPacket* packet,
                                        QuicPacketEntropyHash entropy_hash,
                                        HasRetransmittableData retransmittable) {
-  entropy_manager_.RecordSentPacketEntropyHash(sequence_number, entropy_hash);
+  sent_entropy_manager_.RecordPacketEntropyHash(sequence_number, entropy_hash);
   if (!WritePacket(level, sequence_number, packet, retransmittable, NO_FORCE)) {
     queued_packets_.push_back(QueuedPacket(sequence_number, packet, level,
                                            retransmittable));
     return false;
   }
   return true;
 }
 
 bool QuicConnection::ShouldSimulateLostPacket() {
   // TODO(rch): enable this
   return false;
   /*
   return FLAGS_fake_packet_loss_percentage > 0 &&
       random_->Rand32() % 100 < FLAGS_fake_packet_loss_percentage;
   */
 }
 
 void QuicConnection::UpdateOutgoingAck() {
   if (!unacked_packets_.empty()) {
     outgoing_ack_.sent_info.least_unacked = unacked_packets_.begin()->first;
   } else {
     // If there are no unacked packets, set the least unacked packet to
     // sequence_number() + 1 since that will be the sequence number of this
     // ack packet whenever it is sent.
     outgoing_ack_.sent_info.least_unacked =
         packet_creator_.sequence_number() + 1;
   }
-  outgoing_ack_.sent_info.entropy_hash = entropy_manager_.SentEntropyHash(
+  outgoing_ack_.sent_info.entropy_hash = sent_entropy_manager_.EntropyHash(
       outgoing_ack_.sent_info.least_unacked - 1);
   outgoing_ack_.received_info.entropy_hash =
-      entropy_manager_.ReceivedEntropyHash(
+      received_entropy_manager_.EntropyHash(
           outgoing_ack_.received_info.largest_observed);
 }
 
 void QuicConnection::SendAck() {
   helper_->ClearAckAlarm();
   UpdateOutgoingAck();
   DVLOG(1) << ENDPOINT << "Sending ack: " << outgoing_ack_;
 
   // TODO(rch): delay this until the CreateFeedbackFrame
   // method is invoked.  This requires changes SetShouldSendAck
@@ skipping 191 matching lines @@
              << details;
   QuicConnectionCloseFrame frame;
   frame.error_code = error;
   frame.error_details = details;
   UpdateOutgoingAck();
   frame.ack_frame = outgoing_ack_;
 
   SerializedPacket serialized_packet =
       packet_creator_.SerializeConnectionClose(&frame);
 
-  // We need to update the sent entrophy hash for all sent packets.
-  entropy_manager_.RecordSentPacketEntropyHash(
+  // We need to update the sent entropy hash for all sent packets.
+  sent_entropy_manager_.RecordPacketEntropyHash(
       serialized_packet.sequence_number,
       serialized_packet.entropy_hash);
 
   WritePacket(encryption_level_,
               serialized_packet.sequence_number,
               serialized_packet.packet,
               serialized_packet.retransmittable_frames != NULL ?
                   HAS_RETRANSMITTABLE_DATA : NO_RETRANSMITTABLE_DATA,
               FORCE);
 }
@@ skipping 103 matching lines @@
     if (connection_timeout < timeout) {
       timeout = connection_timeout;
     }
   }
 
   helper_->SetTimeoutAlarm(timeout);
   return false;
 }
 
 }  // namespace net