Landing recent QUIC changes until 6/24/2016 14:00 UTC

net/quic/quic_packet_creator.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_packet_creator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 27 matching lines @@
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       send_path_id_in_packet_(false),
       next_packet_number_length_(PACKET_1BYTE_PACKET_NUMBER),
       have_diversification_nonce_(false),
       max_packet_length_(0),
       connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
       packet_size_(0),
       connection_id_(connection_id),
       packet_(kDefaultPathId,
               0,
-              next_packet_number_length_,
+              PACKET_1BYTE_PACKET_NUMBER,
               nullptr,
               0,
               0,
               false,
               false) {
   SetMaxPacketLength(kDefaultMaxPacketSize);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
   QuicUtils::DeleteFrames(&packet_.retransmittable_frames);
@@ skipping 17 matching lines @@
   // change.
   if (length == max_packet_length_) {
     return;
   }
 
   max_packet_length_ = length;
   max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
 }
 
 void QuicPacketCreator::MaybeUpdatePacketNumberLength() {
+  DCHECK(!FLAGS_quic_simple_packet_number_length);
   if (!queued_frames_.empty()) {
     // Don't change creator state if there are frames queued.
     return;
   }
 
   // Update packet number length only on packet boundary.
   packet_.packet_number_length = next_packet_number_length_;
 }
 
 // Stops serializing version of the protocol in packets sent after this call.
@@ skipping 11 matching lines @@
 void QuicPacketCreator::SetDiversificationNonce(
     const DiversificationNonce nonce) {
   DCHECK(!have_diversification_nonce_);
   have_diversification_nonce_ = true;
   memcpy(&diversification_nonce_, nonce, sizeof(diversification_nonce_));
 }
 
 void QuicPacketCreator::UpdatePacketNumberLength(
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
+  if (FLAGS_quic_simple_packet_number_length && !queued_frames_.empty()) {
+    // Don't change creator state if there are frames queued.
+    QUIC_BUG << "Called UpdatePacketNumberLength with " << queued_frames_.size()
+             << " queued_frames.";
+    return;
+  }
+
   DCHECK_LE(least_packet_awaited_by_peer, packet_.packet_number + 1);
   const QuicPacketNumber current_delta =
       packet_.packet_number + 1 - least_packet_awaited_by_peer;
   const uint64_t delta = max(current_delta, max_packets_in_flight);
-  next_packet_number_length_ =
-      QuicFramer::GetMinSequenceNumberLength(delta * 4);
+  if (FLAGS_quic_simple_packet_number_length) {
+    packet_.packet_number_length =
+        QuicFramer::GetMinSequenceNumberLength(delta * 4);
+  } else {
+    next_packet_number_length_ =
+        QuicFramer::GetMinSequenceNumberLength(delta * 4);
+  }
 }
 
 bool QuicPacketCreator::ConsumeData(QuicStreamId id,
                                     QuicIOVector iov,
                                     size_t iov_offset,
                                     QuicStreamOffset offset,
                                     bool fin,
                                     bool needs_full_padding,
                                     QuicFrame* frame) {
   if (!HasRoomForStreamFrame(id, offset)) {
     return false;
   }
   CreateStreamFrame(id, iov, iov_offset, offset, fin, frame);
   // Explicitly disallow multi-packet CHLOs.
-  if (FLAGS_quic_disallow_multi_packet_chlo && id == kCryptoStreamId &&
+  if (id == kCryptoStreamId &&
       frame->stream_frame->data_length >= sizeof(kCHLO) &&
       strncmp(frame->stream_frame->data_buffer,
               reinterpret_cast<const char*>(&kCHLO), sizeof(kCHLO)) == 0) {
     DCHECK_EQ(static_cast<size_t>(0), iov_offset);
     if (frame->stream_frame->data_length < iov.iov->iov_len) {
       const string error_details = "Client hello won't fit in a single packet.";
       QUIC_BUG << error_details << " Constructed stream frame length: "
                << frame->stream_frame->data_length
                << " CHLO length: " << iov.iov->iov_len;
       delegate_->OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, error_details,
@@ skipping 39 matching lines @@
                                           size_t iov_offset,
                                           QuicStreamOffset offset,
                                           bool fin,
                                           QuicFrame* frame) {
   DCHECK_GT(max_packet_length_,
             StreamFramePacketOverhead(framer_->version(), connection_id_length_,
                                       kIncludeVersion, kIncludePathId,
                                       IncludeNonceInPublicHeader(),
                                       PACKET_6BYTE_PACKET_NUMBER, offset));
 
-  MaybeUpdatePacketNumberLength();
-
-  LOG_IF(DFATAL, !HasRoomForStreamFrame(id, offset))
+  if (!FLAGS_quic_simple_packet_number_length) {
+    MaybeUpdatePacketNumberLength();
+  }
+  QUIC_BUG_IF(!HasRoomForStreamFrame(id, offset))
       << "No room for Stream frame, BytesFree: " << BytesFree()
       << " MinStreamFrameSize: "
       << QuicFramer::GetMinStreamFrameSize(id, offset, true);
 
   if (iov_offset == iov.total_length) {
     QUIC_BUG_IF(!fin) << "Creating a stream frame with no data or fin.";
     // Create a new packet for the fin, if necessary.
     *frame = QuicFrame(new QuicStreamFrame(id, true, offset, StringPiece()));
     return;
   }
@@ skipping 71 matching lines @@
   DCHECK(queued_frames_.empty());
   DCHECK_EQ(0, packet_.num_padding_bytes);
   QUIC_BUG_IF(retransmission.retransmittable_frames.empty())
       << "Attempt to serialize empty packet";
   const QuicPacketNumberLength saved_length = packet_.packet_number_length;
   const QuicPacketNumberLength saved_next_length = next_packet_number_length_;
   const EncryptionLevel default_encryption_level = packet_.encryption_level;
 
   // Temporarily set the packet number length and change the encryption level.
   packet_.packet_number_length = retransmission.packet_number_length;
-  next_packet_number_length_ = retransmission.packet_number_length;
+  if (!FLAGS_quic_simple_packet_number_length) {
+    next_packet_number_length_ = retransmission.packet_number_length;
+  }
   packet_.num_padding_bytes = retransmission.num_padding_bytes;
   // Only preserve the original encryption level if it's a handshake packet or
   // if we haven't gone forward secure.
   if (retransmission.has_crypto_handshake ||
       packet_.encryption_level != ENCRYPTION_FORWARD_SECURE) {
     packet_.encryption_level = retransmission.encryption_level;
   }
 
   // Serialize the packet and restore packet number length state.
   for (const QuicFrame& frame : retransmission.retransmittable_frames) {
     bool success = AddFrame(frame, false);
-    DCHECK(success);
+    LOG_IF(DFATAL, !success)
+        << " Failed to add frame of type:" << frame.type
+        << " num_frames:" << retransmission.retransmittable_frames.size()
+        << " retransmission.packet_number_length:"
+        << retransmission.packet_number_length
+        << " packet_.packet_number_length:" << packet_.packet_number_length;
   }
   SerializePacket(buffer, buffer_len);
   packet_.original_path_id = retransmission.path_id;
   packet_.original_packet_number = retransmission.packet_number;
   packet_.transmission_type = retransmission.transmission_type;
   OnSerializedPacket();
   // Restore old values.
-  packet_.packet_number_length = saved_length;
-  next_packet_number_length_ = saved_next_length;
+  if (!FLAGS_quic_simple_packet_number_length) {
+    // OnSerializedPacket updates the packet_number_length, so it's incorrect to
+    // restore it here.
+    packet_.packet_number_length = saved_length;
+    next_packet_number_length_ = saved_next_length;
+  }
   packet_.encryption_level = default_encryption_level;
 }
 
 void QuicPacketCreator::Flush() {
   if (!HasPendingFrames()) {
     return;
   }
 
   // TODO(rtenneti): Change the default 64 alignas value (used the default
   // value from CACHELINE_SIZE).
@@ skipping 128 matching lines @@
   DCHECK_GE(max_plaintext_size_, PacketSize());
   return max_plaintext_size_ -
          min(max_plaintext_size_, PacketSize() + ExpansionOnNewFrame());
 }
 
 size_t QuicPacketCreator::PacketSize() {
   if (!queued_frames_.empty()) {
     return packet_size_;
   }
   // Update packet number length on packet boundary.
-  packet_.packet_number_length = next_packet_number_length_;
+  if (!FLAGS_quic_simple_packet_number_length) {
+    packet_.packet_number_length = next_packet_number_length_;
+  }
   packet_size_ = GetPacketHeaderSize(
       framer_->version(), connection_id_length_, send_version_in_packet_,
       send_path_id_in_packet_, IncludeNonceInPublicHeader(),
       packet_.packet_number_length);
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, /*save_retransmittable_frames=*/true);
 }
@@ skipping 112 matching lines @@
   if (FLAGS_quic_never_write_unencrypted_data && frame.type == STREAM_FRAME &&
       frame.stream_frame->stream_id != kCryptoStreamId &&
       packet_.encryption_level == ENCRYPTION_NONE) {
     const string error_details = "Cannot send stream data without encryption.";
     QUIC_BUG << error_details;
     delegate_->OnUnrecoverableError(
         QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA, error_details,
         ConnectionCloseSource::FROM_SELF);
     return false;
   }
-  MaybeUpdatePacketNumberLength();
-
+  if (!FLAGS_quic_simple_packet_number_length) {
+    MaybeUpdatePacketNumberLength();
+  }
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true,
       packet_.packet_number_length);
   if (frame_len == 0) {
     // Current open packet is full.
     Flush();
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
@@ skipping 81 matching lines @@
   if (bit_mask_ == 0) {
     bit_bucket_ = random_->RandUint64();
     bit_mask_ = 1;
   }
   bool result = ((bit_bucket_ & bit_mask_) != 0);
   bit_mask_ <<= 1;
   return result;
 }
 
 }  // namespace net