Land Recent QUIC Changes

net/quic/quic_protocol.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_protocol.h"
 #include "base/stl_util.h"
 
 using base::StringPiece;
 using std::map;
 using std::numeric_limits;
@@ skipping 15 matching lines @@
 
 size_t GetStartOfFecProtectedData(bool include_version) {
   return GetPacketHeaderSize(include_version);
 }
 
 size_t GetStartOfEncryptedData(bool include_version) {
   return  GetPacketHeaderSize(include_version) - kPrivateFlagsSize -
       kFecGroupSize;
 }
 
+QuicPacketPublicHeader::QuicPacketPublicHeader() {}
+
+QuicPacketPublicHeader::QuicPacketPublicHeader(
+    const QuicPacketPublicHeader& other)
+    : guid(other.guid),
+      reset_flag(other.reset_flag),
+      version_flag(other.version_flag),
+      versions(other.versions) {
+}
+
+QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
+
+QuicPacketPublicHeader& QuicPacketPublicHeader::operator=(
+    const QuicPacketPublicHeader& other) {
+  guid = other.guid;
+  reset_flag = other.reset_flag;
+  version_flag = other.version_flag;
+  // Window's STL crashes when empty std::vectors are copied.
+  if (other.versions.size() > 0)
+    versions = other.versions;
+  return *this;
+}
+
 QuicStreamFrame::QuicStreamFrame() {}
 
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
                                  StringPiece data)
     : stream_id(stream_id),
       fin(fin),
       offset(offset),
       data(data) {
 }
 
 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
   os << "{ guid: " << header.public_header.guid
      << ", reset_flag: " << header.public_header.reset_flag
-     << ", version_flag: " << header.public_header.version_flag
-     << ", fec_flag: " << header.fec_flag
+     << ", version_flag: " << header.public_header.version_flag;
+  if (header.public_header.version_flag) {
+    os << " version: ";
+    for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
+      os << header.public_header.versions[0] << " ";
+    }
+  }
+  os << ", fec_flag: " << header.fec_flag
      << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", sequence_number: " << header.packet_sequence_number
      << ", fec_group: " << header.fec_group<< "}\n";
   return os;
 }
 
 // TODO(ianswett): Initializing largest_observed to 0 should not be necessary.
 ReceivedPacketInfo::ReceivedPacketInfo()
-    : largest_observed(0) {
+    : largest_observed(0),
+      delta_time_largest_observed(QuicTime::Delta::Infinite()) {
 }
 
 ReceivedPacketInfo::~ReceivedPacketInfo() {}
 
 bool IsAwaitingPacket(const ReceivedPacketInfo& received_info,
                       QuicPacketSequenceNumber sequence_number) {
   return sequence_number > received_info.largest_observed ||
       ContainsKey(received_info.missing_packets, sequence_number);
 }
 
 void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
                                  QuicPacketSequenceNumber lower,
                                  QuicPacketSequenceNumber higher) {
   for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
     received_info->missing_packets.insert(i);
   }
 }
 
 SentPacketInfo::SentPacketInfo() {}
 
 SentPacketInfo::~SentPacketInfo() {}
 
 // Testing convenience method.
 QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_observed,
+                           QuicTime largest_observed_receive_time,
                            QuicPacketSequenceNumber least_unacked) {
   received_info.largest_observed = largest_observed;
   received_info.entropy_hash = 0;
   sent_info.least_unacked = least_unacked;
   sent_info.entropy_hash = 0;
 }
 
 ostream& operator<<(ostream& os, const SentPacketInfo& sent_info) {
   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
      << " least_unacked: " << sent_info.least_unacked;
@@ skipping 175 matching lines @@
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
   os << "bytes_consumed: " << s.bytes_consumed
      << " fin_consumed: " << s.fin_consumed;
   return os;
 }
 
 }  // namespace net