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(QuicTag received_version) = 0;
+  virtual bool OnProtocolVersionMismatch(QuicVersion 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 56 matching lines @@
 // framed, should it get truncated.
 class NET_EXPORT_PRIVATE QuicReceivedEntropyHashCalculatorInterface {
  public:
   virtual ~QuicReceivedEntropyHashCalculatorInterface() {}
 
   // When an ack frame gets truncated while being framed the received
   // entropy of the ack frame needs to be calculated since the some of the
   // missing packets are not added and the largest observed might be lowered.
   // This should return the received entropy hash of the packets received up to
   // and including |sequence_number|.
-  virtual QuicPacketEntropyHash ReceivedEntropyHash(
+  virtual QuicPacketEntropyHash EntropyHash(
       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(QuicTag quic_version,
+  QuicFramer(QuicVersion quic_version,
              QuicTime creation_time,
              bool is_server);
 
   virtual ~QuicFramer();
 
   // Returns true if |version| is a supported protocol version.
-  bool IsSupportedVersion(QuicTag 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
   // 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;
   }
 
-  QuicTag version() const {
+  QuicVersion version() const {
     return quic_version_;
   }
 
-  void set_version(QuicTag version) {
+  void set_version(const QuicVersion version) {
     DCHECK(IsSupportedVersion(version));
     quic_version_ = 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;
+  }
+
   // 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(
+  // last calculator will be used.
+  void set_received_entropy_calculator(
       QuicReceivedEntropyHashCalculatorInterface* entropy_calculator) {
     entropy_calculator_ = entropy_calculator;
   }
 
   QuicErrorCode error() const {
     return error_;
   }
 
   // Pass a UDP packet into the framer for parsing.
   // Return true if the packet was processed succesfully. |packet| must be a
@@ skipping 67 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 QuicTagVector& supported_versions);
+      const QuicVersionVector& 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,
@@ skipping 113 matching lines @@
   QuicFecBuilderInterface* fec_builder_;
   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.
-  QuicTag quic_version_;
+  QuicVersion 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_