Landing Recent QUIC changes until 4AM, Aug 7, 2016 UTC-4

net/quic/core/quic_protocol.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 369 matching lines @@
 //
 // IMPORTANT: if you are adding to this list, follow the instructions at
 // http://sites/quic/adding-and-removing-versions
 static const QuicVersion kSupportedQuicVersions[] = {
     QUIC_VERSION_36, QUIC_VERSION_35, QUIC_VERSION_34, QUIC_VERSION_33,
     QUIC_VERSION_32, QUIC_VERSION_31, QUIC_VERSION_30};
 
 typedef std::vector<QuicVersion> QuicVersionVector;
 
 // Returns a vector of QUIC versions in kSupportedQuicVersions.
-NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions();
+NET_EXPORT_PRIVATE QuicVersionVector AllSupportedVersions();
+
+// Returns a vector of QUIC versions from kSupportedQuicVersions which exclude
+// any versions which are disabled by flags.
+NET_EXPORT_PRIVATE QuicVersionVector CurrentSupportedVersions();
 
 // Returns a vector of QUIC versions from |versions| which exclude any versions
 // which are disabled by flags.
 NET_EXPORT_PRIVATE QuicVersionVector
 FilterSupportedVersions(QuicVersionVector versions);
 
+// Returns QUIC version of |index| in result of |versions|. Returns
+// QUIC_VERSION_UNSUPPORTED if |index| is out of bounds.
+NET_EXPORT_PRIVATE QuicVersionVector
+VersionOfIndex(const QuicVersionVector& versions, int index);
+
 // QuicTag is written to and read from the wire, but we prefer to use
 // the more readable QuicVersion at other levels.
 // Helper function which translates from a QuicVersion to a QuicTag. Returns 0
 // if QuicVersion is unsupported.
 NET_EXPORT_PRIVATE QuicTag QuicVersionToQuicTag(const QuicVersion version);
 
 // Returns appropriate QuicVersion from a QuicTag.
 // Returns QUIC_VERSION_UNSUPPORTED if version_tag cannot be understood.
 NET_EXPORT_PRIVATE QuicVersion QuicTagToQuicVersion(const QuicTag version_tag);
 
@@ skipping 845 matching lines @@
 };
 // QuicFrameType consumes 8 bytes with padding.
 static_assert(sizeof(QuicFrame) <= 16,
               "Frames larger than 8 bytes should be referenced by pointer.");
 
 typedef std::vector<QuicFrame> QuicFrames;
 
 class NET_EXPORT_PRIVATE QuicData {
  public:
   QuicData(const char* buffer, size_t length);
-  QuicData(char* buffer, size_t length, bool owns_buffer);
+  QuicData(const char* buffer, size_t length, bool owns_buffer);
   virtual ~QuicData();
 
   base::StringPiece AsStringPiece() const {
     return base::StringPiece(data(), length());
   }
 
   const char* data() const { return buffer_; }
   size_t length() const { return length_; }
   bool owns_buffer() const { return owns_buffer_; }
 
@@ skipping 31 matching lines @@
   const bool includes_path_id_;
   const bool includes_diversification_nonce_;
   const QuicPacketNumberLength packet_number_length_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacket);
 };
 
 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
  public:
   QuicEncryptedPacket(const char* buffer, size_t length);
-  QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer);
+  QuicEncryptedPacket(const char* buffer, size_t length, bool owns_buffer);
 
   // Clones the packet into a new packet which owns the buffer.
   QuicEncryptedPacket* Clone() const;
 
   // By default, gtest prints the raw bytes of an object. The bool data
   // member (in the base class QuicData) causes this object to have padding
   // bytes, which causes the default gtest object printer to read
   // uninitialize memory. So we need to teach gtest how to print this object.
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os,
       const QuicEncryptedPacket& s);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 // A received encrypted QUIC packet, with a recorded time of receipt.
 class NET_EXPORT_PRIVATE QuicReceivedPacket : public QuicEncryptedPacket {
  public:
   QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time);
-  QuicReceivedPacket(char* buffer,
+  QuicReceivedPacket(const char* buffer,
                      size_t length,
                      QuicTime receipt_time,
                      bool owns_buffer);
+  QuicReceivedPacket(const char* buffer,
+                     size_t length,
+                     QuicTime receipt_time,
+                     bool owns_buffer,
+                     int ttl,
+                     bool ttl_valid);
 
   // Clones the packet into a new packet which owns the buffer.
   QuicReceivedPacket* Clone() const;
 
   // Returns the time at which the packet was received.
   QuicTime receipt_time() const { return receipt_time_; }
 
+  // This is the TTL of the packet, assuming ttl_vaild_ is true.
+  int ttl() const { return ttl_; }
+
   // By default, gtest prints the raw bytes of an object. The bool data
   // member (in the base class QuicData) causes this object to have padding
   // bytes, which causes the default gtest object printer to read
   // uninitialize memory. So we need to teach gtest how to print this object.
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os,
       const QuicReceivedPacket& s);
 
  private:
   const QuicTime receipt_time_;
+  int ttl_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicReceivedPacket);
 };
 
 // Pure virtual class to listen for packet acknowledgements.
 class NET_EXPORT_PRIVATE QuicAckListenerInterface
     : public base::RefCounted<QuicAckListenerInterface> {
  public:
   QuicAckListenerInterface() {}
 
@@ skipping 29 matching lines @@
  public:
   explicit QuicVersionManager(QuicVersionVector supported_versions);
   ~QuicVersionManager();
 
   // Returns supported versions based on flags.
   const QuicVersionVector& GetSupportedVersions();
 
  private:
   // FLAGS_quic_enable_version_35
   bool enable_quic_version_35_;
-  // FLAGS_quic_enable_version_36
+  // FLAGS_quic_enable_version_36_v2
   bool enable_quic_version_36_;
   // The list of versions that may be supported.
   QuicVersionVector allowed_supported_versions_;
   // This vector contains QUIC versions which are currently supported based
   // on flags.
   QuicVersionVector filtered_supported_versions_;
 };
 
 struct NET_EXPORT_PRIVATE AckListenerWrapper {
   AckListenerWrapper(QuicAckListenerInterface* listener,
@@ skipping 119 matching lines @@
       : iov(iov), iov_count(iov_count), total_length(total_length) {}
 
   const struct iovec* iov;
   const int iov_count;
   const size_t total_length;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_