Landing Recent QUIC changes until 01/31/2016 05:22 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 84 matching lines @@
       next_packet_number_length_(PACKET_1BYTE_PACKET_NUMBER),
       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_,
               nullptr,
               0,
+              0,
               false,
               false),
       should_fec_protect_next_packet_(false),
       fec_protect_(false),
       max_packets_per_fec_group_(kDefaultMaxPacketsPerFecGroup),
       fec_send_policy_(FEC_ANY_TRIGGER),
       fec_timeout_(QuicTime::Delta::Zero()),
       rtt_multiplier_for_fec_timeout_(kRttMultiplierForFecTimeout) {
   SetMaxPacketLength(kDefaultMaxPacketSize);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
   QuicUtils::DeleteFrames(&packet_.retransmittable_frames);
-  if (packet_.packet != nullptr) {
-    delete packet_.packet;
-  }
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
     const QuicPacketHeader& header,
     StringPiece payload) {
   if (fec_group_.get() != nullptr) {
     DCHECK_NE(0u, header.fec_group);
     fec_group_->Update(packet_.encryption_level, header, payload);
   }
 }
@@ skipping 338 matching lines @@
   }
 
   // TODO(rtenneti): Change the default 64 alignas value (used the default
   // value from CACHELINE_SIZE).
   ALIGNAS(64) char seralized_packet_buffer[kMaxPacketSize];
   SerializePacket(seralized_packet_buffer, kMaxPacketSize);
   OnSerializedPacket();
 }
 
 void QuicPacketCreator::OnSerializedPacket() {
-  if (packet_.packet == nullptr) {
+  if (packet_.encrypted_buffer == nullptr) {
     QUIC_BUG << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
              << " should_fec_protect_:" << should_fec_protect_next_packet_;
     delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
     return;
   }
 
   delegate_->OnSerializedPacket(&packet_);
   ClearPacket();
   MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/false,
                                   /*is_fec_timeout=*/false);
   // Maximum packet size may be only enacted while no packet is currently being
   // constructed, so here we have a good opportunity to actually change it.
   if (CanSetMaxPacketLength()) {
     SetMaxPacketLength(max_packet_length_);
   }
 }
 
 void QuicPacketCreator::ClearPacket() {
   packet_.has_ack = false;
   packet_.has_stop_waiting = false;
   packet_.has_crypto_handshake = NOT_HANDSHAKE;
   packet_.needs_padding = false;
   packet_.is_fec_packet = false;
   packet_.original_packet_number = 0;
   packet_.transmission_type = NOT_RETRANSMISSION;
-  packet_.packet = nullptr;
+  packet_.encrypted_buffer = nullptr;
+  packet_.encrypted_length = 0;
   DCHECK(packet_.retransmittable_frames.empty());
   packet_.listeners.clear();
 }
 
 bool QuicPacketCreator::HasPendingFrames() const {
   return !queued_frames_.empty();
 }
 
 bool QuicPacketCreator::HasPendingRetransmittableFrames() const {
   return !packet_.retransmittable_frames.empty();
@@ skipping 101 matching lines @@
       packet_.encryption_level, packet_.path_id, packet_.packet_number, packet,
       encrypted_buffer, encrypted_buffer_len);
   if (encrypted_length == 0) {
     QUIC_BUG << "Failed to encrypt packet number " << packet_.packet_number;
     return;
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   packet_.entropy_hash = QuicFramer::GetPacketEntropyHash(header);
-  packet_.packet =
-      new QuicEncryptedPacket(encrypted_buffer, encrypted_length, false);
+  packet_.encrypted_buffer = encrypted_buffer;
+  packet_.encrypted_length = encrypted_length;
 }
 
 void QuicPacketCreator::SerializeFec(char* buffer, size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     QUIC_BUG << "SerializeFEC called but no group or zero packets in group.";
     return;
   }
   if (FLAGS_quic_no_unencrypted_fec &&
       packet_.encryption_level == ENCRYPTION_NONE) {
@@ skipping 14 matching lines @@
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // packet number multiple times.
   size_t encrypted_length = framer_->EncryptPayload(
       packet_.encryption_level, packet_.path_id, packet_.packet_number, *packet,
       buffer, buffer_len);
   if (encrypted_length == 0) {
     QUIC_BUG << "Failed to encrypt packet number " << packet_.packet_number;
     return;
   }
   packet_.entropy_hash = QuicFramer::GetPacketEntropyHash(header);
-  packet_.packet = new QuicEncryptedPacket(buffer, encrypted_length, false);
+  packet_.encrypted_buffer = buffer;
+  packet_.encrypted_length = encrypted_length;
   packet_.is_fec_packet = true;
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   QuicEncryptedPacket* encrypted = QuicFramer::BuildVersionNegotiationPacket(
       connection_id_, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
 }
 
 // TODO(jri): Make this a public method of framer?
 SerializedPacket QuicPacketCreator::NoPacket() {
   return SerializedPacket(kInvalidPathId, 0, PACKET_1BYTE_PACKET_NUMBER,
-                          nullptr, 0, false, false);
+                          nullptr, 0, 0, false, false);
 }
 
 void QuicPacketCreator::FillPacketHeader(QuicFecGroupNumber fec_group,
                                          bool fec_flag,
                                          QuicPacketHeader* header) {
   header->public_header.connection_id = connection_id_;
   header->public_header.connection_id_length = connection_id_length_;
   header->public_header.multipath_flag = send_path_id_in_packet_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
@@ skipping 164 matching lines @@
   packet_.packet_number = it == multipath_packet_number_.end() ? 0 : it->second;
   packet_.path_id = path_id;
   DCHECK(packet_.path_id != kInvalidPathId);
   // Send path in packet if current path is not the default path.
   send_path_id_in_packet_ = packet_.path_id != kDefaultPathId ? true : false;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net