Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

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/basictypes.h"
 #include "base/logging.h"
@@ skipping 58 matching lines @@
 
 QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator)
     : connection_id_(connection_id),
       encryption_level_(ENCRYPTION_NONE),
       framer_(framer),
       random_bool_source_(new QuicRandomBoolSource(random_generator)),
       packet_number_(0),
       should_fec_protect_(false),
-      fec_group_number_(0),
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       max_packet_length_(0),
       max_packets_per_fec_group_(kDefaultMaxPacketsPerFecGroup),
       connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
       next_packet_number_length_(PACKET_1BYTE_PACKET_NUMBER),
       packet_number_length_(next_packet_number_length_),
       packet_size_(0),
       needs_padding_(false) {
   SetMaxPacketLength(kDefaultMaxPacketSize);
 }
@@ skipping 33 matching lines @@
   max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
 }
 
 void QuicPacketCreator::set_max_packets_per_fec_group(
     size_t max_packets_per_fec_group) {
   max_packets_per_fec_group_ = max(kLowestMaxPacketsPerFecGroup,
                                    max_packets_per_fec_group);
   DCHECK_LT(0u, max_packets_per_fec_group_);
 }
 
+QuicFecGroupNumber QuicPacketCreator::fec_group_number() {
+  return fec_group_ != nullptr ? fec_group_->FecGroupNumber() : 0;
+}
+
 bool QuicPacketCreator::ShouldSendFec(bool force_close) const {
   DCHECK(!HasPendingFrames());
   return fec_group_.get() != nullptr && fec_group_->NumReceivedPackets() > 0 &&
          (force_close ||
           fec_group_->NumReceivedPackets() >= max_packets_per_fec_group_);
 }
 
 void QuicPacketCreator::ResetFecGroup() {
   if (HasPendingFrames()) {
     LOG_IF(DFATAL, packet_size_ != 0)
@@ skipping 25 matching lines @@
   should_fec_protect_ = true;
 }
 
 void QuicPacketCreator::StopFecProtectingPackets() {
   if (fec_group_.get() != nullptr) {
     LOG(DFATAL) << "Cannot stop FEC protection with open FEC group.";
     return;
   }
   DCHECK(should_fec_protect_);
   should_fec_protect_ = false;
-  fec_group_number_ = 0;
 }
 
 bool QuicPacketCreator::IsFecProtected() const {
   return should_fec_protect_;
 }
 
 bool QuicPacketCreator::IsFecEnabled() const {
   return max_packets_per_fec_group_ > 0;
 }
 
 InFecGroup QuicPacketCreator::MaybeUpdateLengthsAndStartFec() {
   if (fec_group_.get() != nullptr) {
     // Don't update any lengths when an FEC group is open, to ensure same
     // packet header size in all packets within a group.
     return IN_FEC_GROUP;
   }
   if (!queued_frames_.empty()) {
     // Don't change creator state if there are frames queued.
     return NOT_IN_FEC_GROUP;
   }
 
   // Update packet number length only on packet and FEC group boundaries.
   packet_number_length_ = next_packet_number_length_;
 
   if (!should_fec_protect_) {
     return NOT_IN_FEC_GROUP;
   }
   // Start a new FEC group since protection is on. Set the fec group number to
   // the packet number of the next packet.
-  fec_group_number_ = packet_number() + 1;
-  fec_group_.reset(new QuicFecGroup(fec_group_number_));
+  fec_group_.reset(new QuicFecGroup(packet_number_ + 1));
   return IN_FEC_GROUP;
 }
 
 // Stops serializing version of the protocol in packets sent after this call.
 // A packet that is already open might send kQuicVersionSize bytes less than the
 // maximum packet size if we stop sending version before it is serialized.
 void QuicPacketCreator::StopSendingVersion() {
   DCHECK(send_version_in_packet_);
   send_version_in_packet_ = false;
   if (packet_size_ > 0) {
@@ skipping 252 matching lines @@
                   /*save_retransmittable_frames=*/true,
                   /*needs_padding=*/true, buffer.Pass());
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket(
     char* encrypted_buffer,
     size_t encrypted_buffer_len) {
   DCHECK_LT(0u, encrypted_buffer_len);
   LOG_IF(DFATAL, queued_frames_.empty())
       << "Attempt to serialize empty packet";
-  DCHECK_GE(packet_number_ + 1, fec_group_number_);
+  if (fec_group_.get() != nullptr) {
+    DCHECK_GE(packet_number_ + 1, fec_group_->FecGroupNumber());
+  }
   QuicPacketHeader header;
-  FillPacketHeader(should_fec_protect_ ? fec_group_number_ : 0, false, &header);
+  // FillPacketHeader increments packet_number_.
+  FillPacketHeader(fec_group_number(), false, &header);
 
   MaybeAddPadding();
 
   DCHECK_GE(max_plaintext_size_, packet_size_);
   // ACK Frames will be truncated due to length only if they're the only frame
   // in the packet, and if packet_size_ was set to max_plaintext_size_. If
   // truncation due to length occurred, then GetSerializedFrameLength will have
   // returned all bytes free.
   bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
                                       queued_frames_.size() == 1 &&
                                       queued_frames_.back().type == ACK_FRAME;
   // The optimized encryption algorithm implementations run faster when
   // operating on aligned memory.
   // TODO(rtenneti): Change the default 64 alignas value (used the default
   // value from CACHELINE_SIZE).
   ALIGNAS(64) char buffer[kMaxPacketSize];
   // Use the packet_size_ instead of the buffer size to ensure smaller
   // packet sizes are properly used.
-  scoped_ptr<char[]> large_buffer;
-  size_t length = 0;
-  const bool use_stack_buffer = packet_size_ <= kMaxPacketSize;
-  if (use_stack_buffer) {
-    length =
-        framer_->BuildDataPacket(header, queued_frames_, buffer, packet_size_);
-  } else {
-    large_buffer.reset(new char[packet_size_]);
-    length = framer_->BuildDataPacket(header, queued_frames_,
-                                      large_buffer.get(), packet_size_);
-  }
+  size_t length =
+      framer_->BuildDataPacket(header, queued_frames_, buffer, packet_size_);
   if (length == 0) {
     LOG(DFATAL) << "Failed to serialize " << queued_frames_.size()
                 << " frames.";
     return NoPacket();
   }
 
   // TODO(ianswett) Consider replacing QuicPacket with something else,
   // since it's only used to provide convenience methods to FEC and encryption.
-  QuicPacket packet(use_stack_buffer ? buffer : large_buffer.get(), length,
+  QuicPacket packet(buffer, length,
                     /* owns_buffer */ false,
                     header.public_header.connection_id_length,
                     header.public_header.version_flag,
                     header.public_header.packet_number_length);
   OnBuiltFecProtectedPayload(header, packet.FecProtectedData());
 
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
   if (!possibly_truncated_by_length) {
     DCHECK_EQ(packet_size_, length);
   }
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // packet number multiple times.
-  QuicEncryptedPacket* encrypted =
+  size_t encrypted_length =
       framer_->EncryptPayload(encryption_level_, packet_number_, packet,
                               encrypted_buffer, encrypted_buffer_len);
-  if (encrypted == nullptr) {
+  if (encrypted_length == 0) {
     LOG(DFATAL) << "Failed to encrypt packet number " << packet_number_;
     return NoPacket();
   }
 
   // Update |needs_padding_| flag of |queued_retransmittable_frames_| here, and
   // not in AddFrame, because when the first padded frame is added to the queue,
   // it might not be retransmittable, and hence the flag would end up being not
   // set.
   if (queued_retransmittable_frames_.get() != nullptr) {
     queued_retransmittable_frames_->set_needs_padding(needs_padding_);
   }
 
   bool has_ack = false;
   bool has_stop_waiting = false;
   for (const QuicFrame& frame : queued_frames_) {
     has_ack |= frame.type == ACK_FRAME;
     has_stop_waiting |= frame.type == STOP_WAITING_FRAME;
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   needs_padding_ = false;
   return SerializedPacket(
       header.packet_number, header.public_header.packet_number_length,
-      encrypted, QuicFramer::GetPacketEntropyHash(header),
+      encrypted_buffer, encrypted_length, /* owns_buffer*/ false,
+      QuicFramer::GetPacketEntropyHash(header),
       queued_retransmittable_frames_.release(), has_ack, has_stop_waiting);
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec(char* buffer,
                                                  size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
     return NoPacket();
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
-  FillPacketHeader(fec_group_number_, true, &header);
+  FillPacketHeader(fec_group_->FecGroupNumber(), true, &header);
   scoped_ptr<QuicPacket> packet(
       framer_->BuildFecPacket(header, fec_group_->PayloadParity()));
   fec_group_.reset(nullptr);
   packet_size_ = 0;
   LOG_IF(DFATAL, packet == nullptr)
-      << "Failed to serialize fec packet for group:" << fec_group_number_;
+      << "Failed to serialize fec packet for group:"
+      << fec_group_->FecGroupNumber();
   DCHECK_GE(max_packet_length_, packet->length());
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // packet number multiple times.
-  QuicEncryptedPacket* encrypted = framer_->EncryptPayload(
+  size_t encrypted_length = framer_->EncryptPayload(
       encryption_level_, packet_number_, *packet, buffer, buffer_len);
-  if (encrypted == nullptr) {
+  if (encrypted_length == 0) {
     LOG(DFATAL) << "Failed to encrypt packet number " << packet_number_;
     return NoPacket();
   }
   SerializedPacket serialized(
-      header.packet_number, header.public_header.packet_number_length,
-      encrypted, QuicFramer::GetPacketEntropyHash(header), nullptr, false,
-      false);
+      header.packet_number, header.public_header.packet_number_length, buffer,
+      encrypted_length, /* owns_buffer */ false,
+      QuicFramer::GetPacketEntropyHash(header), nullptr, false, false);
   serialized.is_fec_packet = true;
   return serialized;
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   QuicPacketPublicHeader header;
   header.connection_id = connection_id_;
   header.reset_flag = false;
@@ skipping 80 matching lines @@
   if (BytesFree() == 0) {
     // Don't pad full packets.
     return;
   }
 
   bool success = AddFrame(QuicFrame(QuicPaddingFrame()), false, false, nullptr);
   DCHECK(success);
 }
 
 }  // namespace net