Landing Recent QUIC changes until Sun Sep 4 03:41:00

net/quic/core/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/core/quic_packet_creator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 375 matching lines @@
   packet_.listeners.clear();
 }
 
 void QuicPacketCreator::CreateAndSerializeStreamFrame(
     QuicStreamId id,
     const QuicIOVector& iov,
     QuicStreamOffset iov_offset,
     QuicStreamOffset stream_offset,
     bool fin,
     QuicAckListenerInterface* listener,
-    char* encrypted_buffer,
-    size_t encrypted_buffer_len,
     size_t* num_bytes_consumed) {
   DCHECK(queued_frames_.empty());
   // Write out the packet header
   QuicPacketHeader header;
   FillPacketHeader(&header);
-  QuicDataWriter writer(kMaxPacketSize, encrypted_buffer);
+  ALIGNAS(64) char encrypted_buffer[kMaxPacketSize];
+  QuicDataWriter writer(arraysize(encrypted_buffer), encrypted_buffer);
   if (!framer_->AppendPacketHeader(header, &writer)) {
     QUIC_BUG << "AppendPacketHeader failed";
     return;
   }
 
   // Create a Stream frame with the remaining space.
   QUIC_BUG_IF(iov_offset == iov.total_length && !fin)
       << "Creating a stream frame with no data or fin.";
   const size_t remaining_data_size = iov.total_length - iov_offset;
   const size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
@@ skipping 20 matching lines @@
   }
   if (!framer_->AppendStreamFrame(*frame, /* no stream frame length */ true,
                                   &writer)) {
     QUIC_BUG << "AppendStreamFrame failed";
     return;
   }
 
   size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.path_id, packet_.packet_number,
       GetStartOfEncryptedData(framer_->version(), header), writer.length(),
-      encrypted_buffer_len, encrypted_buffer);
+      arraysize(encrypted_buffer), encrypted_buffer);
   if (encrypted_length == 0) {
     QUIC_BUG << "Failed to encrypt packet number " << header.packet_number;
     return;
   }
   // TODO(ianswett): Optimize the storage so RetransmitableFrames can be
   // unioned with a QuicStreamFrame and a UniqueStreamBuffer.
   *num_bytes_consumed = bytes_consumed;
   packet_size_ = 0;
   packet_.entropy_hash = QuicFramer::GetPacketEntropyHash(header);
   packet_.encrypted_buffer = encrypted_buffer;
@@ skipping 150 matching lines @@
     case MTU_DISCOVERY_FRAME:
       return false;
     default:
       return true;
   }
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
                                  bool save_retransmittable_frames) {
   DVLOG(1) << "Adding frame: " << frame;
-  if (FLAGS_quic_never_write_unencrypted_data && frame.type == STREAM_FRAME &&
+  if (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;
   }
   if (!FLAGS_quic_simple_packet_number_length_2) {
@@ skipping 93 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