Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

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"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 124 matching lines @@
 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
   switch (version) {
     case QUIC_VERSION_25:
       return MakeQuicTag('Q', '0', '2', '5');
     case QUIC_VERSION_26:
       return MakeQuicTag('Q', '0', '2', '6');
     case QUIC_VERSION_27:
       return MakeQuicTag('Q', '0', '2', '7');
     case QUIC_VERSION_28:
       return MakeQuicTag('Q', '0', '2', '8');
+    case QUIC_VERSION_29:
+      return MakeQuicTag('Q', '0', '2', '9');
+    case QUIC_VERSION_30:
+      return MakeQuicTag('Q', '0', '3', '0');
     default:
       // This shold be an ERROR because we should never attempt to convert an
       // invalid QuicVersion to be written to the wire.
       LOG(ERROR) << "Unsupported QuicVersion: " << version;
       return 0;
   }
 }
 
 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
@@ skipping 10 matching lines @@
 #define RETURN_STRING_LITERAL(x) \
 case x: \
 return #x
 
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_25);
     RETURN_STRING_LITERAL(QUIC_VERSION_26);
     RETURN_STRING_LITERAL(QUIC_VERSION_27);
     RETURN_STRING_LITERAL(QUIC_VERSION_28);
+    RETURN_STRING_LITERAL(QUIC_VERSION_29);
+    RETURN_STRING_LITERAL(QUIC_VERSION_30);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
 }
 
 string QuicVersionVectorToString(const QuicVersionVector& versions) {
   string result = "";
   for (size_t i = 0; i < versions.size(); ++i) {
     if (i != 0) {
       result.append(",");
@@ skipping 43 matching lines @@
     : entropy_hash(0),
       least_unacked(0) {
 }
 
 QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 
 QuicAckFrame::QuicAckFrame()
     : entropy_hash(0),
       is_truncated(false),
       largest_observed(0),
-      delta_time_largest_observed(QuicTime::Delta::Infinite()) {}
+      delta_time_largest_observed(QuicTime::Delta::Infinite()),
+      latest_revived_packet(0) {}
 
 QuicAckFrame::~QuicAckFrame() {}
 
 QuicRstStreamErrorCode AdjustErrorForVersion(QuicRstStreamErrorCode error_code,
                                              QuicVersion /*version*/) {
   return error_code;
 }
 
 QuicRstStreamFrame::QuicRstStreamFrame()
     : stream_id(0), error_code(QUIC_STREAM_NO_ERROR), byte_offset(0) {}
@@ skipping 212 matching lines @@
   }
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
   os << "entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
      << " largest_observed: " << ack_frame.largest_observed
      << " delta_time_largest_observed: "
      << ack_frame.delta_time_largest_observed.ToMicroseconds()
      << " missing_packets: [ " << ack_frame.missing_packets
-     << " ] is_truncated: " << ack_frame.is_truncated;
-  os << " revived_packets: [ ";
-  for (PacketNumberSet::const_iterator it = ack_frame.revived_packets.begin();
-       it != ack_frame.revived_packets.end(); ++it) {
-    os << *it << " ";
-  }
-  os << " ] received_packets: [ ";
+     << " ] is_truncated: " << ack_frame.is_truncated
+     << " revived_packet: " << ack_frame.latest_revived_packet
+     << " received_packets: [ ";
   for (const std::pair<QuicPacketNumber, QuicTime>& p :
        ack_frame.received_packet_times) {
     os << p.first << " at " << p.second.ToDebuggingValue() << " ";
   }
   os << " ]";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicFrame& frame) {
   switch (frame.type) {
@@ skipping 280 matching lines @@
     bool has_stop_waiting)
     : packet(packet),
       retransmittable_frames(retransmittable_frames),
       packet_number(packet_number),
       packet_number_length(packet_number_length),
       entropy_hash(entropy_hash),
       is_fec_packet(false),
       has_ack(has_ack),
       has_stop_waiting(has_stop_waiting) {}
 
+SerializedPacket::SerializedPacket(
+    QuicPacketNumber packet_number,
+    QuicPacketNumberLength packet_number_length,
+    char* encrypted_buffer,
+    size_t encrypted_length,
+    bool owns_buffer,
+    QuicPacketEntropyHash entropy_hash,
+    RetransmittableFrames* retransmittable_frames,
+    bool has_ack,
+    bool has_stop_waiting)
+    : SerializedPacket(packet_number,
+                       packet_number_length,
+                       new QuicEncryptedPacket(encrypted_buffer,
+                                               encrypted_length,
+                                               owns_buffer),
+                       entropy_hash,
+                       retransmittable_frames,
+                       has_ack,
+                       has_stop_waiting) {}
+
 SerializedPacket::~SerializedPacket() {}
 
 QuicEncryptedPacket* QuicEncryptedPacket::Clone() const {
   char* buffer = new char[this->length()];
   memcpy(buffer, this->data(), this->length());
   return new QuicEncryptedPacket(buffer, this->length(), true);
 }
 
 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) {
   os << s.length() << "-byte data";
@@ skipping 26 matching lines @@
       sent_time(sent_time),
       transmission_type(transmission_type),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(is_fec_packet),
       all_transmissions(nullptr) {}
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net