Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

net/quic/core/quic_packet_creator.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.
 //
 // Accumulates frames for the next packet until more frames no longer fit or
 // it's time to create a packet from them. If multipath enabled, only creates
 // packets on one path at the same time. Currently, next packet number is
 // tracked per-path.
 
 #ifndef NET_QUIC_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_QUIC_PACKET_CREATOR_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 #include "net/quic/core/quic_framer.h"
+#include "net/quic/core/quic_iovector.h"
 #include "net/quic/core/quic_protocol.h"
 
 namespace net {
 namespace test {
 class QuicPacketCreatorPeer;
 }
 
-class QuicRandom;
-
 class NET_EXPORT_PRIVATE QuicPacketCreator {
  public:
   // A delegate interface for further processing serialized packet.
   class NET_EXPORT_PRIVATE DelegateInterface
       : public QuicConnectionCloseDelegateInterface {
    public:
     ~DelegateInterface() override {}
     // Called when a packet is serialized. Delegate does not take the ownership
     // of |serialized_packet|, but takes ownership of any frames it removes
     // from |packet.retransmittable_frames|.
     virtual void OnSerializedPacket(SerializedPacket* serialized_packet) = 0;
   };
 
   // Interface which gets callbacks from the QuicPacketCreator at interesting
   // points.  Implementations must not mutate the state of the creator
   // as a result of these callbacks.
   class NET_EXPORT_PRIVATE DebugDelegate {
    public:
     virtual ~DebugDelegate() {}
 
     // Called when a frame has been added to the current packet.
     virtual void OnFrameAddedToPacket(const QuicFrame& frame) {}
   };
 
-  // QuicRandom* required for packet entropy.
   QuicPacketCreator(QuicConnectionId connection_id,
                     QuicFramer* framer,
-                    QuicRandom* random_generator,
                     QuicBufferAllocator* buffer_allocator,
                     DelegateInterface* delegate);
 
   ~QuicPacketCreator();
 
   // Makes the framer not serialize the protocol version in sent packets.
   void StopSendingVersion();
 
   // SetDiversificationNonce sets the nonce that will be sent in each public
   // header of packets encrypted at the initial encryption level. Should only
@@ skipping 87 matching lines @@
 
   // Identical to AddSavedFrame, but allows the frame to be padded.
   bool AddPaddedSavedFrame(const QuicFrame& frame);
 
   // Adds |listener| to the next serialized packet and notifies the
   // std::listener with |length| as the number of acked bytes.
   void AddAckListener(QuicAckListenerInterface* listener,
                       QuicPacketLength length);
 
   // Creates a version negotiation packet which supports |supported_versions|.
-  // Also, sets the entropy hash of the serialized packet to a random bool and
-  // returns that value as a member of SerializedPacket.
   std::unique_ptr<QuicEncryptedPacket> SerializeVersionNegotiationPacket(
       const QuicVersionVector& supported_versions);
 
   // Returns a dummy packet that is valid but contains no useful information.
   static SerializedPacket NoPacket();
 
   // Sets the encryption level that will be applied to new packets.
   void set_encryption_level(EncryptionLevel level) {
     packet_.encryption_level = level;
   }
@@ skipping 35 matching lines @@
                       QuicPacketNumber least_packet_awaited_by_peer,
                       QuicPacketCount max_packets_in_flight);
 
   void set_debug_delegate(DebugDelegate* debug_delegate) {
     debug_delegate_ = debug_delegate;
   }
 
  private:
   friend class test::QuicPacketCreatorPeer;
 
-  // A QuicRandom wrapper that gets a bucket of entropy and distributes it
-  // bit-by-bit. Replenishes the bucket as needed. Not thread-safe. Expose this
-  // class if single bit randomness is needed elsewhere.
-  class QuicRandomBoolSource {
-   public:
-    // random: Source of entropy. Not owned.
-    explicit QuicRandomBoolSource(QuicRandom* random);
-
-    ~QuicRandomBoolSource();
-
-    // Returns the next random bit from the bucket.
-    bool RandBool();
-
-   private:
-    // Source of entropy.
-    QuicRandom* random_;
-    // Stored random bits.
-    uint64_t bit_bucket_;
-    // The next available bit has "1" in the mask. Zero means empty bucket.
-    uint64_t bit_mask_;
-
-    DISALLOW_COPY_AND_ASSIGN(QuicRandomBoolSource);
-  };
-
   static bool ShouldRetransmit(const QuicFrame& frame);
 
   // Converts a raw payload to a frame which fits into the current open
   // packet.  The payload begins at |iov_offset| into the |iov|.
   // If data is empty and fin is true, the expected behavior is to consume the
   // fin but return 0.  If any data is consumed, it will be copied into a
   // new buffer that |frame| will point to and own.
   void CreateStreamFrame(QuicStreamId id,
                          QuicIOVector iov,
                          size_t iov_offset,
@@ skipping 16 matching lines @@
   // saves the |frame| in the next SerializedPacket.
   bool AddFrame(const QuicFrame& frame, bool save_retransmittable_frames);
 
   // Adds a padding frame to the current packet only if the current packet
   // contains a handshake message, and there is sufficient room to fit a
   // padding frame.
   void MaybeAddPadding();
 
   // Serializes all frames which have been added and adds any which should be
   // retransmitted to packet_.retransmittable_frames. All frames must fit into
-  // a single packet. Sets the entropy hash of the serialized packet to a
-  // random bool.
+  // a single packet.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
   void SerializePacket(char* encrypted_buffer, size_t buffer_len);
 
   // Called after a new SerialiedPacket is created to call the delegate's
   // OnSerializedPacket and reset state.
   void OnSerializedPacket();
 
   // Clears all fields of packet_ that should be cleared between serializations.
   void ClearPacket();
 
   // Returns true if a diversification nonce should be included in the current
   // packet's public header.
   bool IncludeNonceInPublicHeader();
 
   // Does not own these delegates or the framer.
   DelegateInterface* delegate_;
   DebugDelegate* debug_delegate_;
   QuicFramer* framer_;
 
-  QuicRandomBoolSource random_bool_source_;
   QuicBufferAllocator* const buffer_allocator_;
 
   // Controls whether version should be included while serializing the packet.
   bool send_version_in_packet_;
   // Controls whether path id should be included while serializing the packet.
   bool send_path_id_in_packet_;
   // Staging variable to hold next packet number length. When sequence
   // number length is to be changed, this variable holds the new length until
   // a packet boundary, when the creator's packet_number_length_ can be changed
   // to this new value.
@@ skipping 22 matching lines @@
 
   // Map mapping path_id to last sent packet number on the path.
   std::unordered_map<QuicPathId, QuicPacketNumber> multipath_packet_number_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_CREATOR_H_