Queueing QUIC frames to be resent instead of packets and packing RST frames with acks and congestio…

net/quic/quic_framer.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_framer.h"
 
 #include "base/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 33 matching lines @@
   QuicPacket* packet =
       ConstructMaxFrameDataPacket(header, frames, &num_consumed);
   DCHECK_EQ(frames.size(), num_consumed);
   return packet;
 }
 
 QuicPacket* QuicFramer::ConstructMaxFrameDataPacket(
     const QuicPacketHeader& header,
     const QuicFrames& frames,
     size_t* num_consumed) {
+  DCHECK(!frames.empty());
   // Compute the length of the packet.  We use "magic numbers" here because
   // sizeof(member_) is not necessarily the same as sizeof(member_wire_format).
   const size_t max_plaintext_size = GetMaxPlaintextSize(kMaxPacketSize);
   size_t len = kPacketHeaderSize;
   len += 1;  // frame count
   bool truncating = false;
   for (size_t i = 0; i < frames.size(); ++i) {
     size_t frame_len = 1;  // Space for the 8 bit type.
     frame_len += ComputeFramePayloadLength(frames[i]);
     if (len + frame_len > max_plaintext_size) {
@@ skipping 18 matching lines @@
     *num_consumed = i + 1;
   }
 
   QuicDataWriter writer(len);
 
   if (!WritePacketHeader(header, &writer)) {
     return NULL;
   }
 
   // frame count
-  if (frames.size() > 256u) {
+  if (*num_consumed > 256u) {
     return NULL;
   }
   if (!writer.WriteUInt8(*num_consumed)) {
     return NULL;
   }
 
   for (size_t i = 0; i < *num_consumed; ++i) {
     const QuicFrame& frame = frames[i];
     if (!writer.WriteUInt8(frame.type)) {
           return NULL;
@@ skipping 498 matching lines @@
 
   if (!ProcessAckFrame(&frame.ack_frame)) {
     DLOG(WARNING) << "Unable to process ack frame.";
     return false;
   }
 
   visitor_->OnConnectionCloseFrame(frame);
   return true;
 }
 
-void QuicFramer::WriteSequenceNumber(QuicPacketSequenceNumber sequence_number,
-                                     QuicPacket* packet) {
-  QuicDataWriter::WriteUint48ToBuffer(
-      sequence_number, packet->mutable_data() + kSequenceNumberOffset);
-}
-
-void QuicFramer::WriteFecGroup(QuicFecGroupNumber fec_group,
-                               QuicPacket* packet) {
-  QuicDataWriter::WriteUint8ToBuffer(
-      fec_group, packet->mutable_data() + kFecGroupOffset);
-}
-
 QuicEncryptedPacket* QuicFramer::EncryptPacket(const QuicPacket& packet) {
   scoped_ptr<QuicData> out(encrypter_->Encrypt(packet.AssociatedData(),
                                                packet.Plaintext()));
   if (out.get() == NULL) {
     RaiseError(QUIC_ENCRYPTION_FAILURE);
     return NULL;
   }
   size_t len = kStartOfEncryptedData + out->length();
   char* buffer = new char[len];
   // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt().
@@ skipping 301 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net