Landing Recent QUIC changes until 9:41 AM, Oct 10, 2016 UTC-7

net/quic/core/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/core/quic_protocol.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
@@ skipping 60 matching lines @@
 
 QuicPacketPublicHeader::QuicPacketPublicHeader(
     const QuicPacketPublicHeader& other) = default;
 
 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
 
 QuicPacketHeader::QuicPacketHeader()
     : packet_number(0),
       path_id(kDefaultPathId),
       entropy_flag(false),
-      entropy_hash(0),
-      fec_flag(false) {}
+      entropy_hash(0) {}
 
 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header)
     : public_header(header),
       packet_number(0),
       path_id(kDefaultPathId),
       entropy_flag(false),
-      entropy_hash(0),
-      fec_flag(false) {}
+      entropy_hash(0) {}
 
 QuicPacketHeader::QuicPacketHeader(const QuicPacketHeader& other) = default;
 
 QuicPublicResetPacket::QuicPublicResetPacket()
     : nonce_proof(0), rejected_packet_number(0) {}
 
 QuicPublicResetPacket::QuicPublicResetPacket(
     const QuicPacketPublicHeader& header)
     : public_header(header), nonce_proof(0), rejected_packet_number(0) {}
 
@@ skipping 79 matching lines @@
 }
 
 QuicVersionVector CurrentSupportedVersions() {
   return FilterSupportedVersions(AllSupportedVersions());
 }
 
 QuicVersionVector FilterSupportedVersions(QuicVersionVector versions) {
   QuicVersionVector filtered_versions(versions.size());
   filtered_versions.clear();  // Guaranteed by spec not to change capacity.
   for (QuicVersion version : versions) {
-    if (version < QUIC_VERSION_32) {
-      if (!FLAGS_quic_disable_pre_32 && !FLAGS_quic_disable_pre_34) {
-        filtered_versions.push_back(version);
-      }
-    } else if (version < QUIC_VERSION_34) {
+    if (version < QUIC_VERSION_34) {
       if (!FLAGS_quic_disable_pre_34) {
         filtered_versions.push_back(version);
       }
     } else if (version == QUIC_VERSION_35) {
       if (FLAGS_quic_enable_version_35) {
         filtered_versions.push_back(version);
       }
     } else if (version == QUIC_VERSION_36) {
       if (FLAGS_quic_enable_version_35 && FLAGS_quic_enable_version_36_v2) {
         filtered_versions.push_back(version);
@@ skipping 11 matching lines @@
   if (index >= 0 && index < version_count) {
     version.push_back(versions[index]);
   } else {
     version.push_back(QUIC_VERSION_UNSUPPORTED);
   }
   return version;
 }
 
 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
   switch (version) {
-    case QUIC_VERSION_30:
-      return MakeQuicTag('Q', '0', '3', '0');
-    case QUIC_VERSION_31:
-      return MakeQuicTag('Q', '0', '3', '1');
     case QUIC_VERSION_32:
       return MakeQuicTag('Q', '0', '3', '2');
     case QUIC_VERSION_33:
       return MakeQuicTag('Q', '0', '3', '3');
     case QUIC_VERSION_34:
       return MakeQuicTag('Q', '0', '3', '4');
     case QUIC_VERSION_35:
       return MakeQuicTag('Q', '0', '3', '5');
     case QUIC_VERSION_36:
       return MakeQuicTag('Q', '0', '3', '6');
@@ skipping 16 matching lines @@
            << QuicUtils::TagToString(version_tag);
   return QUIC_VERSION_UNSUPPORTED;
 }
 
 #define RETURN_STRING_LITERAL(x) \
   case x:                        \
     return #x
 
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
-    RETURN_STRING_LITERAL(QUIC_VERSION_30);
-    RETURN_STRING_LITERAL(QUIC_VERSION_31);
     RETURN_STRING_LITERAL(QUIC_VERSION_32);
     RETURN_STRING_LITERAL(QUIC_VERSION_33);
     RETURN_STRING_LITERAL(QUIC_VERSION_34);
     RETURN_STRING_LITERAL(QUIC_VERSION_35);
     RETURN_STRING_LITERAL(QUIC_VERSION_36);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
 }
 
@@ skipping 29 matching lines @@
     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
       os << " ";
       os << QuicVersionToString(header.public_header.versions[i]);
     }
   }
   if (header.public_header.nonce != nullptr) {
     os << ", diversification_nonce: "
        << QuicUtils::HexEncode(StringPiece(header.public_header.nonce->data(),
                                            header.public_header.nonce->size()));
   }
-  os << ", fec_flag: " << header.fec_flag
-     << ", entropy_flag: " << header.entropy_flag
+  os << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", path_id: " << static_cast<int>(header.path_id)
      << ", packet_number: " << header.packet_number << " }\n";
   return os;
 }
 
 bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
                       QuicPacketNumber packet_number,
                       QuicPacketNumber peer_least_packet_awaiting_ack) {
   if (ack_frame.missing) {
@@ skipping 390 matching lines @@
 }
 
 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) {
   os << s.length() << "-byte data";
   return os;
 }
 
 QuicReceivedPacket::QuicReceivedPacket(const char* buffer,
                                        size_t length,
                                        QuicTime receipt_time)
-    : QuicReceivedPacket(buffer,
-                         length,
-                         receipt_time,
-                         false /* owns_buffer */) {}
+    : QuicEncryptedPacket(buffer, length),
+      receipt_time_(receipt_time),
+      ttl_(0) {}
 
 QuicReceivedPacket::QuicReceivedPacket(const char* buffer,
                                        size_t length,
                                        QuicTime receipt_time,
                                        bool owns_buffer)
-    : QuicReceivedPacket(buffer,
-                         length,
-                         receipt_time,
-                         owns_buffer,
-                         false /* potentially_small_mtu */,
-                         -1 /* ttl */,
-                         false /* ttl_valid */) {}
+    : QuicEncryptedPacket(buffer, length, owns_buffer),
+      receipt_time_(receipt_time),
+      ttl_(0) {}
 
 QuicReceivedPacket::QuicReceivedPacket(const char* buffer,
                                        size_t length,
                                        QuicTime receipt_time,
                                        bool owns_buffer,
-                                       bool potentially_small_mtu,
                                        int ttl,
                                        bool ttl_valid)
     : QuicEncryptedPacket(buffer, length, owns_buffer),
       receipt_time_(receipt_time),
-      ttl_(ttl_valid ? ttl : -1),
-      potentially_small_mtu_(potentially_small_mtu) {}
+      ttl_(ttl_valid ? ttl : -1) {}
 
 QuicReceivedPacket* QuicReceivedPacket::Clone() const {
   char* buffer = new char[this->length()];
   memcpy(buffer, this->data(), this->length());
   return new QuicReceivedPacket(buffer, this->length(), receipt_time(), true,
-                                potentially_small_mtu(), ttl(), ttl() >= 0);
+                                ttl(), ttl() >= 0);
 }
 
 ostream& operator<<(ostream& os, const QuicReceivedPacket& s) {
   os << s.length() << "-byte data";
   return os;
 }
 
 StringPiece QuicPacket::AssociatedData(QuicVersion version) const {
   return StringPiece(
       data(), GetStartOfEncryptedData(version, connection_id_length_,
                                       includes_version_, includes_path_id_,
                                       includes_diversification_nonce_,
                                       packet_number_length_));
 }
 
 StringPiece QuicPacket::Plaintext(QuicVersion version) const {
   const size_t start_of_encrypted_data = GetStartOfEncryptedData(
       version, connection_id_length_, includes_version_, includes_path_id_,
       includes_diversification_nonce_, packet_number_length_);
   return StringPiece(data() + start_of_encrypted_data,
                      length() - start_of_encrypted_data);
 }
 
 QuicVersionManager::QuicVersionManager(QuicVersionVector supported_versions)
-    : disable_pre_32_(FLAGS_quic_disable_pre_32),
-      disable_pre_34_(FLAGS_quic_disable_pre_34),
+    : disable_pre_34_(FLAGS_quic_disable_pre_34),
       enable_version_35_(FLAGS_quic_enable_version_35),
       enable_version_36_(FLAGS_quic_enable_version_36_v2),
       allowed_supported_versions_(supported_versions),
       filtered_supported_versions_(
           FilterSupportedVersions(supported_versions)) {}
 
 QuicVersionManager::~QuicVersionManager() {}
 
 const QuicVersionVector& QuicVersionManager::GetSupportedVersions() {
-  if (disable_pre_32_ != FLAGS_quic_disable_pre_32 ||
-      disable_pre_34_ != FLAGS_quic_disable_pre_34 ||
+  if (disable_pre_34_ != FLAGS_quic_disable_pre_34 ||
       enable_version_35_ != FLAGS_quic_enable_version_35 ||
       enable_version_36_ != FLAGS_quic_enable_version_36_v2) {
-    disable_pre_32_ = FLAGS_quic_disable_pre_32;
     disable_pre_34_ = FLAGS_quic_disable_pre_34;
     enable_version_35_ = FLAGS_quic_enable_version_35;
     enable_version_36_ = FLAGS_quic_enable_version_36_v2;
     filtered_supported_versions_ =
         FilterSupportedVersions(allowed_supported_versions_);
   }
   return filtered_supported_versions_;
 }
 
 AckListenerWrapper::AckListenerWrapper(QuicAckListenerInterface* listener,
@@ skipping 62 matching lines @@
       is_unackable(false),
       has_crypto_handshake(has_crypto_handshake),
       num_padding_bytes(num_padding_bytes),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net