Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

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"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_utils.h"
 
 using base::hash_set;
 using base::StringPiece;
 
 namespace net {
 
 QuicFramer::QuicFramer(QuicDecrypter* decrypter, QuicEncrypter* encrypter)
     : visitor_(NULL),
       fec_builder_(NULL),
       error_(QUIC_NO_ERROR),
       decrypter_(decrypter),
       encrypter_(encrypter) {
 }
 
 QuicFramer::~QuicFramer() {}
 
-bool QuicFramer::ConstructFragementDataPacket(
+bool QuicFramer::ConstructFrameDataPacket(
     const QuicPacketHeader& header,
     const QuicFrames& frames,
     QuicPacket** packet) {
   // Compute the length of the packet.  We use "magic numbers" here because
   // sizeof(member_) is not necessairly the same as sizeof(member_wire_format).
   size_t len = kPacketHeaderSize;
   len += 1;  // frame count
   for (size_t i = 0; i < frames.size(); ++i) {
     len += 1;  // space for the 8 bit type
     len += ComputeFramePayloadLength(frames[i]);
@@ skipping 42 matching lines @@
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFramePayload(
             *frame.connection_close_frame, &writer)) {
           return false;
         }
         break;
       default:
         return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
   }
+
   DCHECK_EQ(len, writer.length());
-  *packet = new QuicPacket(writer.take(), len, true);
+  *packet = new QuicPacket(writer.take(), len, true, PACKET_FLAGS_NONE);
   if (fec_builder_) {
     fec_builder_->OnBuiltFecProtectedPayload(header,
                                              (*packet)->FecProtectedData());
   }
 
   return true;
 }
 
 bool QuicFramer::ConstructFecPacket(const QuicPacketHeader& header,
                                     const QuicFecData& fec,
@@ skipping 11 matching lines @@
   }
 
   if (!writer.WriteUInt48(fec.min_protected_packet_sequence_number)) {
     return false;
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
     return false;
   }
 
-  *packet = new QuicPacket(writer.take(), len, true);
+  *packet = new QuicPacket(writer.take(), len, true, PACKET_FLAGS_FEC);
 
   return true;
 }
 
-void QuicFramer::IncrementRetransmitCount(QuicPacket* packet) {
-  CHECK_GT(packet->length(), kPacketHeaderSize);
-
-  ++packet->mutable_data()[kRetransmissionOffset];
-}
-
-uint8 QuicFramer::GetRetransmitCount(QuicPacket* packet) {
-  CHECK_GT(packet->length(), kPacketHeaderSize);
-
-  return packet->mutable_data()[kRetransmissionOffset];
-}
-
 bool QuicFramer::ProcessPacket(const IPEndPoint& self_address,
                                const IPEndPoint& peer_address,
                                const QuicEncryptedPacket& packet) {
   DCHECK(!reader_.get());
   reader_.reset(new QuicDataReader(packet.data(), packet.length()));
   visitor_->OnPacket(self_address, peer_address);
 
   // First parse the packet header.
   QuicPacketHeader header;
   if (!ProcessPacketHeader(&header, packet)) {
@@ skipping 69 matching lines @@
                                    QuicDataWriter* writer) {
   // ConnectionHeader
   if (!writer->WriteUInt64(header.guid)) {
     return false;
   }
 
   if (!writer->WriteUInt48(header.packet_sequence_number)) {
     return false;
   }
 
-  if (!writer->WriteBytes(&header.retransmission_count, 1)) {
-    return false;
-  }
-
   // CongestionMonitoredHeader
   if (!writer->WriteUInt64(header.transmission_time)) {
     return false;
   }
 
   uint8 flags = static_cast<uint8>(header.flags);
   if (!writer->WriteBytes(&flags, 1)) {
      return false;
   }
 
@@ skipping 10 matching lines @@
   if (!reader_->ReadUInt64(&header->guid)) {
     set_detailed_error("Unable to read GUID.");
     return false;
   }
 
   if (!reader_->ReadUInt48(&header->packet_sequence_number)) {
     set_detailed_error("Unable to read sequence number.");
     return false;
   }
 
-  if (!reader_->ReadBytes(&header->retransmission_count, 1)) {
-    set_detailed_error("Unable to read retransmission count.");
-    return false;
-  }
-
   // CongestionMonitoredHeader
   if (!reader_->ReadUInt64(&header->transmission_time)) {
     set_detailed_error("Unable to read transmission time.");
     return false;
   }
 
   unsigned char flags;
   if (!reader_->ReadBytes(&flags, 1)) {
     set_detailed_error("Unable to read flags.");
     return false;
@@ skipping 270 matching lines @@
   visitor_->OnConnectionCloseFrame(frame);
   return true;
 }
 
 void QuicFramer::WriteTransmissionTime(QuicTransmissionTime time,
                                        QuicPacket* packet) {
   QuicDataWriter::WriteUint64ToBuffer(
       time, packet->mutable_data() + kTransmissionTimeOffset);
 }
 
+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 234 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net