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