Change QuicFramer so it accepts a QuicDataWriter rather than allocating

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 "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
+#include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::pair;
 using std::vector;
 
@@ skipping 269 matching lines @@
 
 // TODO(ianswett): Remove this method, because it's test only.
 SerializedPacket QuicPacketCreator::SerializeAllFrames(
     const QuicFrames& frames) {
   // TODO(satyamshekhar): Verify that this DCHECK won't fail. What about queued
   // frames from SendStreamData()[send_stream_should_flush_ == false &&
   // data.empty() == true] and retransmit due to RTO.
   DCHECK_EQ(0u, queued_frames_.size());
   LOG_IF(DFATAL, frames.empty())
       << "Attempt to serialize empty packet";
-  for (size_t i = 0; i < frames.size(); ++i) {
-    bool success = AddFrame(frames[i], false);
+  for (const QuicFrame& frame : frames) {
+    bool success = AddFrame(frame, false);
     DCHECK(success);
   }
   SerializedPacket packet = SerializePacket();
   DCHECK(packet.retransmittable_frames == nullptr);
   return packet;
 }
 
 bool QuicPacketCreator::HasPendingFrames() const {
   return !queued_frames_.empty();
 }
@@ skipping 53 matching lines @@
   size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(max_packet_length_);
   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;
-  scoped_ptr<QuicPacket> packet(
-      framer_->BuildDataPacket(header, queued_frames_, packet_size_));
+  char buffer[kMaxPacketSize];
+  scoped_ptr<QuicPacket> packet;
+  // Use the packet_size_ instead of the buffer size to ensure smaller
+  // packet sizes are properly used.
+  scoped_ptr<char[]> large_buffer;
+  if (packet_size_ <= kMaxPacketSize) {
+    packet.reset(
+        framer_->BuildDataPacket(header, queued_frames_, buffer, packet_size_));
+  } else {
+    large_buffer.reset(new char[packet_size_]);
+    packet.reset(framer_->BuildDataPacket(header, queued_frames_,
+                                          large_buffer.get(), packet_size_));
+  }
   LOG_IF(DFATAL, packet == nullptr) << "Failed to serialize "
                                     << queued_frames_.size() << " frames.";
   // 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_, packet->length());
   }
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // sequence number multiple times.
   QuicEncryptedPacket* encrypted =
@@ skipping 155 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net