Move shared files in net/quic/ into net/quic/core/

net/quic/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/quic/quic_framer.h"
-#include "net/quic/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
-  // be called by servers.
-  void SetDiversificationNonce(const DiversificationNonce nonce);
-
-  // Update the packet number length to use in future packets as soon as it
-  // can be safely changed.
-  // TODO(fayang): Directly set packet number length instead of compute it in
-  // creator.
-  void UpdatePacketNumberLength(QuicPacketNumber least_packet_awaited_by_peer,
-                                QuicPacketCount max_packets_in_flight);
-
-  // The overhead the framing will add for a packet with one frame.
-  static size_t StreamFramePacketOverhead(
-      QuicVersion version,
-      QuicConnectionIdLength connection_id_length,
-      bool include_version,
-      bool include_path_id,
-      bool include_diversification_nonce,
-      QuicPacketNumberLength packet_number_length,
-      QuicStreamOffset offset);
-
-  // Returns false and flushes all pending frames if current open packet is
-  // full.
-  // If current packet is not full, converts a raw payload into a stream frame
-  // that fits into the open packet and adds it to the packet.
-  // The payload begins at |iov_offset| into the |iov|.
-  bool ConsumeData(QuicStreamId id,
-                   QuicIOVector iov,
-                   size_t iov_offset,
-                   QuicStreamOffset offset,
-                   bool fin,
-                   bool needs_full_padding,
-                   QuicFrame* frame);
-
-  // Returns true if current open packet can accommodate more stream frames of
-  // stream |id| at |offset|, false otherwise.
-  bool HasRoomForStreamFrame(QuicStreamId id, QuicStreamOffset offset);
-
-  // Re-serializes frames with the original packet's packet number length.
-  // Used for retransmitting packets to ensure they aren't too long.
-  void ReserializeAllFrames(const PendingRetransmission& retransmission,
-                            char* buffer,
-                            size_t buffer_len);
-
-  // Serializes all added frames into a single packet and invokes the delegate_
-  // to further process the SerializedPacket.
-  void Flush();
-
-  // Optimized method to create a QuicStreamFrame, serialize it, and encrypt it
-  // into |encrypted_buffer|. Adds the QuicStreamFrame to the returned
-  // SerializedPacket.  Sets |num_bytes_consumed| to the number of bytes
-  // consumed to create the QuicStreamFrame.
-  void CreateAndSerializeStreamFrame(QuicStreamId id,
-                                     const QuicIOVector& iov,
-                                     QuicStreamOffset iov_offset,
-                                     QuicStreamOffset stream_offset,
-                                     bool fin,
-                                     QuicAckListenerInterface* listener,
-                                     char* encrypted_buffer,
-                                     size_t encrypted_buffer_len,
-                                     size_t* num_bytes_consumed);
-
-  // Returns true if there are frames pending to be serialized.
-  bool HasPendingFrames() const;
-
-  // Returns true if there are retransmittable frames pending to be serialized.
-  bool HasPendingRetransmittableFrames() const;
-
-  // Returns the number of bytes which are available to be used by additional
-  // frames in the packet.  Since stream frames are slightly smaller when they
-  // are the last frame in a packet, this method will return a different
-  // value than max_packet_size - PacketSize(), in this case.
-  size_t BytesFree();
-
-  // Returns the number of bytes that the packet will expand by if a new frame
-  // is added to the packet. If the last frame was a stream frame, it will
-  // expand slightly when a new frame is added, and this method returns the
-  // amount of expected expansion.
-  size_t ExpansionOnNewFrame() const;
-
-  // Returns the number of bytes in the current packet, including the header,
-  // if serialized with the current frames.  Adding a frame to the packet
-  // may change the serialized length of existing frames, as per the comment
-  // in BytesFree.
-  size_t PacketSize();
-
-  // Tries to add |frame| to the packet creator's list of frames to be
-  // serialized. If the frame does not fit into the current packet, flushes the
-  // packet and returns false.
-  bool AddSavedFrame(const QuicFrame& frame);
-
-  // 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|.
-  // Caller owns the created  packet. Also, sets the entropy hash of the
-  // serialized packet to a random bool and returns that value as a member of
-  // SerializedPacket.
-  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;
-  }
-
-  // packet number of the last created packet, or 0 if no packets have been
-  // created.
-  QuicPacketNumber packet_number() const { return packet_.packet_number; }
-
-  QuicConnectionIdLength connection_id_length() const {
-    return connection_id_length_;
-  }
-
-  void set_connection_id_length(QuicConnectionIdLength length) {
-    connection_id_length_ = length;
-  }
-
-  QuicByteCount max_packet_length() const { return max_packet_length_; }
-
-  bool has_ack() const { return packet_.has_ack; }
-
-  bool has_stop_waiting() const { return packet_.has_stop_waiting; }
-
-  // Sets the encrypter to use for the encryption level and updates the max
-  // plaintext size.
-  void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
-
-  // Indicates whether the packet creator is in a state where it can change
-  // current maximum packet length.
-  bool CanSetMaxPacketLength() const;
-
-  // Sets the maximum packet length.
-  void SetMaxPacketLength(QuicByteCount length);
-
-  // Sets the path on which subsequent packets will be created. It is the
-  // caller's responsibility to guarantee no packet is under construction before
-  // calling this function. If |path_id| is different from current_path_,
-  // next_packet_number_length_ is recalculated.
-  void SetCurrentPath(QuicPathId path_id,
-                      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,
-                         QuicStreamOffset offset,
-                         bool fin,
-                         QuicFrame* frame);
-
-  // Copies |length| bytes from iov starting at offset |iov_offset| into buffer.
-  // |iov| must be at least iov_offset+length total length and buffer must be
-  // at least |length| long.
-  static void CopyToBuffer(QuicIOVector iov,
-                           size_t iov_offset,
-                           size_t length,
-                           char* buffer);
-
-  // Updates packet number length on packet boundary.
-  void MaybeUpdatePacketNumberLength();
-
-  void FillPacketHeader(QuicPacketHeader* header);
-
-  // Adds a |frame| if there is space and returns false and flushes all pending
-  // frames if there isn't room. If |save_retransmittable_frames| is true,
-  // 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.
-  // 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.
-  QuicPacketNumberLength next_packet_number_length_;
-  // If true, then |nonce_for_public_header_| will be included in the public
-  // header of all packets created at the initial encryption level.
-  bool have_diversification_nonce_;
-  DiversificationNonce diversification_nonce_;
-  // Maximum length including headers and encryption (UDP payload length.)
-  QuicByteCount max_packet_length_;
-  size_t max_plaintext_size_;
-  // Length of connection_id to send over the wire.
-  QuicConnectionIdLength connection_id_length_;
-
-  // Frames to be added to the next SerializedPacket
-  QuicFrames queued_frames_;
-
-  // packet_size should never be read directly, use PacketSize() instead.
-  // TODO(ianswett): Move packet_size_ into SerializedPacket once
-  // QuicEncryptedPacket has been flattened into SerializedPacket.
-  size_t packet_size_;
-  QuicConnectionId connection_id_;
-
-  // Packet used to invoke OnSerializedPacket.
-  SerializedPacket packet_;
-
-  // 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_