Land Recent QUIC changes.

net/quic/quic_framer.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_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 132 matching lines @@
       QuicPacketSequenceNumber sequence_number) const = 0;
 };
 
 // Class for parsing and constructing QUIC packets.  It has a
 // QuicFramerVisitorInterface that is called when packets are parsed.
 // It also has a QuicFecBuilder that is called when packets are constructed
 // in order to generate FEC data for subsequently building FEC packets.
 class NET_EXPORT_PRIVATE QuicFramer {
  public:
   // Constructs a new framer that installs a kNULL QuicEncrypter and
-  // QuicDecrypter for level ENCRYPTION_NONE.
-  QuicFramer(QuicVersion quic_version,
+  // QuicDecrypter for level ENCRYPTION_NONE. |supported_versions| specifies the
+  // list of supported QUIC versions. |quic_version_| is set to the maximum
+  // version in |supported_versions|.
+  QuicFramer(const QuicVersionVector& supported_versions,
              QuicTime creation_time,
              bool is_server);
 
   virtual ~QuicFramer();
 
   // Returns true if |version| is a supported protocol version.
   bool IsSupportedVersion(const QuicVersion version) const;
 
   // Calculates the largest observed packet to advertise in the case an Ack
   // Frame was truncated.  last_written in this case is the iterator for the
@@ skipping 10 matching lines @@
     visitor_ = visitor;
   }
 
   // Set a builder to be called from the framer when building FEC protected
   // packets.  If this is called multiple times, only the last builder
   // will be used.  The builder need not be set.
   void set_fec_builder(QuicFecBuilderInterface* builder) {
     fec_builder_ = builder;
   }
 
+  const QuicVersionVector& supported_versions() const {
+    return supported_versions_;
+  }
+
   QuicVersion version() const {
     return quic_version_;
   }
 
   void set_version(const QuicVersion version);
 
   // Does not DCHECK for supported version. Used by tests to set unsupported
   // version to trigger version negotiation.
   void set_version_for_tests(const QuicVersion version) {
     quic_version_ = version;
@@ skipping 227 matching lines @@
   QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
   QuicErrorCode error_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketSequenceNumber last_sequence_number_;
   // Updated by WritePacketHeader.
   QuicGuid last_serialized_guid_;
   // Buffer containing decrypted payload data during parsing.
   scoped_ptr<QuicData> decrypted_;
   // Version of the protocol being used.
   QuicVersion quic_version_;
+  // This vector contains QUIC versions which we currently support.
+  // This should be ordered such that the highest supported version is the first
+  // element, with subsequent elements in descending order (versions can be
+  // skipped as necessary).
+  QuicVersionVector supported_versions_;
   // Primary decrypter used to decrypt packets during parsing.
   scoped_ptr<QuicDecrypter> decrypter_;
   // Alternative decrypter that can also be used to decrypt packets.
   scoped_ptr<QuicDecrypter> alternative_decrypter_;
   // alternative_decrypter_latch_is true if, when |alternative_decrypter_|
   // successfully decrypts a packet, we should install it as the only
   // decrypter.
   bool alternative_decrypter_latch_;
   // Encrypters used to encrypt packets via EncryptPacket().
   scoped_ptr<QuicEncrypter> encrypter_[NUM_ENCRYPTION_LEVELS];
   // Tracks if the framer is being used by the entity that received the
   // connection or the entity that initiated it.
   bool is_server_;
   // The time this frames was created.  Time written to the wire will be
   // written as a delta from this value.
   QuicTime creation_time_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_