Land recent QUIC changes.

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 68 matching lines @@
     if (CanTruncate(frame)) {
       // Truncate the frame so the packet will not exceed kMaxPacketSize.
       // Note that we may not use every byte of the writer in this case.
       DLOG(INFO) << "Truncating large frame";
       return free_bytes;
     }
   }
   return frame_len;
 }
 
-QuicPacket* QuicFramer::ConstructFrameDataPacket(const QuicPacketHeader& header,
-                                                 const QuicFrames& frames) {
+QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
+    const QuicPacketHeader& header) const {
+  if (!header.entropy_flag) {
+    // TODO(satyamshekhar): Return some more better value here (something that
+    // is not a constant).
+    return 0;
+  }
+  return 1 << (header.packet_sequence_number % 8);
+}
+
+SerializedPacket QuicFramer::ConstructFrameDataPacket(
+    const QuicPacketHeader& header,
+    const QuicFrames& frames) {
   const size_t max_plaintext_size = GetMaxPlaintextSize(kMaxPacketSize);
   size_t packet_size = kPacketHeaderSize;
   for (size_t i = 0; i < frames.size(); ++i) {
     DCHECK_LE(packet_size, max_plaintext_size);
     const size_t frame_size = GetSerializedFrameLength(
         frames[i], max_plaintext_size - packet_size, i == 0);
     DCHECK(frame_size);
     packet_size += frame_size;
   }
   return ConstructFrameDataPacket(header, frames, packet_size);
 }
 
-QuicPacket* QuicFramer::ConstructFrameDataPacket(const QuicPacketHeader& header,
-                                                 const QuicFrames& frames,
-                                                 size_t packet_size) {
+SerializedPacket QuicFramer::ConstructFrameDataPacket(
+    const QuicPacketHeader& header,
+    const QuicFrames& frames,
+    size_t packet_size) {
   QuicDataWriter writer(packet_size);
+  SerializedPacket kNoPacket = SerializedPacket(0, NULL, 0, NULL);
   if (!WritePacketHeader(header, &writer)) {
-    return NULL;
+    return kNoPacket;
   }
 
   for (size_t i = 0; i < frames.size(); ++i) {
     const QuicFrame& frame = frames[i];
     if (!writer.WriteUInt8(frame.type)) {
-      return NULL;
+      return kNoPacket;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
         if (!AppendStreamFramePayload(*frame.stream_frame, &writer)) {
-          return NULL;
+          return kNoPacket;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFramePayload(*frame.ack_frame, &writer)) {
-          return NULL;
+          return kNoPacket;
         }
         break;
       case CONGESTION_FEEDBACK_FRAME:
         if (!AppendQuicCongestionFeedbackFramePayload(
                 *frame.congestion_feedback_frame, &writer)) {
-          return NULL;
+          return kNoPacket;
         }
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFramePayload(*frame.rst_stream_frame, &writer)) {
-          return NULL;
+          return kNoPacket;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFramePayload(
                 *frame.connection_close_frame, &writer)) {
-          return NULL;
+          return kNoPacket;
+        }
+        break;
+      case GOAWAY_FRAME:
+        if (!AppendGoAwayFramePayload(*frame.goaway_frame, &writer)) {
+          return kNoPacket;
         }
         break;
       default:
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        return NULL;
+        return kNoPacket;
     }
   }
 
   // Save the length before writing, because take clears it.
   const size_t len = writer.length();
   // Less than or equal because truncated acks end up with max_plaintex_size
   // length, even though they're typically slightly shorter.
   DCHECK_LE(len, packet_size);
   QuicPacket* packet = QuicPacket::NewDataPacket(writer.take(), len, true);
 
   if (fec_builder_) {
     fec_builder_->OnBuiltFecProtectedPayload(header,
                                              packet->FecProtectedData());
   }
 
-  return packet;
+  return SerializedPacket(header.packet_sequence_number, packet,
+                          GetPacketEntropyHash(header), NULL);
 }
 
-QuicPacket* QuicFramer::ConstructFecPacket(const QuicPacketHeader& header,
-                                           const QuicFecData& fec) {
+SerializedPacket QuicFramer::ConstructFecPacket(const QuicPacketHeader& header,
+                                                const QuicFecData& fec) {
   size_t len = kPacketHeaderSize;
   len += fec.redundancy.length();
 
   QuicDataWriter writer(len);
-
+  SerializedPacket kNoPacket = SerializedPacket(0, NULL, 0, NULL);
   if (!WritePacketHeader(header, &writer)) {
-    return NULL;
+    return kNoPacket;
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
-    return NULL;
+    return kNoPacket;
   }
 
-  return QuicPacket::NewFecPacket(writer.take(), len, true);
+  return SerializedPacket(header.packet_sequence_number,
+                          QuicPacket::NewFecPacket(writer.take(), len, true),
+                          GetPacketEntropyHash(header), NULL);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
     const QuicPublicResetPacket& packet) {
-  DCHECK_EQ(PACKET_PUBLIC_FLAGS_RST,
-            PACKET_PUBLIC_FLAGS_RST & packet.public_header.flags);
+  DCHECK(packet.public_header.reset_flag);
+  DCHECK(!packet.public_header.version_flag);
   size_t len = kPublicResetPacketSize;
   QuicDataWriter writer(len);
 
   if (!writer.WriteUInt64(packet.public_header.guid)) {
     return NULL;
   }
 
-  uint8 flags = static_cast<uint8>(packet.public_header.flags);
+  uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(packet.nonce_proof)) {
     return NULL;
   }
 
   if (!AppendPacketSequenceNumber(packet.rejected_sequence_number,
                                   &writer)) {
     return NULL;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   DCHECK(!reader_.get());
   reader_.reset(new QuicDataReader(packet.data(), packet.length()));
 
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&public_header)) {
     DLOG(WARNING) << "Unable to process public header.";
     reader_.reset(NULL);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   bool rv;
-  if (public_header.flags & PACKET_PUBLIC_FLAGS_RST) {
+  if (public_header.reset_flag) {
     rv = ProcessPublicResetPacket(public_header);
   } else {
     rv = ProcessDataPacket(public_header, packet);
   }
 
   reader_.reset(NULL);
   return rv;
 }
 
 bool QuicFramer::ProcessDataPacket(
@@ skipping 10 matching lines @@
   if (!visitor_->OnPacketHeader(header)) {
     return true;
   }
 
   if (packet.length() > kMaxPacketSize) {
     DLOG(WARNING) << "Packet too large: " << packet.length();
     return RaiseError(QUIC_PACKET_TOO_LARGE);
   }
 
   // Handle the payload.
-  if ((header.private_flags & PACKET_PRIVATE_FLAGS_FEC) == 0) {
+  if (!header.fec_flag) {
     if (header.fec_group != 0) {
       StringPiece payload = reader_->PeekRemainingPayload();
       visitor_->OnFecProtectedPayload(payload);
     }
     if (!ProcessFrameData()) {
       DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
       DLOG(WARNING) << "Unable to process frame data.";
       return false;
     }
   } else {
@@ skipping 17 matching lines @@
   // TODO(satyamshekhar): validate nonce to protect against DoS.
 
   if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) {
     set_detailed_error("Unable to read rejected sequence number.");
     return false;
   }
   visitor_->OnPublicResetPacket(packet);
   return true;
 }
 
-bool QuicFramer::ProcessRevivedPacket(const QuicPacketHeader& header,
+bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header,
                                       StringPiece payload) {
   DCHECK(!reader_.get());
 
   visitor_->OnRevivedPacket();
 
-  visitor_->OnPacketHeader(header);
+  header->entropy_hash = GetPacketEntropyHash(*header);
+
+  // TODO(satyamshekhar): Don't process if the visitor refuses the header.
+  visitor_->OnPacketHeader(*header);
 
   if (payload.length() > kMaxPacketSize) {
     set_detailed_error("Revived packet too large.");
     return RaiseError(QUIC_PACKET_TOO_LARGE);
   }
 
   reader_.reset(new QuicDataReader(payload.data(), payload.length()));
   if (!ProcessFrameData()) {
     DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
     DLOG(WARNING) << "Unable to process frame data.";
     return false;
   }
 
   visitor_->OnPacketComplete();
   reader_.reset(NULL);
   return true;
 }
 
 bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
                                    QuicDataWriter* writer) {
   if (!writer->WriteUInt64(header.public_header.guid)) {
     return false;
   }
 
-  uint8 flags = static_cast<uint8>(header.public_header.flags);
+  uint8 flags = 0;
+  if (header.public_header.reset_flag) {
+    flags |= PACKET_PUBLIC_FLAGS_RST;
+  }
+  if (header.public_header.version_flag) {
+    flags |= PACKET_PUBLIC_FLAGS_VERSION;
+  }
   if (!writer->WriteUInt8(flags)) {
     return false;
   }
 
   if (!AppendPacketSequenceNumber(header.packet_sequence_number, writer)) {
     return false;
   }
 
-  flags = static_cast<uint8>(header.private_flags);
+  flags = 0;
+  if (header.fec_flag) {
+    flags |= PACKET_PRIVATE_FLAGS_FEC;
+  }
+  if (header.entropy_flag) {
+    flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
+  }
+  if (header.fec_entropy_flag) {
+    flags |= PACKET_PRIVATE_FLAGS_FEC_ENTROPY;
+  }
   if (!writer->WriteUInt8(flags)) {
     return false;
   }
 
   // Offset from the current packet sequence number to the first fec
   // protected packet, or kNoFecOffset to signal no FEC protection.
   uint8 first_fec_protected_packet_offset = kNoFecOffset;
 
   // The FEC group number is the sequence number of the first fec
   // protected packet, or 0 if this packet is not protected.
   if (header.fec_group != 0) {
     DCHECK_GE(header.packet_sequence_number, header.fec_group);
     DCHECK_GT(255u, header.packet_sequence_number - header.fec_group);
     first_fec_protected_packet_offset =
         header.packet_sequence_number - header.fec_group;
   }
   if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
     return false;
   }
 
   return true;
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
     QuicPacketSequenceNumber packet_sequence_number) const {
-  // The new sequence number might have wrapped to the next epoc, or
+  // The new sequence number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the sequence number closest to the
   // previous sequence number.
   QuicPacketSequenceNumber epoch = last_sequence_number_ & ~kSequenceNumberMask;
   QuicPacketSequenceNumber prev_epoch = epoch - (GG_UINT64_C(1) << 48);
   QuicPacketSequenceNumber next_epoch = epoch + (GG_UINT64_C(1) << 48);
 
   return ClosestTo(last_sequence_number_,
                    epoch + packet_sequence_number,
                    ClosestTo(last_sequence_number_,
@@ skipping 11 matching lines @@
   if (!reader_->ReadBytes(&public_flags, 1)) {
     set_detailed_error("Unable to read public flags.");
     return false;
   }
 
   if (public_flags > PACKET_PUBLIC_FLAGS_MAX) {
     set_detailed_error("Illegal public flags value.");
     return false;
   }
 
-  public_header->flags = static_cast<QuicPacketPublicFlags>(public_flags);
+  public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
+  public_header->version_flag =
+      (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
+
   return true;
 }
 
 // static
 bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
                                     QuicGuid* guid) {
   QuicDataReader reader(packet.data(), packet.length());
   return reader.ReadUInt64(guid);
 }
 
 bool QuicFramer::ProcessPacketHeader(
     QuicPacketHeader* header,
     const QuicEncryptedPacket& packet) {
   if (!ProcessPacketSequenceNumber(&header->packet_sequence_number)) {
     set_detailed_error("Unable to read sequence number.");
     return false;
   }
 
   if (header->packet_sequence_number == 0u) {
     set_detailed_error("Packet sequence numbers cannot be 0.");
     return false;
   }
 
-  if (!DecryptPayload(packet)) {
+  if (!DecryptPayload(header->packet_sequence_number, packet)) {
     DLOG(WARNING) << "Unable to decrypt payload.";
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   uint8 private_flags;
   if (!reader_->ReadBytes(&private_flags, 1)) {
     set_detailed_error("Unable to read private flags.");
     return false;
   }
 
   if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
     set_detailed_error("Illegal private flags value.");
     return false;
   }
 
-  header->private_flags = static_cast<QuicPacketPrivateFlags>(private_flags);
+  header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0;
+  header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
+  header->fec_entropy_flag =
+      (private_flags & PACKET_PRIVATE_FLAGS_FEC_ENTROPY) != 0;
 
   uint8 first_fec_protected_packet_offset;
   if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) {
     set_detailed_error("Unable to read first fec protected packet offset.");
     return false;
   }
   header->fec_group = first_fec_protected_packet_offset == kNoFecOffset ? 0 :
       header->packet_sequence_number - first_fec_protected_packet_offset;
 
+  header->entropy_hash = GetPacketEntropyHash(*header);
   // Set the last sequence number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   last_sequence_number_ = header->packet_sequence_number;
   return true;
 }
 
 bool QuicFramer::ProcessPacketSequenceNumber(
     QuicPacketSequenceNumber* sequence_number) {
   QuicPacketSequenceNumber wire_sequence_number;
   if (!reader_->ReadUInt48(&wire_sequence_number)) {
@@ skipping 42 matching lines @@
       case RST_STREAM_FRAME:
         if (!ProcessRstStreamFrame()) {
           return RaiseError(QUIC_INVALID_RST_STREAM_DATA);
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!ProcessConnectionCloseFrame()) {
           return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA);
         }
         break;
+      case GOAWAY_FRAME:
+        if (!ProcessGoAwayFrame()) {
+          return RaiseError(QUIC_INVALID_GOAWAY_DATA);
+        }
+        break;
       default:
         set_detailed_error("Illegal frame type.");
         DLOG(WARNING) << "Illegal frame type: "
                       << static_cast<int>(frame_type);
         return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
   }
 
   return true;
 }
@@ skipping 35 matching lines @@
     return false;
   }
   if (!ProcessReceivedInfo(&frame->received_info)) {
     return false;
   }
   visitor_->OnAckFrame(*frame);
   return true;
 }
 
 bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
+  if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) {
+    set_detailed_error("Unable to read entropy hash for received packets.");
+    return false;
+  }
+
   if (!ProcessPacketSequenceNumber(&received_info->largest_observed)) {
      set_detailed_error("Unable to read largest observed.");
      return false;
   }
 
   uint8 num_missing_packets;
   if (!reader_->ReadBytes(&num_missing_packets, 1)) {
     set_detailed_error("Unable to read num missing packets.");
     return false;
   }
 
   for (int i = 0; i < num_missing_packets; ++i) {
     QuicPacketSequenceNumber sequence_number;
     if (!ProcessPacketSequenceNumber(&sequence_number)) {
       set_detailed_error("Unable to read sequence number in missing packets.");
       return false;
     }
     received_info->missing_packets.insert(sequence_number);
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessSentInfo(SentPacketInfo* sent_info) {
+  if (!reader_->ReadBytes(&sent_info->entropy_hash, 1)) {
+    set_detailed_error("Unable to read entropy hash for sent packets.");
+    return false;
+  }
+
   if (!ProcessPacketSequenceNumber(&sent_info->least_unacked)) {
     set_detailed_error("Unable to read least unacked.");
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
     QuicCongestionFeedbackFrame* frame) {
@@ skipping 96 matching lines @@
   return true;
 }
 
 bool QuicFramer::ProcessRstStreamFrame() {
   QuicRstStreamFrame frame;
   if (!reader_->ReadUInt32(&frame.stream_id)) {
     set_detailed_error("Unable to read stream_id.");
     return false;
   }
 
-  if (!reader_->ReadUInt64(&frame.offset)) {
-    set_detailed_error("Unable to read offset in rst frame.");
-    return false;
-  }
-
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read rst stream error code.");
     return false;
   }
   frame.error_code = static_cast<QuicErrorCode>(error_code);
 
   StringPiece error_details;
   if (!reader_->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read rst stream error details.");
@@ skipping 24 matching lines @@
 
   if (!ProcessAckFrame(&frame.ack_frame)) {
     DLOG(WARNING) << "Unable to process ack frame.";
     return false;
   }
 
   visitor_->OnConnectionCloseFrame(frame);
   return true;
 }
 
-QuicEncryptedPacket* QuicFramer::EncryptPacket(const QuicPacket& packet) {
-  scoped_ptr<QuicData> out(encrypter_->Encrypt(packet.AssociatedData(),
+bool QuicFramer::ProcessGoAwayFrame() {
+  QuicGoAwayFrame frame;
+
+  uint32 error_code;
+  if (!reader_->ReadUInt32(&error_code)) {
+    set_detailed_error("Unable to read go away error code.");
+    return false;
+  }
+  frame.error_code = static_cast<QuicErrorCode>(error_code);
+
+  uint32 stream_id;
+  if (!reader_->ReadUInt32(&stream_id)) {
+    set_detailed_error("Unable to read last good stream id.");
+    return false;
+  }
+  frame.last_good_stream_id = static_cast<QuicErrorCode>(stream_id);
+
+  StringPiece reason_phrase;
+  if (!reader_->ReadStringPiece16(&reason_phrase)) {
+    set_detailed_error("Unable to read goaway reason.");
+    return false;
+  }
+  frame.reason_phrase = reason_phrase.as_string();
+
+  visitor_->OnGoAwayFrame(frame);
+  return true;
+}
+
+QuicEncryptedPacket* QuicFramer::EncryptPacket(
+    QuicPacketSequenceNumber packet_sequence_number,
+    const QuicPacket& packet) {
+  scoped_ptr<QuicData> out(encrypter_->Encrypt(packet_sequence_number,
+                                               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().
   memcpy(buffer, packet.data(), kStartOfEncryptedData);
   memcpy(buffer + kStartOfEncryptedData, out->data(), out->length());
   return new QuicEncryptedPacket(buffer, len, true);
 }
 
 size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) {
   return encrypter_->GetMaxPlaintextSize(ciphertext_size);
 }
 
-bool QuicFramer::DecryptPayload(const QuicEncryptedPacket& packet) {
+bool QuicFramer::DecryptPayload(QuicPacketSequenceNumber sequence_number,
+                                const QuicEncryptedPacket& packet) {
   StringPiece encrypted;
   if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
     return false;
   }
   DCHECK(decrypter_.get() != NULL);
-  decrypted_.reset(decrypter_->Decrypt(packet.AssociatedData(), encrypted));
+  decrypted_.reset(decrypter_->Decrypt(sequence_number,
+                                       packet.AssociatedData(), encrypted));
   if  (decrypted_.get() == NULL) {
     return false;
   }
 
   reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
   return true;
 }
 
 size_t QuicFramer::ComputeFramePayloadLength(const QuicFrame& frame) {
   size_t len = 0;
   // We use "magic numbers" here because sizeof(member_) is not necessarily the
   // same as sizeof(member_wire_format).
   switch (frame.type) {
     case STREAM_FRAME:
-      len += 4;  // stream id
-      len += 1;  // fin
-      len += 8;  // offset
-      len += 2;  // space for the 16 bit length
+      len += 4;  // Stream id of the frame.
+      len += 1;  // A byte for fin.
+      len += 8;  // Byte offset.
+      len += 2;  // Space for the 16 bit length.
       len += frame.stream_frame->data.size();
       break;
     case ACK_FRAME: {
       const QuicAckFrame& ack = *frame.ack_frame;
-      len += 6;  // largest observed packet sequence number
-      len += 1;  // num missing packets
+      len += 1;  // Commutative hash of entropy of the packets received.
+      len += 6;  // Least packet sequence number awaiting an ack.
+      len += 1;  // Hash of entropy of the packets sent up to largest observed.
+      len += 6;  // Largest observed packet sequence number.
+      len += 1;  // Number of missing packets.
       len += 6 * ack.received_info.missing_packets.size();
-      len += 6;  // least packet sequence number awaiting an ack
       break;
     }
     case CONGESTION_FEEDBACK_FRAME: {
       const QuicCongestionFeedbackFrame& congestion_feedback =
           *frame.congestion_feedback_frame;
-      len += 1;  // congestion feedback type
+      len += 1;  // Congestion feedback type.
 
       switch (congestion_feedback.type) {
         case kInterArrival: {
           const CongestionFeedbackMessageInterArrival& inter_arrival =
               congestion_feedback.inter_arrival;
           len += 2;
-          len += 1;  // num received packets
+          len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
-            len += 6;  // smallest received
-            len += 8;  // time
+            len += 6;  // Smallest received.
+            len += 8;  // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
             len += 6 * (inter_arrival.received_packet_times.size() - 1);
           }
           break;
         }
         case kFixRate:
           len += 4;
           break;
         case kTCP:
           len += 4;
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DLOG(INFO) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
       break;
     }
     case RST_STREAM_FRAME:
-      len += 4;  // stream id
-      len += 8;  // offset
-      len += 4;  // error code
-      len += 2;  // error details size
+      len += 4;  // Stream id of the frame.
+      len += 4;  // Error code.
+      len += 2;  // Error details size.
       len += frame.rst_stream_frame->error_details.size();
       break;
     case CONNECTION_CLOSE_FRAME:
-      len += 4;  // error code
-      len += 2;  // error details size
+      len += 4;  // Error code.
+      len += 2;  // Error details size.
       len += frame.connection_close_frame->error_details.size();
       len += ComputeFramePayloadLength(
           QuicFrame(&frame.connection_close_frame->ack_frame));
       break;
+    case GOAWAY_FRAME:
+      len += 4;  // error code
+      len += 4;  // last good stream id
+      len += 2;  // reason phrase length
+      len += frame.goaway_frame->reason_phrase.size();
+      break;
     default:
       set_detailed_error("Illegal frame type.");
       DLOG(INFO) << "Illegal frame type: " << frame.type;
       break;
   }
   return len;
 }
 
 // static
 bool QuicFramer::AppendPacketSequenceNumber(
@@ skipping 22 matching lines @@
     return false;
   }
   if (!writer->WriteBytes(frame.data.data(),
                            frame.data.size())) {
     return false;
   }
   return true;
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculateLargestObserved(
-    const SequenceSet& missing_packets,
-    SequenceSet::const_iterator largest_written) {
-  SequenceSet::const_iterator it = largest_written;
+    const SequenceNumberSet& missing_packets,
+    SequenceNumberSet::const_iterator largest_written) {
+  SequenceNumberSet::const_iterator it = largest_written;
   QuicPacketSequenceNumber previous_missing = *it;
   ++it;
 
   // See if the next thing is a gap in the missing packets: if it's a
   // non-missing packet we can return it.
   if (it != missing_packets.end() && previous_missing + 1 != *it) {
     return *it - 1;
   }
 
   // Otherwise return the largest missing packet, as indirectly observed.
   return *largest_written;
 }
 
 // TODO(ianswett): Use varints or another more compact approach for all deltas.
 bool QuicFramer::AppendAckFramePayload(
     const QuicAckFrame& frame,
     QuicDataWriter* writer) {
+  // TODO(satyamshekhar): Decide how often we really should send this
+  // entropy_hash update.
+  if (!writer->WriteUInt8(frame.sent_info.entropy_hash)) {
+    return false;
+  }
+
   if (!AppendPacketSequenceNumber(frame.sent_info.least_unacked, writer)) {
     return false;
   }
 
+  size_t received_entropy_offset = writer->length();
+  if (!writer->WriteUInt8(frame.received_info.entropy_hash)) {
+    return false;
+  }
+
   size_t largest_observed_offset = writer->length();
   if (!AppendPacketSequenceNumber(frame.received_info.largest_observed,
                                   writer)) {
     return false;
   }
 
   // We don't check for overflowing uint8 here, because we only can fit 192 acks
   // per packet, so if we overflow we will be truncated.
   uint8 num_missing_packets = frame.received_info.missing_packets.size();
   size_t num_missing_packets_offset = writer->length();
   if (!writer->WriteBytes(&num_missing_packets, 1)) {
     return false;
   }
 
-  SequenceSet::const_iterator it = frame.received_info.missing_packets.begin();
+  SequenceNumberSet::const_iterator it =
+      frame.received_info.missing_packets.begin();
   int num_missing_packets_written = 0;
   for (; it != frame.received_info.missing_packets.end(); ++it) {
     if (!AppendPacketSequenceNumber(*it, writer)) {
-      // We are truncating.  Overwrite largest_observed.
+      // We are truncating.
       QuicPacketSequenceNumber largest_observed =
           CalculateLargestObserved(frame.received_info.missing_packets, --it);
+      // Overwrite entropy hash for received packets.
+      writer->WriteUInt8ToOffset(
+          entropy_calculator_->ReceivedEntropyHash(largest_observed),
+          received_entropy_offset);
+      // Overwrite largest_observed.
       writer->WriteUInt48ToOffset(largest_observed & kSequenceNumberMask,
                                   largest_observed_offset);
       writer->WriteUInt8ToOffset(num_missing_packets_written,
                                  num_missing_packets_offset);
       return true;
     }
     ++num_missing_packets_written;
     DCHECK_GE(numeric_limits<uint8>::max(), num_missing_packets_written);
   }
 
@@ skipping 89 matching lines @@
 
   return true;
 }
 
 bool QuicFramer::AppendRstStreamFramePayload(
         const QuicRstStreamFrame& frame,
         QuicDataWriter* writer) {
   if (!writer->WriteUInt32(frame.stream_id)) {
     return false;
   }
-  if (!writer->WriteUInt64(frame.offset)) {
-    return false;
-  }
 
   uint32 error_code = static_cast<uint32>(frame.error_code);
   if (!writer->WriteUInt32(error_code)) {
     return false;
   }
 
   if (!writer->WriteStringPiece16(frame.error_details)) {
     return false;
   }
   return true;
 }
 
 bool QuicFramer::AppendConnectionCloseFramePayload(
     const QuicConnectionCloseFrame& frame,
     QuicDataWriter* writer) {
   uint32 error_code = static_cast<uint32>(frame.error_code);
   if (!writer->WriteUInt32(error_code)) {
     return false;
   }
   if (!writer->WriteStringPiece16(frame.error_details)) {
     return false;
   }
   AppendAckFramePayload(frame.ack_frame, writer);
   return true;
 }
 
+bool QuicFramer::AppendGoAwayFramePayload(const QuicGoAwayFrame& frame,
+                                          QuicDataWriter* writer) {
+  uint32 error_code = static_cast<uint32>(frame.error_code);
+  if (!writer->WriteUInt32(error_code)) {
+    return false;
+  }
+  uint32 stream_id = static_cast<uint32>(frame.last_good_stream_id);
+  if (!writer->WriteUInt32(stream_id)) {
+    return false;
+  }
+  if (!writer->WriteStringPiece16(frame.reason_phrase)) {
+    return false;
+  }
+  return true;
+}
+
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net