quic_protocol.cc revision 5c02ac1a9c1b504631c0a3d2b6e737b5d738bae1 
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
147QuicVersionVector QuicSupportedVersions() {
148  QuicVersionVector supported_versions;
149  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
150    supported_versions.push_back(kSupportedQuicVersions[i]);
151  }
152  return supported_versions;
153}
154
155QuicTag QuicVersionToQuicTag(const QuicVersion version) {
156  switch (version) {
157    case QUIC_VERSION_15:
158      return MakeQuicTag('Q', '0', '1', '5');
159    case QUIC_VERSION_16:
160      return MakeQuicTag('Q', '0', '1', '6');
161    case QUIC_VERSION_17:
162      return MakeQuicTag('Q', '0', '1', '7');
163    case QUIC_VERSION_18:
164      return MakeQuicTag('Q', '0', '1', '8');
165    default:
166      // This shold be an ERROR because we should never attempt to convert an
167      // invalid QuicVersion to be written to the wire.
168      LOG(ERROR) << "Unsupported QuicVersion: " << version;
169      return 0;
170  }
171}
172
173QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
174  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
175    if (version_tag == QuicVersionToQuicTag(kSupportedQuicVersions[i])) {
176      return kSupportedQuicVersions[i];
177    }
178  }
179  // Reading from the client so this should not be considered an ERROR.
180  DVLOG(1) << "Unsupported QuicTag version: "
181           << QuicUtils::TagToString(version_tag);
182  return QUIC_VERSION_UNSUPPORTED;
183}
184
185#define RETURN_STRING_LITERAL(x) \
186case x: \
187return #x
188
189string QuicVersionToString(const QuicVersion version) {
190  switch (version) {
191    RETURN_STRING_LITERAL(QUIC_VERSION_15);
192    RETURN_STRING_LITERAL(QUIC_VERSION_16);
193    RETURN_STRING_LITERAL(QUIC_VERSION_17);
194    RETURN_STRING_LITERAL(QUIC_VERSION_18);
195    default:
196      return "QUIC_VERSION_UNSUPPORTED";
197  }
198}
199
200string 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
211ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
212  os << "{ connection_id: " << header.public_header.connection_id
213     << ", connection_id_length:" << header.public_header.connection_id_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
233ReceivedPacketInfo::ReceivedPacketInfo()
234    : entropy_hash(0),
235      largest_observed(0),
236      delta_time_largest_observed(QuicTime::Delta::Infinite()),
237      is_truncated(false) {}
238
239ReceivedPacketInfo::~ReceivedPacketInfo() {}
240
241bool 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
247void 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
255QuicStopWaitingFrame::QuicStopWaitingFrame()
256    : entropy_hash(0),
257      least_unacked(0) {
258}
259
260QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
261
262QuicAckFrame::QuicAckFrame() {}
263
264CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
265    : receive_window(0) {
266}
267
268CongestionFeedbackMessageInterArrival::CongestionFeedbackMessageInterArrival() {
269}
270
271CongestionFeedbackMessageInterArrival::
272    ~CongestionFeedbackMessageInterArrival() {}
273
274QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() : type(kTCP) {}
275
276QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() {}
277
278QuicRstStreamErrorCode AdjustErrorForVersion(
279    QuicRstStreamErrorCode error_code,
280    QuicVersion version) {
281  switch (error_code) {
282    case QUIC_RST_FLOW_CONTROL_ACCOUNTING:
283      if (version <= QUIC_VERSION_17) {
284        return QUIC_STREAM_NO_ERROR;
285      }
286      break;
287    default:
288      return error_code;
289  }
290  return error_code;
291}
292
293QuicRstStreamFrame::QuicRstStreamFrame()
294    : stream_id(0),
295      error_code(QUIC_STREAM_NO_ERROR) {
296}
297
298QuicRstStreamFrame::QuicRstStreamFrame(QuicStreamId stream_id,
299                                       QuicRstStreamErrorCode error_code,
300                                       QuicStreamOffset bytes_written)
301    : stream_id(stream_id),
302      error_code(error_code),
303      byte_offset(bytes_written) {
304  DCHECK_LE(error_code, numeric_limits<uint8>::max());
305}
306
307QuicConnectionCloseFrame::QuicConnectionCloseFrame()
308    : error_code(QUIC_NO_ERROR) {
309}
310
311QuicFrame::QuicFrame() {}
312
313QuicFrame::QuicFrame(QuicPaddingFrame* padding_frame)
314    : type(PADDING_FRAME),
315      padding_frame(padding_frame) {
316}
317
318QuicFrame::QuicFrame(QuicStreamFrame* stream_frame)
319    : type(STREAM_FRAME),
320      stream_frame(stream_frame) {
321}
322
323QuicFrame::QuicFrame(QuicAckFrame* frame)
324    : type(ACK_FRAME),
325      ack_frame(frame) {
326}
327
328QuicFrame::QuicFrame(QuicCongestionFeedbackFrame* frame)
329    : type(CONGESTION_FEEDBACK_FRAME),
330      congestion_feedback_frame(frame) {
331}
332
333QuicFrame::QuicFrame(QuicStopWaitingFrame* frame)
334    : type(STOP_WAITING_FRAME),
335      stop_waiting_frame(frame) {
336}
337
338QuicFrame::QuicFrame(QuicPingFrame* frame)
339    : type(PING_FRAME),
340      ping_frame(frame) {
341}
342
343QuicFrame::QuicFrame(QuicRstStreamFrame* frame)
344    : type(RST_STREAM_FRAME),
345      rst_stream_frame(frame) {
346}
347
348QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame)
349    : type(CONNECTION_CLOSE_FRAME),
350      connection_close_frame(frame) {
351}
352
353QuicFrame::QuicFrame(QuicGoAwayFrame* frame)
354    : type(GOAWAY_FRAME),
355      goaway_frame(frame) {
356}
357
358QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
359    : type(WINDOW_UPDATE_FRAME),
360      window_update_frame(frame) {
361}
362
363QuicFrame::QuicFrame(QuicBlockedFrame* frame)
364    : type(BLOCKED_FRAME),
365      blocked_frame(frame) {
366}
367
368QuicFecData::QuicFecData() : fec_group(0) {}
369
370ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
371  os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
372     << " least_unacked: " << sent_info.least_unacked;
373  return os;
374}
375
376ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) {
377  os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
378     << " is_truncated: " << received_info.is_truncated
379     << " largest_observed: " << received_info.largest_observed
380     << " delta_time_largest_observed: "
381     << received_info.delta_time_largest_observed.ToMicroseconds()
382     << " missing_packets: [ ";
383  for (SequenceNumberSet::const_iterator it =
384           received_info.missing_packets.begin();
385       it != received_info.missing_packets.end(); ++it) {
386    os << *it << " ";
387  }
388  os << " ] revived_packets: [ ";
389  for (SequenceNumberSet::const_iterator it =
390           received_info.revived_packets.begin();
391       it != received_info.revived_packets.end(); ++it) {
392    os << *it << " ";
393  }
394  os << " ]";
395  return os;
396}
397
398ostream& operator<<(ostream& os, const QuicFrame& frame) {
399  switch (frame.type) {
400  case PADDING_FRAME: {
401      os << "type { PADDING_FRAME } ";
402      break;
403    }
404    case RST_STREAM_FRAME: {
405      os << "type { " << RST_STREAM_FRAME << " } " << *(frame.rst_stream_frame);
406      break;
407    }
408    case CONNECTION_CLOSE_FRAME: {
409      os << "type { CONNECTION_CLOSE_FRAME } "
410         << *(frame.connection_close_frame);
411      break;
412    }
413    case GOAWAY_FRAME: {
414      os << "type { GOAWAY_FRAME } " << *(frame.goaway_frame);
415      break;
416    }
417    case WINDOW_UPDATE_FRAME: {
418      os << "type { WINDOW_UPDATE_FRAME } " << *(frame.window_update_frame);
419      break;
420    }
421    case BLOCKED_FRAME: {
422      os << "type { BLOCKED_FRAME } " << *(frame.blocked_frame);
423      break;
424    }
425    case STREAM_FRAME: {
426      os << "type { STREAM_FRAME } " << *(frame.stream_frame);
427      break;
428    }
429    case ACK_FRAME: {
430      os << "type { ACK_FRAME } " << *(frame.ack_frame);
431      break;
432    }
433    case CONGESTION_FEEDBACK_FRAME: {
434      os << "type { CONGESTION_FEEDBACK_FRAME } "
435         << *(frame.congestion_feedback_frame);
436      break;
437    }
438    case STOP_WAITING_FRAME: {
439      os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame);
440      break;
441    }
442    default: {
443      LOG(ERROR) << "Unknown frame type: " << frame.type;
444      break;
445    }
446  }
447  return os;
448}
449
450ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) {
451  os << "stream_id { " << rst_frame.stream_id << " } "
452     << "error_code { " << rst_frame.error_code << " } "
453     << "error_details { " << rst_frame.error_details << " }\n";
454  return os;
455}
456
457ostream& operator<<(ostream& os,
458                    const QuicConnectionCloseFrame& connection_close_frame) {
459  os << "error_code { " << connection_close_frame.error_code << " } "
460     << "error_details { " << connection_close_frame.error_details << " }\n";
461  return os;
462}
463
464ostream& operator<<(ostream& os, const QuicGoAwayFrame& goaway_frame) {
465  os << "error_code { " << goaway_frame.error_code << " } "
466     << "last_good_stream_id { " << goaway_frame.last_good_stream_id << " } "
467     << "reason_phrase { " << goaway_frame.reason_phrase << " }\n";
468  return os;
469}
470
471ostream& operator<<(ostream& os,
472                    const QuicWindowUpdateFrame& window_update_frame) {
473  os << "stream_id { " << window_update_frame.stream_id << " } "
474     << "byte_offset { " << window_update_frame.byte_offset << " }\n";
475  return os;
476}
477
478ostream& operator<<(ostream& os, const QuicBlockedFrame& blocked_frame) {
479  os << "stream_id { " << blocked_frame.stream_id << " }\n";
480  return os;
481}
482
483ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) {
484  os << "stream_id { " << stream_frame.stream_id << " } "
485     << "fin { " << stream_frame.fin << " } "
486     << "offset { " << stream_frame.offset << " } "
487     << "data { "
488     << QuicUtils::StringToHexASCIIDump(*(stream_frame.GetDataAsString()))
489     << " }\n";
490  return os;
491}
492
493ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
494  os << "sent info { " << ack_frame.sent_info << " } "
495     << "received info { " << ack_frame.received_info << " }\n";
496  return os;
497}
498
499ostream& operator<<(ostream& os,
500                    const QuicCongestionFeedbackFrame& congestion_frame) {
501  os << "type: " << congestion_frame.type;
502  switch (congestion_frame.type) {
503    case kInterArrival: {
504      const CongestionFeedbackMessageInterArrival& inter_arrival =
505          congestion_frame.inter_arrival;
506      os << " received packets: [ ";
507      for (TimeMap::const_iterator it =
508               inter_arrival.received_packet_times.begin();
509           it != inter_arrival.received_packet_times.end(); ++it) {
510        os << it->first << "@" << it->second.ToDebuggingValue() << " ";
511      }
512      os << "]";
513      break;
514    }
515    case kFixRate: {
516      os << " bitrate_in_bytes_per_second: "
517         << congestion_frame.fix_rate.bitrate.ToBytesPerSecond();
518      break;
519    }
520    case kTCP: {
521      const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
522      os << " receive_window: " << tcp.receive_window;
523      break;
524    }
525  }
526  return os;
527}
528
529CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate()
530    : bitrate(QuicBandwidth::Zero()) {
531}
532
533QuicGoAwayFrame::QuicGoAwayFrame()
534    : error_code(QUIC_NO_ERROR),
535      last_good_stream_id(0) {
536}
537
538QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
539                                 QuicStreamId last_good_stream_id,
540                                 const string& reason)
541    : error_code(error_code),
542      last_good_stream_id(last_good_stream_id),
543      reason_phrase(reason) {
544  DCHECK_LE(error_code, numeric_limits<uint8>::max());
545}
546
547QuicData::QuicData(const char* buffer,
548                   size_t length)
549    : buffer_(buffer),
550      length_(length),
551      owns_buffer_(false) {
552}
553
554QuicData::QuicData(char* buffer,
555                   size_t length,
556                   bool owns_buffer)
557    : buffer_(buffer),
558      length_(length),
559      owns_buffer_(owns_buffer) {
560}
561
562QuicData::~QuicData() {
563  if (owns_buffer_) {
564    delete [] const_cast<char*>(buffer_);
565  }
566}
567
568QuicWindowUpdateFrame::QuicWindowUpdateFrame(QuicStreamId stream_id,
569                                             QuicStreamOffset byte_offset)
570    : stream_id(stream_id),
571      byte_offset(byte_offset) {}
572
573QuicBlockedFrame::QuicBlockedFrame(QuicStreamId stream_id)
574    : stream_id(stream_id) {}
575
576QuicPacket::QuicPacket(char* buffer,
577                       size_t length,
578                       bool owns_buffer,
579                       QuicConnectionIdLength connection_id_length,
580                       bool includes_version,
581                       QuicSequenceNumberLength sequence_number_length,
582                       bool is_fec_packet)
583    : QuicData(buffer, length, owns_buffer),
584      buffer_(buffer),
585      is_fec_packet_(is_fec_packet),
586      connection_id_length_(connection_id_length),
587      includes_version_(includes_version),
588      sequence_number_length_(sequence_number_length) {
589}
590
591QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer,
592                                         size_t length)
593    : QuicData(buffer, length) {
594}
595
596QuicEncryptedPacket::QuicEncryptedPacket(char* buffer,
597                                         size_t length,
598                                         bool owns_buffer)
599      : QuicData(buffer, length, owns_buffer) {
600}
601
602StringPiece QuicPacket::FecProtectedData() const {
603  const size_t start_of_fec = GetStartOfFecProtectedData(
604      connection_id_length_, includes_version_, sequence_number_length_);
605  return StringPiece(data() + start_of_fec, length() - start_of_fec);
606}
607
608StringPiece QuicPacket::AssociatedData() const {
609  return StringPiece(
610      data() + kStartOfHashData,
611      GetStartOfEncryptedData(
612          connection_id_length_, includes_version_, sequence_number_length_) -
613      kStartOfHashData);
614}
615
616StringPiece QuicPacket::BeforePlaintext() const {
617  return StringPiece(data(), GetStartOfEncryptedData(connection_id_length_,
618                                                     includes_version_,
619                                                     sequence_number_length_));
620}
621
622StringPiece QuicPacket::Plaintext() const {
623  const size_t start_of_encrypted_data =
624      GetStartOfEncryptedData(
625          connection_id_length_, includes_version_, sequence_number_length_);
626  return StringPiece(data() + start_of_encrypted_data,
627                     length() - start_of_encrypted_data);
628}
629
630RetransmittableFrames::RetransmittableFrames()
631    : encryption_level_(NUM_ENCRYPTION_LEVELS) {
632}
633
634RetransmittableFrames::~RetransmittableFrames() {
635  for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) {
636    switch (it->type) {
637      case PADDING_FRAME:
638        delete it->padding_frame;
639        break;
640      case STREAM_FRAME:
641        delete it->stream_frame;
642        break;
643      case ACK_FRAME:
644        delete it->ack_frame;
645        break;
646      case CONGESTION_FEEDBACK_FRAME:
647        delete it->congestion_feedback_frame;
648        break;
649      case STOP_WAITING_FRAME:
650        delete it->stop_waiting_frame;
651        break;
652      case PING_FRAME:
653        delete it->ping_frame;
654        break;
655      case RST_STREAM_FRAME:
656        delete it->rst_stream_frame;
657        break;
658      case CONNECTION_CLOSE_FRAME:
659        delete it->connection_close_frame;
660        break;
661      case GOAWAY_FRAME:
662        delete it->goaway_frame;
663        break;
664      case WINDOW_UPDATE_FRAME:
665        delete it->window_update_frame;
666        break;
667      case BLOCKED_FRAME:
668        delete it->blocked_frame;
669        break;
670      case NUM_FRAME_TYPES:
671        DCHECK(false) << "Cannot delete type: " << it->type;
672    }
673  }
674  STLDeleteElements(&stream_data_);
675}
676
677const QuicFrame& RetransmittableFrames::AddStreamFrame(
678    QuicStreamFrame* stream_frame) {
679  // Make an owned copy of the stream frame's data.
680  stream_data_.push_back(stream_frame->GetDataAsString());
681  // Ensure the stream frame's IOVector points to the owned copy of the data.
682  stream_frame->data.Clear();
683  stream_frame->data.Append(const_cast<char*>(stream_data_.back()->data()),
684                            stream_data_.back()->size());
685  frames_.push_back(QuicFrame(stream_frame));
686  return frames_.back();
687}
688
689const QuicFrame& RetransmittableFrames::AddNonStreamFrame(
690    const QuicFrame& frame) {
691  DCHECK_NE(frame.type, STREAM_FRAME);
692  frames_.push_back(frame);
693  return frames_.back();
694}
695
696IsHandshake RetransmittableFrames::HasCryptoHandshake() const {
697  for (size_t i = 0; i < frames().size(); ++i) {
698    if (frames()[i].type == STREAM_FRAME &&
699        frames()[i].stream_frame->stream_id == kCryptoStreamId) {
700      return IS_HANDSHAKE;
701    }
702  }
703  return NOT_HANDSHAKE;
704}
705
706void RetransmittableFrames::set_encryption_level(EncryptionLevel level) {
707  encryption_level_ = level;
708}
709
710SerializedPacket::SerializedPacket(
711    QuicPacketSequenceNumber sequence_number,
712    QuicSequenceNumberLength sequence_number_length,
713    QuicPacket* packet,
714    QuicPacketEntropyHash entropy_hash,
715    RetransmittableFrames* retransmittable_frames)
716    : sequence_number(sequence_number),
717      sequence_number_length(sequence_number_length),
718      packet(packet),
719      entropy_hash(entropy_hash),
720      retransmittable_frames(retransmittable_frames) {
721}
722
723SerializedPacket::~SerializedPacket() {}
724
725QuicEncryptedPacket* QuicEncryptedPacket::Clone() const {
726  char* buffer = new char[this->length()];
727  memcpy(buffer, this->data(), this->length());
728  return new QuicEncryptedPacket(buffer, this->length(), true);
729}
730
731ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) {
732  os << s.length() << "-byte data";
733  return os;
734}
735
736QuicConsumedData::QuicConsumedData(size_t bytes_consumed,
737                                   bool fin_consumed)
738      : bytes_consumed(bytes_consumed),
739        fin_consumed(fin_consumed) {
740}
741
742ostream& operator<<(ostream& os, const QuicConsumedData& s) {
743  os << "bytes_consumed: " << s.bytes_consumed
744     << " fin_consumed: " << s.fin_consumed;
745  return os;
746}
747
748WriteResult::WriteResult()
749    : status(WRITE_STATUS_ERROR),
750      bytes_written(0) {
751}
752
753WriteResult::WriteResult(WriteStatus status,
754                         int bytes_written_or_error_code)
755    : status(status),
756      bytes_written(bytes_written_or_error_code) {
757}
758
759}  // namespace net
760