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 46 matching lines @@
   virtual ~QuicFramerVisitorInterface() {}
 
   // Called if an error is detected in the QUIC protocol.
   virtual void OnError(QuicFramer* framer) = 0;
 
   // Called only when |is_server_| is true and the the framer gets a packet with
   // version flag true and the version on the packet doesn't match
   // |quic_version_|. The visitor should return true after it updates the
   // version of the |framer_| to |received_version| or false to stop processing
   // this packet.
-  virtual bool OnProtocolVersionMismatch(QuicVersionTag received_version) = 0;
+  virtual bool OnProtocolVersionMismatch(QuicTag received_version) = 0;
 
   // Called when a new packet has been received, before it
   // has been validated or processed.
   virtual void OnPacket() = 0;
 
   // Called when a public reset packet has been parsed but has not yet
   // been validated.
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) = 0;
 
@@ skipping 68 matching lines @@
 };
 
 // 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(QuicVersionTag quic_version,
+  QuicFramer(QuicTag quic_version,
              QuicTime creation_time,
              bool is_server);
 
   virtual ~QuicFramer();
 
   // Returns true if |version| is a supported protocol version.
-  bool IsSupportedVersion(QuicVersionTag version);
+  bool IsSupportedVersion(QuicTag version);
 
   // 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
   // last missing packet which fit in the outgoing ack.
   static QuicPacketSequenceNumber CalculateLargestObserved(
       const SequenceNumberSet& missing_packets,
       SequenceNumberSet::const_iterator last_written);
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
   void set_visitor(QuicFramerVisitorInterface* visitor) {
     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;
   }
 
-  QuicVersionTag version() const {
+  QuicTag version() const {
     return quic_version_;
   }
 
-  void set_version(QuicVersionTag version) {
+  void set_version(QuicTag version) {
     DCHECK(IsSupportedVersion(version));
     quic_version_ = version;
   }
 
   // Set entropy calculator to be called from the framer when it needs the
   // entropy of a truncated ack frame. An entropy calculator must be set or else
   // the framer will likely crash. If this is called multiple times, only the
   // last visitor will be used.
   void set_entropy_calculator(
       QuicReceivedEntropyHashCalculatorInterface* entropy_calculator) {
@@ skipping 62 matching lines @@
   // packet could not be created.
   SerializedPacket ConstructFecPacket(const QuicPacketHeader& header,
                                       const QuicFecData& fec);
 
   // Returns a new public reset packet, owned by the caller.
   static QuicEncryptedPacket* ConstructPublicResetPacket(
       const QuicPublicResetPacket& packet);
 
   QuicEncryptedPacket* ConstructVersionNegotiationPacket(
       const QuicPacketPublicHeader& header,
-      const QuicVersionTagList& supported_versions);
+      const QuicTagVector& supported_versions);
 
   // SetDecrypter sets the primary decrypter, replacing any that already exists,
   // and takes ownership. If an alternative decrypter is in place then the
   // function DCHECKs. This is intended for cases where one knows that future
   // packets will be using the new decrypter and the previous decrypter is not
   // obsolete.
   void SetDecrypter(QuicDecrypter* decrypter);
 
   // SetAlternativeDecrypter sets a decrypter that may be used to decrypt
   // future packets and takes ownership of it. If |latch_once_used| is true,
   // then the first time that the decrypter is successful it will replace the
   // primary decrypter. Otherwise both decrypters will remain active and the
   // primary decrypter will be the one last used.
   void SetAlternativeDecrypter(QuicDecrypter* decrypter,
                                bool latch_once_used);
 
   const QuicDecrypter* decrypter() const;
   const QuicDecrypter* alternative_decrypter() const;
 
   // Changes the encrypter used for level |level| to |encrypter|. The function
   // takes ownership of |encrypter|.
   void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
   const QuicEncrypter* encrypter(EncryptionLevel level) const;
 
+  // SwapCryptersForTest exchanges the state of the crypters with |other|. To
+  // be used in tests only.
+  void SwapCryptersForTest(QuicFramer* other);
+
   // Returns a new encrypted packet, owned by the caller.
   QuicEncryptedPacket* EncryptPacket(EncryptionLevel level,
                                      QuicPacketSequenceNumber sequence_number,
                                      const QuicPacket& packet);
 
   // Returns the maximum length of plaintext that can be encrypted
   // to ciphertext no larger than |ciphertext_size|.
   size_t GetMaxPlaintextSize(size_t ciphertext_size);
 
   const std::string& detailed_error() { return detailed_error_; }
@@ skipping 80 matching lines @@
   scoped_ptr<QuicDataReader> reader_;
   QuicFramerVisitorInterface* visitor_;
   QuicFecBuilderInterface* fec_builder_;
   QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
   QuicErrorCode error_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketSequenceNumber last_sequence_number_;
   // Buffer containing decrypted payload data during parsing.
   scoped_ptr<QuicData> decrypted_;
   // Version of the protocol being used.
-  QuicVersionTag quic_version_;
+  QuicTag quic_version_;
   // 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_