net/quic/core/quic_protocol.h - Issue 2541673002: Rename quic_protocol to quic_packets. No behavior change.

Unified Diff: net/quic/core/quic_protocol.h

Issue 2541673002: Rename quic_protocol to quic_packets. No behavior change. (Closed)

Patch Set: Rollback accidentally wrong CL Created 4 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: net/quic/core/quic_protocol.h

diff --git a/net/quic/core/quic_protocol.h b/net/quic/core/quic_protocol.h

deleted file mode 100644

index 788cf42dbc43c9b249c77202d6f6a792a80a732d..0000000000000000000000000000000000000000

--- a/net/quic/core/quic_protocol.h

+++ /dev/null

@@ -1,368 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#ifndef NET_QUIC_QUIC_PROTOCOL_H_

-#define NET_QUIC_QUIC_PROTOCOL_H_

-#include <limits>

-#include <list>

-#include <memory>

-#include <ostream>

-#include <string>

-#include <utility>

-#include <vector>

-#include "base/logging.h"

-#include "base/macros.h"

-#include "base/memory/ref_counted.h"

-#include "base/strings/string_piece.h"

-#include "net/base/int128.h"

-#include "net/base/iovec.h"

-#include "net/base/net_export.h"

-#include "net/quic/core/quic_bandwidth.h"

-#include "net/quic/core/quic_constants.h"

-#include "net/quic/core/quic_error_codes.h"

-#include "net/quic/core/quic_frames.h"

-#include "net/quic/core/quic_time.h"

-#include "net/quic/core/quic_types.h"

-#include "net/quic/core/quic_versions.h"

-#include "net/quic/platform/api/quic_socket_address.h"

-namespace net {

-class QuicPacket;

-struct QuicPacketHeader;

-// Size in bytes of the data packet header.

-NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicVersion version,

- const QuicPacketHeader& header);

-NET_EXPORT_PRIVATE size_t

-GetPacketHeaderSize(QuicVersion version,

- QuicConnectionIdLength connection_id_length,

- bool include_version,

- bool include_path_id,

- bool include_diversification_nonce,

- QuicPacketNumberLength packet_number_length);

-// Index of the first byte in a QUIC packet of encrypted data.

-NET_EXPORT_PRIVATE size_t

-GetStartOfEncryptedData(QuicVersion version, const QuicPacketHeader& header);

-NET_EXPORT_PRIVATE size_t

-GetStartOfEncryptedData(QuicVersion version,

- QuicConnectionIdLength connection_id_length,

- bool include_version,

- bool include_path_id,

- bool include_diversification_nonce,

- QuicPacketNumberLength packet_number_length);

-struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {

- QuicPacketPublicHeader();

- explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);

- ~QuicPacketPublicHeader();

- // Universal header. All QuicPacket headers will have a connection_id and

- // public flags.

- QuicConnectionId connection_id;

- QuicConnectionIdLength connection_id_length;

- bool multipath_flag;

- bool reset_flag;

- bool version_flag;

- QuicPacketNumberLength packet_number_length;

- QuicVersionVector versions;

- // nonce contains an optional, 32-byte nonce value. If not included in the

- // packet, |nonce| will be empty.

- DiversificationNonce* nonce;

-};

-// Header for Data packets.

-struct NET_EXPORT_PRIVATE QuicPacketHeader {

- QuicPacketHeader();

- explicit QuicPacketHeader(const QuicPacketPublicHeader& header);

- QuicPacketHeader(const QuicPacketHeader& other);

- NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,

- const QuicPacketHeader& s);

- QuicPacketPublicHeader public_header;

- QuicPacketNumber packet_number;

- QuicPathId path_id;

-};

-struct NET_EXPORT_PRIVATE QuicPublicResetPacket {

- QuicPublicResetPacket();

- explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header);

- QuicPacketPublicHeader public_header;

- QuicPublicResetNonceProof nonce_proof;

- // TODO(fayang): remove rejected_packet_number when deprecating

- // FLAGS_quic_remove_packet_number_from_public_reset.

- QuicPacketNumber rejected_packet_number;

- QuicSocketAddress client_address;

-};

-typedef QuicPacketPublicHeader QuicVersionNegotiationPacket;

-typedef std::vector<std::pair<QuicPacketNumber, QuicTime>> PacketTimeVector;

-class NET_EXPORT_PRIVATE QuicData {

- public:

- QuicData(const char* buffer, size_t length);

- QuicData(const char* buffer, size_t length, bool owns_buffer);

- virtual ~QuicData();

- base::StringPiece AsStringPiece() const {

- return base::StringPiece(data(), length());

- }

- const char* data() const { return buffer_; }

- size_t length() const { return length_; }

- bool owns_buffer() const { return owns_buffer_; }

- private:

- const char* buffer_;

- size_t length_;

- bool owns_buffer_;

- DISALLOW_COPY_AND_ASSIGN(QuicData);

-};

-class NET_EXPORT_PRIVATE QuicPacket : public QuicData {

- public:

- // TODO(fayang): 4 fields from public header are passed in as arguments.

- // Consider to add a convenience method which directly accepts the entire

- // public header.

- QuicPacket(char* buffer,

- size_t length,

- bool owns_buffer,

- QuicConnectionIdLength connection_id_length,

- bool includes_version,

- bool includes_path_id,

- bool includes_diversification_nonce,

- QuicPacketNumberLength packet_number_length);

- base::StringPiece AssociatedData(QuicVersion version) const;

- base::StringPiece Plaintext(QuicVersion version) const;

- char* mutable_data() { return buffer_; }

- private:

- char* buffer_;

- const QuicConnectionIdLength connection_id_length_;

- const bool includes_version_;

- const bool includes_path_id_;

- const bool includes_diversification_nonce_;

- const QuicPacketNumberLength packet_number_length_;

- DISALLOW_COPY_AND_ASSIGN(QuicPacket);

-};

-class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {

- public:

- QuicEncryptedPacket(const char* buffer, size_t length);

- QuicEncryptedPacket(const char* buffer, size_t length, bool owns_buffer);

- // Clones the packet into a new packet which owns the buffer.

- std::unique_ptr<QuicEncryptedPacket> Clone() const;

- // By default, gtest prints the raw bytes of an object. The bool data

- // member (in the base class QuicData) causes this object to have padding

- // bytes, which causes the default gtest object printer to read

- // uninitialize memory. So we need to teach gtest how to print this object.

- NET_EXPORT_PRIVATE friend std::ostream& operator<<(

- std::ostream& os,

- const QuicEncryptedPacket& s);

- private:

- DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);

-};

-// A received encrypted QUIC packet, with a recorded time of receipt.

-class NET_EXPORT_PRIVATE QuicReceivedPacket : public QuicEncryptedPacket {

- public:

- QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time);

- QuicReceivedPacket(const char* buffer,

- size_t length,

- QuicTime receipt_time,

- bool owns_buffer);

- QuicReceivedPacket(const char* buffer,

- size_t length,

- QuicTime receipt_time,

- bool owns_buffer,

- int ttl,

- bool ttl_valid);

- // Clones the packet into a new packet which owns the buffer.

- std::unique_ptr<QuicReceivedPacket> Clone() const;

- // Returns the time at which the packet was received.

- QuicTime receipt_time() const { return receipt_time_; }

- // This is the TTL of the packet, assuming ttl_vaild_ is true.

- int ttl() const { return ttl_; }

- // By default, gtest prints the raw bytes of an object. The bool data

- // member (in the base class QuicData) causes this object to have padding

- // bytes, which causes the default gtest object printer to read

- // uninitialize memory. So we need to teach gtest how to print this object.

- NET_EXPORT_PRIVATE friend std::ostream& operator<<(

- std::ostream& os,

- const QuicReceivedPacket& s);

- private:

- const QuicTime receipt_time_;

- int ttl_;

- DISALLOW_COPY_AND_ASSIGN(QuicReceivedPacket);

-};

-// Pure virtual class to listen for packet acknowledgements.

-class NET_EXPORT_PRIVATE QuicAckListenerInterface

- : public base::RefCounted<QuicAckListenerInterface> {

- public:

- QuicAckListenerInterface() {}

- // Called when a packet is acked. Called once per packet.

- // |acked_bytes| is the number of data bytes acked.

- virtual void OnPacketAcked(int acked_bytes,

- QuicTime::Delta ack_delay_time) = 0;

- // Called when a packet is retransmitted. Called once per packet.

- // |retransmitted_bytes| is the number of data bytes retransmitted.

- virtual void OnPacketRetransmitted(int retransmitted_bytes) = 0;

- protected:

- friend class base::RefCounted<QuicAckListenerInterface>;

- // Delegates are ref counted.

- virtual ~QuicAckListenerInterface() {}

-};

-struct NET_EXPORT_PRIVATE AckListenerWrapper {

- AckListenerWrapper(QuicAckListenerInterface* listener,

- QuicPacketLength data_length);

- AckListenerWrapper(const AckListenerWrapper& other);

- ~AckListenerWrapper();

- scoped_refptr<QuicAckListenerInterface> ack_listener;

- QuicPacketLength length;

-};

-struct NET_EXPORT_PRIVATE SerializedPacket {

- SerializedPacket(QuicPathId path_id,

- QuicPacketNumber packet_number,

- QuicPacketNumberLength packet_number_length,

- const char* encrypted_buffer,

- QuicPacketLength encrypted_length,

- bool has_ack,

- bool has_stop_waiting);

- SerializedPacket(const SerializedPacket& other);

- ~SerializedPacket();

- // Not owned.

- const char* encrypted_buffer;

- QuicPacketLength encrypted_length;

- QuicFrames retransmittable_frames;

- IsHandshake has_crypto_handshake;

- // -1: full padding to the end of a max-sized packet

- // 0: no padding

- // otherwise: only pad up to num_padding_bytes bytes

- int16_t num_padding_bytes;

- QuicPathId path_id;

- QuicPacketNumber packet_number;

- QuicPacketNumberLength packet_number_length;

- EncryptionLevel encryption_level;

- bool has_ack;

- bool has_stop_waiting;

- TransmissionType transmission_type;

- QuicPathId original_path_id;

- QuicPacketNumber original_packet_number;

- // Optional notifiers which will be informed when this packet has been ACKed.

- std::list<AckListenerWrapper> listeners;

-};

-// Deletes and clears all the frames and the packet from serialized packet.

-NET_EXPORT_PRIVATE void ClearSerializedPacket(

- SerializedPacket* serialized_packet);

-// Allocates a new char[] of size |packet.encrypted_length| and copies in

-// |packet.encrypted_buffer|.

-NET_EXPORT_PRIVATE char* CopyBuffer(const SerializedPacket& packet);

-struct NET_EXPORT_PRIVATE TransmissionInfo {

- // Used by STL when assigning into a map.

- TransmissionInfo();

- // Constructs a Transmission with a new all_transmissions set

- // containing |packet_number|.

- TransmissionInfo(EncryptionLevel level,

- QuicPacketNumberLength packet_number_length,

- TransmissionType transmission_type,

- QuicTime sent_time,

- QuicPacketLength bytes_sent,

- bool has_crypto_handshake,

- int num_padding_bytes);

- TransmissionInfo(const TransmissionInfo& other);

- ~TransmissionInfo();

- QuicFrames retransmittable_frames;

- EncryptionLevel encryption_level;

- QuicPacketNumberLength packet_number_length;

- QuicPacketLength bytes_sent;

- QuicTime sent_time;

- // Reason why this packet was transmitted.

- TransmissionType transmission_type;

- // In flight packets have not been abandoned or lost.

- bool in_flight;

- // True if the packet can never be acked, so it can be removed. Occurs when

- // a packet is never sent, after it is acknowledged once, or if it's a crypto

- // packet we never expect to receive an ack for.

- bool is_unackable;

- // True if the packet contains stream data from the crypto stream.

- bool has_crypto_handshake;

- // Non-zero if the packet needs padding if it's retransmitted.

- int16_t num_padding_bytes;

- // Stores the packet number of the next retransmission of this packet.

- // Zero if the packet has not been retransmitted.

- QuicPacketNumber retransmission;

- // Non-empty if there is a std::listener for this packet.

- std::list<AckListenerWrapper> ack_listeners;

-};

-// Struct to store the pending retransmission information.

-struct PendingRetransmission {

- PendingRetransmission(QuicPathId path_id,

- QuicPacketNumber packet_number,

- TransmissionType transmission_type,

- const QuicFrames& retransmittable_frames,

- bool has_crypto_handshake,

- int num_padding_bytes,

- EncryptionLevel encryption_level,

- QuicPacketNumberLength packet_number_length)

- : packet_number(packet_number),

- retransmittable_frames(retransmittable_frames),

- transmission_type(transmission_type),

- path_id(path_id),

- has_crypto_handshake(has_crypto_handshake),

- num_padding_bytes(num_padding_bytes),

- encryption_level(encryption_level),

- packet_number_length(packet_number_length) {}

- QuicPacketNumber packet_number;

- const QuicFrames& retransmittable_frames;

- TransmissionType transmission_type;

- QuicPathId path_id;

- bool has_crypto_handshake;

- int num_padding_bytes;

- EncryptionLevel encryption_level;

- QuicPacketNumberLength packet_number_length;

-};

-} // namespace net

-#endif // NET_QUIC_QUIC_PROTOCOL_H_

« no previous file with comments | « net/quic/core/quic_packets.cc ('k') | net/quic/core/quic_protocol.cc » ('j') | no next file with comments »