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