net/quic/quic_protocol.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/quic_protocol.h"
   6
   7 #include "base/stl_util.h"
   8 #include "net/quic/quic_utils.h"
   9
  10 using base::StringPiece;
  11 using std::map;
  12 using std::numeric_limits;
  13 using std::ostream;
  14 using std::string;
  15
  16 namespace net {
  17
  18 size_t GetPacketHeaderSize(const QuicPacketHeader& header) {
  19   return GetPacketHeaderSize(header.public_header.guid_length,
  20                              header.public_header.version_flag,
  21                              header.public_header.sequence_number_length,
  22                              header.is_in_fec_group);
  23 }
  24
  25 size_t GetPacketHeaderSize(QuicGuidLength guid_length,
  26                            bool include_version,
  27                            QuicSequenceNumberLength sequence_number_length,
  28                            InFecGroup is_in_fec_group) {
  29   return kPublicFlagsSize + guid_length +
  30       (include_version ? kQuicVersionSize : 0) + sequence_number_length +
  31       kPrivateFlagsSize + (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0);
  32 }
  33
  34 size_t GetStartOfFecProtectedData(
  35     QuicGuidLength guid_length,
  36     bool include_version,
  37     QuicSequenceNumberLength sequence_number_length) {
  38   return GetPacketHeaderSize(
  39       guid_length, include_version, sequence_number_length, IN_FEC_GROUP);
  40 }
  41
  42 size_t GetStartOfEncryptedData(
  43     QuicGuidLength guid_length,
  44     bool include_version,
  45     QuicSequenceNumberLength sequence_number_length) {
  46   // Don't include the fec size, since encryption starts before private flags.
  47   return GetPacketHeaderSize(
  48       guid_length, include_version, sequence_number_length, NOT_IN_FEC_GROUP) -
  49       kPrivateFlagsSize;
  50 }
  51
  52 QuicPacketPublicHeader::QuicPacketPublicHeader()
  53     : guid(0),
  54       guid_length(PACKET_8BYTE_GUID),
  55       reset_flag(false),
  56       version_flag(false),
  57       sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
  58 }
  59
  60 QuicPacketPublicHeader::QuicPacketPublicHeader(
  61     const QuicPacketPublicHeader& other)
  62     : guid(other.guid),
  63       guid_length(other.guid_length),
  64       reset_flag(other.reset_flag),
  65       version_flag(other.version_flag),
  66       sequence_number_length(other.sequence_number_length),
  67       versions(other.versions) {
  68 }
  69
  70 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
  71
  72 QuicPacketHeader::QuicPacketHeader()
  73     : fec_flag(false),
  74       entropy_flag(false),
  75       entropy_hash(0),
  76       packet_sequence_number(0),
  77       is_in_fec_group(NOT_IN_FEC_GROUP),
  78       fec_group(0) {
  79 }
  80
  81 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header)
  82     : public_header(header),
  83       fec_flag(false),
  84       entropy_flag(false),
  85       entropy_hash(0),
  86       packet_sequence_number(0),
  87       is_in_fec_group(NOT_IN_FEC_GROUP),
  88       fec_group(0) {
  89 }
  90
  91 QuicPublicResetPacket::QuicPublicResetPacket()
  92     : nonce_proof(0),
  93       rejected_sequence_number(0) {}
  94
  95 QuicPublicResetPacket::QuicPublicResetPacket(
  96     const QuicPacketPublicHeader& header)
  97     : public_header(header),
  98       nonce_proof(0),
  99       rejected_sequence_number(0) {}
 100
 101 QuicStreamFrame::QuicStreamFrame()
 102     : stream_id(0),
 103       fin(false),
 104       offset(0),
 105       notifier(NULL) {}
 106
 107 QuicStreamFrame::QuicStreamFrame(const QuicStreamFrame& frame)
 108     : stream_id(frame.stream_id),
 109       fin(frame.fin),
 110       offset(frame.offset),
 111       data(frame.data),
 112       notifier(frame.notifier) {
 113 }
 114
 115 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
 116                                  bool fin,
 117                                  QuicStreamOffset offset,
 118                                  IOVector data)
 119     : stream_id(stream_id),
 120       fin(fin),
 121       offset(offset),
 122       data(data),
 123       notifier(NULL) {
 124 }
 125
 126 string* QuicStreamFrame::GetDataAsString() const {
 127   string* data_string = new string();
 128   data_string->reserve(data.TotalBufferSize());
 129   for (size_t i = 0; i < data.Size(); ++i) {
 130     data_string->append(static_cast<char*>(data.iovec()[i].iov_base),
 131                         data.iovec()[i].iov_len);
 132   }
 133   DCHECK_EQ(data_string->size(), data.TotalBufferSize());
 134   return data_string;
 135 }
 136
 137 uint32 MakeQuicTag(char a, char b, char c, char d) {
 138   return static_cast<uint32>(a) |
 139          static_cast<uint32>(b) << 8 |
 140          static_cast<uint32>(c) << 16 |
 141          static_cast<uint32>(d) << 24;
 142 }
 143
 144 QuicVersionVector QuicSupportedVersions() {
 145   QuicVersionVector supported_versions;
 146   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
 147     supported_versions.push_back(kSupportedQuicVersions[i]);
 148   }
 149   return supported_versions;
 150 }
 151
 152 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
 153   switch (version) {
 154     case QUIC_VERSION_12:
 155       return MakeQuicTag('Q', '0', '1', '2');
 156     case QUIC_VERSION_13:
 157       return MakeQuicTag('Q', '0', '1', '3');
 158     case QUIC_VERSION_14:
 159       return MakeQuicTag('Q', '0', '1', '4');
 160     case QUIC_VERSION_15:
 161       return MakeQuicTag('Q', '0', '1', '5');
 162     case QUIC_VERSION_16:
 163       return MakeQuicTag('Q', '0', '1', '6');
 164     default:
 165       // This shold be an ERROR because we should never attempt to convert an
 166       // invalid QuicVersion to be written to the wire.
 167       LOG(ERROR) << "Unsupported QuicVersion: " << version;
 168       return 0;
 169   }
 170 }
 171
 172 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
 173   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
 174     if (version_tag == QuicVersionToQuicTag(kSupportedQuicVersions[i])) {
 175       return kSupportedQuicVersions[i];
 176     }
 177   }
 178   // Reading from the client so this should not be considered an ERROR.
 179   DVLOG(1) << "Unsupported QuicTag version: "
 180            << QuicUtils::TagToString(version_tag);
 181   return QUIC_VERSION_UNSUPPORTED;
 182 }
 183
 184 #define RETURN_STRING_LITERAL(x) \
 185 case x: \
 186 return #x
 187
 188 string QuicVersionToString(const QuicVersion version) {
 189   switch (version) {
 190     RETURN_STRING_LITERAL(QUIC_VERSION_12);
 191     RETURN_STRING_LITERAL(QUIC_VERSION_13);
 192     RETURN_STRING_LITERAL(QUIC_VERSION_14);
 193     RETURN_STRING_LITERAL(QUIC_VERSION_15);
 194     RETURN_STRING_LITERAL(QUIC_VERSION_16);
 195     default:
 196       return "QUIC_VERSION_UNSUPPORTED";
 197   }
 198 }
 199
 200 string QuicVersionVectorToString(const QuicVersionVector& versions) {
 201   string result = "";
 202   for (size_t i = 0; i < versions.size(); ++i) {
 203     if (i != 0) {
 204       result.append(",");
 205     }
 206     result.append(QuicVersionToString(versions[i]));
 207   }
 208   return result;
 209 }
 210
 211 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
 212   os << "{ guid: " << header.public_header.guid
 213      << ", guid_length:" << header.public_header.guid_length
 214      << ", sequence_number_length:"
 215      << header.public_header.sequence_number_length
 216      << ", reset_flag: " << header.public_header.reset_flag
 217      << ", version_flag: " << header.public_header.version_flag;
 218   if (header.public_header.version_flag) {
 219     os << " version: ";
 220     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
 221       os << header.public_header.versions[0] << " ";
 222     }
 223   }
 224   os << ", fec_flag: " << header.fec_flag
 225      << ", entropy_flag: " << header.entropy_flag
 226      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
 227      << ", sequence_number: " << header.packet_sequence_number
 228      << ", is_in_fec_group:" << header.is_in_fec_group
 229      << ", fec_group: " << header.fec_group<< "}\n";
 230   return os;
 231 }
 232
 233 ReceivedPacketInfo::ReceivedPacketInfo()
 234     : entropy_hash(0),
 235       largest_observed(0),
 236       delta_time_largest_observed(QuicTime::Delta::Infinite()),
 237       is_truncated(false) {}
 238
 239 ReceivedPacketInfo::~ReceivedPacketInfo() {}
 240
 241 bool IsAwaitingPacket(const ReceivedPacketInfo& received_info,
 242                       QuicPacketSequenceNumber sequence_number) {
 243   return sequence_number > received_info.largest_observed ||
 244       ContainsKey(received_info.missing_packets, sequence_number);
 245 }
 246
 247 void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
 248                                  QuicPacketSequenceNumber lower,
 249                                  QuicPacketSequenceNumber higher) {
 250   for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
 251     received_info->missing_packets.insert(i);
 252   }
 253 }
 254
 255 QuicStopWaitingFrame::QuicStopWaitingFrame()
 256     : entropy_hash(0),
 257       least_unacked(0) {
 258 }
 259
 260 QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 261
 262 QuicAckFrame::QuicAckFrame() {}
 263
 264 QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_observed,
 265                            QuicTime largest_observed_receive_time,
 266                            QuicPacketSequenceNumber least_unacked) {
 267   received_info.largest_observed = largest_observed;
 268   received_info.entropy_hash = 0;
 269   sent_info.least_unacked = least_unacked;
 270   sent_info.entropy_hash = 0;
 271 }
 272
 273 CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
 274     : receive_window(0) {
 275 }
 276
 277 CongestionFeedbackMessageInterArrival::CongestionFeedbackMessageInterArrival() {
 278 }
 279
 280 CongestionFeedbackMessageInterArrival::
 281     ~CongestionFeedbackMessageInterArrival() {}
 282
 283 QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() : type(kTCP) {}
 284
 285 QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() {}
 286
 287 QuicRstStreamFrame::QuicRstStreamFrame()
 288     : stream_id(0),
 289       error_code(QUIC_STREAM_NO_ERROR) {
 290 }
 291
 292 QuicRstStreamFrame::QuicRstStreamFrame(QuicStreamId stream_id,
 293                                        QuicRstStreamErrorCode error_code,
 294                                        QuicStreamOffset bytes_written)
 295     : stream_id(stream_id),
 296       error_code(error_code),
 297       byte_offset(bytes_written) {
 298   DCHECK_LE(error_code, numeric_limits<uint8>::max());
 299 }
 300
 301 QuicConnectionCloseFrame::QuicConnectionCloseFrame()
 302     : error_code(QUIC_NO_ERROR) {
 303 }
 304
 305 QuicFrame::QuicFrame() {}
 306
 307 QuicFrame::QuicFrame(QuicPaddingFrame* padding_frame)
 308     : type(PADDING_FRAME),
 309       padding_frame(padding_frame) {
 310 }
 311
 312 QuicFrame::QuicFrame(QuicStreamFrame* stream_frame)
 313     : type(STREAM_FRAME),
 314       stream_frame(stream_frame) {
 315 }
 316
 317 QuicFrame::QuicFrame(QuicAckFrame* frame)
 318     : type(ACK_FRAME),
 319       ack_frame(frame) {
 320 }
 321
 322 QuicFrame::QuicFrame(QuicCongestionFeedbackFrame* frame)
 323     : type(CONGESTION_FEEDBACK_FRAME),
 324       congestion_feedback_frame(frame) {
 325 }
 326
 327 QuicFrame::QuicFrame(QuicStopWaitingFrame* frame)
 328     : type(STOP_WAITING_FRAME),
 329       stop_waiting_frame(frame) {
 330 }
 331
 332 QuicFrame::QuicFrame(QuicRstStreamFrame* frame)
 333     : type(RST_STREAM_FRAME),
 334       rst_stream_frame(frame) {
 335 }
 336
 337 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame)
 338     : type(CONNECTION_CLOSE_FRAME),
 339       connection_close_frame(frame) {
 340 }
 341
 342 QuicFrame::QuicFrame(QuicGoAwayFrame* frame)
 343     : type(GOAWAY_FRAME),
 344       goaway_frame(frame) {
 345 }
 346
 347 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
 348     : type(WINDOW_UPDATE_FRAME),
 349       window_update_frame(frame) {
 350 }
 351
 352 QuicFrame::QuicFrame(QuicBlockedFrame* frame)
 353     : type(BLOCKED_FRAME),
 354       blocked_frame(frame) {
 355 }
 356
 357 QuicFecData::QuicFecData() : fec_group(0) {}
 358
 359 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
 360   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
 361      << " least_unacked: " << sent_info.least_unacked;
 362   return os;
 363 }
 364
 365 ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) {
 366   os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
 367      << " is_truncated: " << received_info.is_truncated
 368      << " largest_observed: " << received_info.largest_observed
 369      << " missing_packets: [ ";
 370   for (SequenceNumberSet::const_iterator it =
 371            received_info.missing_packets.begin();
 372        it != received_info.missing_packets.end(); ++it) {
 373     os << *it << " ";
 374   }
 375   os << " ] revived_packets: [ ";
 376   for (SequenceNumberSet::const_iterator it =
 377            received_info.revived_packets.begin();
 378        it != received_info.revived_packets.end(); ++it) {
 379     os << *it << " ";
 380   }
 381   os << " ]";
 382   return os;
 383 }
 384
 385 ostream& operator<<(ostream& os, const QuicFrame& frame) {
 386   switch (frame.type) {
 387   case PADDING_FRAME: {
 388       os << "type { PADDING_FRAME } ";
 389       break;
 390     }
 391     case RST_STREAM_FRAME: {
 392       os << "type { " << RST_STREAM_FRAME << " } " << *(frame.rst_stream_frame);
 393       break;
 394     }
 395     case CONNECTION_CLOSE_FRAME: {
 396       os << "type { CONNECTION_CLOSE_FRAME } "
 397          << *(frame.connection_close_frame);
 398       break;
 399     }
 400     case GOAWAY_FRAME: {
 401       os << "type { GOAWAY_FRAME } " << *(frame.goaway_frame);
 402       break;
 403     }
 404     case WINDOW_UPDATE_FRAME: {
 405       os << "type { WINDOW_UPDATE_FRAME } " << *(frame.window_update_frame);
 406       break;
 407     }
 408     case BLOCKED_FRAME: {
 409       os << "type { BLOCKED_FRAME } " << *(frame.blocked_frame);
 410       break;
 411     }
 412     case STREAM_FRAME: {
 413       os << "type { STREAM_FRAME } " << *(frame.stream_frame);
 414       break;
 415     }
 416     case ACK_FRAME: {
 417       os << "type { ACK_FRAME } " << *(frame.ack_frame);
 418       break;
 419     }
 420     case CONGESTION_FEEDBACK_FRAME: {
 421       os << "type { CONGESTION_FEEDBACK_FRAME } "
 422          << *(frame.congestion_feedback_frame);
 423       break;
 424     }
 425     case STOP_WAITING_FRAME: {
 426       os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame);
 427       break;
 428     }
 429     default: {
 430       LOG(ERROR) << "Unknown frame type: " << frame.type;
 431       break;
 432     }
 433   }
 434   return os;
 435 }
 436
 437 ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) {
 438   os << "stream_id { " << rst_frame.stream_id << " } "
 439      << "error_code { " << rst_frame.error_code << " } "
 440      << "error_details { " << rst_frame.error_details << " }\n";
 441   return os;
 442 }
 443
 444 ostream& operator<<(ostream& os,
 445                     const QuicConnectionCloseFrame& connection_close_frame) {
 446   os << "error_code { " << connection_close_frame.error_code << " } "
 447      << "error_details { " << connection_close_frame.error_details << " }\n";
 448   return os;
 449 }
 450
 451 ostream& operator<<(ostream& os, const QuicGoAwayFrame& goaway_frame) {
 452   os << "error_code { " << goaway_frame.error_code << " } "
 453      << "last_good_stream_id { " << goaway_frame.last_good_stream_id << " } "
 454      << "reason_phrase { " << goaway_frame.reason_phrase << " }\n";
 455   return os;
 456 }
 457
 458 ostream& operator<<(ostream& os,
 459                     const QuicWindowUpdateFrame& window_update_frame) {
 460   os << "stream_id { " << window_update_frame.stream_id << " } "
 461      << "byte_offset { " << window_update_frame.byte_offset << " }\n";
 462   return os;
 463 }
 464
 465 ostream& operator<<(ostream& os, const QuicBlockedFrame& blocked_frame) {
 466   os << "stream_id { " << blocked_frame.stream_id << " }\n";
 467   return os;
 468 }
 469
 470 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) {
 471   os << "stream_id { " << stream_frame.stream_id << " } "
 472      << "fin { " << stream_frame.fin << " } "
 473      << "offset { " << stream_frame.offset << " } "
 474      << "data { "
 475      << QuicUtils::StringToHexASCIIDump(*(stream_frame.GetDataAsString()))
 476      << " }\n";
 477   return os;
 478 }
 479
 480 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
 481   os << "sent info { " << ack_frame.sent_info << " } "
 482      << "received info { " << ack_frame.received_info << " }\n";
 483   return os;
 484 }
 485
 486 ostream& operator<<(ostream& os,
 487                     const QuicCongestionFeedbackFrame& congestion_frame) {
 488   os << "type: " << congestion_frame.type;
 489   switch (congestion_frame.type) {
 490     case kInterArrival: {
 491       const CongestionFeedbackMessageInterArrival& inter_arrival =
 492           congestion_frame.inter_arrival;
 493       os << " received packets: [ ";
 494       for (TimeMap::const_iterator it =
 495                inter_arrival.received_packet_times.begin();
 496            it != inter_arrival.received_packet_times.end(); ++it) {
 497         os << it->first << "@" << it->second.ToDebuggingValue() << " ";
 498       }
 499       os << "]";
 500       break;
 501     }
 502     case kFixRate: {
 503       os << " bitrate_in_bytes_per_second: "
 504          << congestion_frame.fix_rate.bitrate.ToBytesPerSecond();
 505       break;
 506     }
 507     case kTCP: {
 508       const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
 509       os << " receive_window: " << tcp.receive_window;
 510       break;
 511     }
 512   }
 513   return os;
 514 }
 515
 516 CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate()
 517     : bitrate(QuicBandwidth::Zero()) {
 518 }
 519
 520 QuicGoAwayFrame::QuicGoAwayFrame()
 521     : error_code(QUIC_NO_ERROR),
 522       last_good_stream_id(0) {
 523 }
 524
 525 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
 526                                  QuicStreamId last_good_stream_id,
 527                                  const string& reason)
 528     : error_code(error_code),
 529       last_good_stream_id(last_good_stream_id),
 530       reason_phrase(reason) {
 531   DCHECK_LE(error_code, numeric_limits<uint8>::max());
 532 }
 533
 534 QuicData::QuicData(const char* buffer,
 535                    size_t length)
 536     : buffer_(buffer),
 537       length_(length),
 538       owns_buffer_(false) {
 539 }
 540
 541 QuicData::QuicData(char* buffer,
 542                    size_t length,
 543                    bool owns_buffer)
 544     : buffer_(buffer),
 545       length_(length),
 546       owns_buffer_(owns_buffer) {
 547 }
 548
 549 QuicData::~QuicData() {
 550   if (owns_buffer_) {
 551     delete [] const_cast<char*>(buffer_);
 552   }
 553 }
 554
 555 QuicWindowUpdateFrame::QuicWindowUpdateFrame(QuicStreamId stream_id,
 556                                              QuicStreamOffset byte_offset)
 557     : stream_id(stream_id),
 558       byte_offset(byte_offset) {}
 559
 560 QuicBlockedFrame::QuicBlockedFrame(QuicStreamId stream_id)
 561     : stream_id(stream_id) {}
 562
 563 QuicPacket::QuicPacket(char* buffer,
 564                        size_t length,
 565                        bool owns_buffer,
 566                        QuicGuidLength guid_length,
 567                        bool includes_version,
 568                        QuicSequenceNumberLength sequence_number_length,
 569                        bool is_fec_packet)
 570     : QuicData(buffer, length, owns_buffer),
 571       buffer_(buffer),
 572       is_fec_packet_(is_fec_packet),
 573       guid_length_(guid_length),
 574       includes_version_(includes_version),
 575       sequence_number_length_(sequence_number_length) {
 576 }
 577
 578 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer,
 579                                          size_t length)
 580     : QuicData(buffer, length) {
 581 }
 582
 583 QuicEncryptedPacket::QuicEncryptedPacket(char* buffer,
 584                                          size_t length,
 585                                          bool owns_buffer)
 586       : QuicData(buffer, length, owns_buffer) {
 587 }
 588
 589 StringPiece QuicPacket::FecProtectedData() const {
 590   const size_t start_of_fec = GetStartOfFecProtectedData(
 591       guid_length_, includes_version_, sequence_number_length_);
 592   return StringPiece(data() + start_of_fec, length() - start_of_fec);
 593 }
 594
 595 StringPiece QuicPacket::AssociatedData() const {
 596   return StringPiece(
 597       data() + kStartOfHashData,
 598       GetStartOfEncryptedData(
 599           guid_length_, includes_version_, sequence_number_length_) -
 600       kStartOfHashData);
 601 }
 602
 603 StringPiece QuicPacket::BeforePlaintext() const {
 604   return StringPiece(data(), GetStartOfEncryptedData(guid_length_,
 605                                                      includes_version_,
 606                                                      sequence_number_length_));
 607 }
 608
 609 StringPiece QuicPacket::Plaintext() const {
 610   const size_t start_of_encrypted_data =
 611       GetStartOfEncryptedData(
 612           guid_length_, includes_version_, sequence_number_length_);
 613   return StringPiece(data() + start_of_encrypted_data,
 614                      length() - start_of_encrypted_data);
 615 }
 616
 617 RetransmittableFrames::RetransmittableFrames()
 618     : encryption_level_(NUM_ENCRYPTION_LEVELS) {
 619 }
 620
 621 RetransmittableFrames::~RetransmittableFrames() {
 622   for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) {
 623     switch (it->type) {
 624       case PADDING_FRAME:
 625         delete it->padding_frame;
 626         break;
 627       case STREAM_FRAME:
 628         delete it->stream_frame;
 629         break;
 630       case ACK_FRAME:
 631         delete it->ack_frame;
 632         break;
 633       case CONGESTION_FEEDBACK_FRAME:
 634         delete it->congestion_feedback_frame;
 635         break;
 636       case STOP_WAITING_FRAME:
 637         delete it->stop_waiting_frame;
 638         break;
 639       case RST_STREAM_FRAME:
 640         delete it->rst_stream_frame;
 641         break;
 642       case CONNECTION_CLOSE_FRAME:
 643         delete it->connection_close_frame;
 644         break;
 645       case GOAWAY_FRAME:
 646         delete it->goaway_frame;
 647         break;
 648       case WINDOW_UPDATE_FRAME:
 649         delete it->window_update_frame;
 650         break;
 651       case BLOCKED_FRAME:
 652         delete it->blocked_frame;
 653         break;
 654       case NUM_FRAME_TYPES:
 655         DCHECK(false) << "Cannot delete type: " << it->type;
 656     }
 657   }
 658   STLDeleteElements(&stream_data_);
 659 }
 660
 661 const QuicFrame& RetransmittableFrames::AddStreamFrame(
 662     QuicStreamFrame* stream_frame) {
 663   // Make an owned copy of the stream frame's data.
 664   stream_data_.push_back(stream_frame->GetDataAsString());
 665   // Ensure the stream frame's IOVector points to the owned copy of the data.
 666   stream_frame->data.Clear();
 667   stream_frame->data.Append(const_cast<char*>(stream_data_.back()->data()),
 668                             stream_data_.back()->size());
 669   frames_.push_back(QuicFrame(stream_frame));
 670   return frames_.back();
 671 }
 672
 673 const QuicFrame& RetransmittableFrames::AddNonStreamFrame(
 674     const QuicFrame& frame) {
 675   DCHECK_NE(frame.type, STREAM_FRAME);
 676   frames_.push_back(frame);
 677   return frames_.back();
 678 }
 679
 680 IsHandshake RetransmittableFrames::HasCryptoHandshake() const {
 681   for (size_t i = 0; i < frames().size(); ++i) {
 682     if (frames()[i].type == STREAM_FRAME &&
 683         frames()[i].stream_frame->stream_id == kCryptoStreamId) {
 684       return IS_HANDSHAKE;
 685     }
 686   }
 687   return NOT_HANDSHAKE;
 688 }
 689
 690 void RetransmittableFrames::set_encryption_level(EncryptionLevel level) {
 691   encryption_level_ = level;
 692 }
 693
 694 SerializedPacket::SerializedPacket(
 695     QuicPacketSequenceNumber sequence_number,
 696     QuicSequenceNumberLength sequence_number_length,
 697     QuicPacket* packet,
 698     QuicPacketEntropyHash entropy_hash,
 699     RetransmittableFrames* retransmittable_frames)
 700     : sequence_number(sequence_number),
 701       sequence_number_length(sequence_number_length),
 702       packet(packet),
 703       entropy_hash(entropy_hash),
 704       retransmittable_frames(retransmittable_frames) {
 705 }
 706
 707 SerializedPacket::~SerializedPacket() {}
 708
 709 QuicEncryptedPacket* QuicEncryptedPacket::Clone() const {
 710   char* buffer = new char[this->length()];
 711   memcpy(buffer, this->data(), this->length());
 712   return new QuicEncryptedPacket(buffer, this->length(), true);
 713 }
 714
 715 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) {
 716   os << s.length() << "-byte data";
 717   return os;
 718 }
 719
 720 QuicConsumedData::QuicConsumedData(size_t bytes_consumed,
 721                                    bool fin_consumed)
 722       : bytes_consumed(bytes_consumed),
 723         fin_consumed(fin_consumed) {
 724 }
 725
 726 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
 727   os << "bytes_consumed: " << s.bytes_consumed
 728      << " fin_consumed: " << s.fin_consumed;
 729   return os;
 730 }
 731
 732 WriteResult::WriteResult(WriteStatus status,
 733                          int bytes_written_or_error_code)
 734     : status(status),
 735       bytes_written(bytes_written_or_error_code) {
 736 }
 737
 738 }  // namespace net