Streamline the use of QUICHE_EXPORT macros in quic/core.
Previously, we had files that were in core/ that were not compiled in Chromium quiche component since they were not used there; because of that, those had to be manually tagged as QUIC_NO_EXPORT and be kept in sync with the structure of Chromium build files.
This CL changes this to a much simpler approach of "everything in quic/core except for I/O directories uses QUICHE_EXPORT". This works because:
(1) The linker will remove unused code anyways, so binary size should not be a concern.
(2) We already build all of this code for tests, so it is neutral in terms of build time.
(3) All of this code is already either cross-platform, or does not build for Windows (which is the only platform where QUICHE_EXPORT can cause things to fail to compile).
This CL is a google3 counterpart of build file refactor in https://chromium-review.googlesource.com/c/chromium/src/+/4848368
PiperOrigin-RevId: 563502086
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_base.h b/quiche/quic/core/batch_writer/quic_batch_writer_base.h
index 9f9f226..69cefba 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_base.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_base.h
@@ -21,7 +21,7 @@
// A derived batch writer must override the FlushImpl() function to send all
// buffered writes in a batch. It must also override the CanBatch() function
// to control whether/when a WritePacket() call should flush.
-class QUIC_EXPORT_PRIVATE QuicBatchWriterBase : public QuicPacketWriter {
+class QUICHE_EXPORT QuicBatchWriterBase : public QuicPacketWriter {
public:
explicit QuicBatchWriterBase(
std::unique_ptr<QuicBatchWriterBuffer> batch_buffer);
@@ -73,7 +73,7 @@
// Given the release delay in |options| and the state of |batch_buffer_|, get
// the absolute release time.
- struct QUIC_NO_EXPORT ReleaseTime {
+ struct QUICHE_EXPORT ReleaseTime {
// The actual (absolute) release time.
uint64_t actual_release_time = 0;
// The difference between |actual_release_time| and ideal release time,
@@ -87,7 +87,7 @@
return ReleaseTime{0, QuicTime::Delta::Zero()};
}
- struct QUIC_EXPORT_PRIVATE CanBatchResult {
+ struct QUICHE_EXPORT CanBatchResult {
CanBatchResult(bool can_batch, bool must_flush)
: can_batch(can_batch), must_flush(must_flush) {}
// Whether this write can be batched with existing buffered writes.
@@ -107,7 +107,7 @@
const QuicPacketWriterParams& params,
uint64_t release_time) const = 0;
- struct QUIC_EXPORT_PRIVATE FlushImplResult {
+ struct QUICHE_EXPORT FlushImplResult {
// The return value of the Flush() interface, which is:
// - WriteResult(WRITE_STATUS_OK, <bytes_flushed>) if all buffered writes
// were sent successfully.
@@ -144,7 +144,7 @@
};
// QuicUdpBatchWriter is a batch writer backed by a UDP socket.
-class QUIC_EXPORT_PRIVATE QuicUdpBatchWriter : public QuicBatchWriterBase {
+class QUICHE_EXPORT QuicUdpBatchWriter : public QuicBatchWriterBase {
public:
QuicUdpBatchWriter(std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
int fd)
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
index 369ecff..2d25157 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
@@ -19,7 +19,7 @@
// that they can be sent by a QuicGsoBatchWriter.
// This class can also be used by a QuicBatchWriter which uses sendmmsg,
// although it is not optimized for that use case.
-class QUIC_EXPORT_PRIVATE QuicBatchWriterBuffer {
+class QUICHE_EXPORT QuicBatchWriterBuffer {
public:
QuicBatchWriterBuffer();
@@ -29,7 +29,7 @@
char* GetNextWriteLocation() const;
// Push a buffered write to the back.
- struct QUIC_EXPORT_PRIVATE PushResult {
+ struct QUICHE_EXPORT PushResult {
bool succeeded;
// True in one of the following cases:
// 1) The packet buffer is external and copied to the internal buffer, or
@@ -54,7 +54,7 @@
// Pop |num_buffered_writes| buffered writes from the front.
// |num_buffered_writes| will be capped to [0, buffered_writes().size()]
// before it is used.
- struct QUIC_EXPORT_PRIVATE PopResult {
+ struct QUICHE_EXPORT PopResult {
int32_t num_buffers_popped;
// True if after |num_buffers_popped| buffers are popped from front, the
// remaining buffers are moved to the beginning of the internal buffer.
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc b/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
index 747ff1f..63ff5a2 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
@@ -16,8 +16,7 @@
namespace test {
namespace {
-class QUIC_EXPORT_PRIVATE TestQuicBatchWriterBuffer
- : public QuicBatchWriterBuffer {
+class QUICHE_EXPORT TestQuicBatchWriterBuffer : public QuicBatchWriterBuffer {
public:
using QuicBatchWriterBuffer::buffer_;
using QuicBatchWriterBuffer::buffered_writes_;
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_test.h b/quiche/quic/core/batch_writer/quic_batch_writer_test.h
index 08610f0..7fa200d 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_test.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_test.h
@@ -74,7 +74,7 @@
}
struct QuicUdpBatchWriterIOTestParams;
-class QUIC_EXPORT_PRIVATE QuicUdpBatchWriterIOTestDelegate {
+class QUICHE_EXPORT QuicUdpBatchWriterIOTestDelegate {
public:
virtual ~QuicUdpBatchWriterIOTestDelegate() {}
@@ -87,14 +87,14 @@
virtual QuicUdpBatchWriter* GetWriter() = 0;
};
-struct QUIC_EXPORT_PRIVATE QuicUdpBatchWriterIOTestParams {
+struct QUICHE_EXPORT QuicUdpBatchWriterIOTestParams {
// Use shared_ptr because gtest makes copies of test params.
std::shared_ptr<QuicUdpBatchWriterIOTestDelegate> delegate;
int address_family;
int data_size;
int packet_size;
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
+ QUICHE_EXPORT friend std::ostream& operator<<(
std::ostream& os, const QuicUdpBatchWriterIOTestParams& p) {
os << "{ address_family: " << p.address_family
<< " data_size: " << p.data_size << " packet_size: " << p.packet_size
@@ -129,7 +129,7 @@
// QuicUdpBatchWriterIOTest is a value parameterized test fixture that can be
// used by tests of derived classes of QuicUdpBatchWriter, to verify basic
// packet IO capabilities.
-class QUIC_EXPORT_PRIVATE QuicUdpBatchWriterIOTest
+class QUICHE_EXPORT QuicUdpBatchWriterIOTest
: public QuicTestWithParam<QuicUdpBatchWriterIOTestParams> {
protected:
QuicUdpBatchWriterIOTest()
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer.h b/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
index 492e446..4ca18e4 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
@@ -11,7 +11,7 @@
// QuicGsoBatchWriter sends QUIC packets in batches, using UDP socket's generic
// segmentation offload(GSO) capability.
-class QUIC_EXPORT_PRIVATE QuicGsoBatchWriter : public QuicUdpBatchWriter {
+class QUICHE_EXPORT QuicGsoBatchWriter : public QuicUdpBatchWriter {
public:
explicit QuicGsoBatchWriter(int fd);
@@ -36,7 +36,7 @@
protected:
// Test only constructor to forcefully enable release time.
- struct QUIC_EXPORT_PRIVATE ReleaseTimeForceEnabler {};
+ struct QUICHE_EXPORT ReleaseTimeForceEnabler {};
QuicGsoBatchWriter(std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
int fd, clockid_t clockid_for_release_time,
ReleaseTimeForceEnabler enabler);
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc b/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
index 35c48c1..ecb4c81 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
@@ -33,7 +33,7 @@
uint64_t MillisToNanos(uint64_t milliseconds) { return milliseconds * 1000000; }
-class QUIC_EXPORT_PRIVATE TestQuicGsoBatchWriter : public QuicGsoBatchWriter {
+class QUICHE_EXPORT TestQuicGsoBatchWriter : public QuicGsoBatchWriter {
public:
using QuicGsoBatchWriter::batch_buffer;
using QuicGsoBatchWriter::buffered_writes;
@@ -64,7 +64,7 @@
};
// TestBufferedWrite is a copy-constructible BufferedWrite.
-struct QUIC_EXPORT_PRIVATE TestBufferedWrite : public BufferedWrite {
+struct QUICHE_EXPORT TestBufferedWrite : public BufferedWrite {
using BufferedWrite::BufferedWrite;
TestBufferedWrite(const TestBufferedWrite& other)
: BufferedWrite(other.buffer, other.buf_len, other.self_address,
@@ -77,7 +77,7 @@
// Pointed to by all instances of |BatchCriteriaTestData|. Content not used.
static char unused_packet_buffer[kMaxOutgoingPacketSize];
-struct QUIC_EXPORT_PRIVATE BatchCriteriaTestData {
+struct QUICHE_EXPORT BatchCriteriaTestData {
BatchCriteriaTestData(size_t buf_len, const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
uint64_t release_time, bool can_batch, bool must_flush)
diff --git a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
index 9dda5dd..cbb936c 100644
--- a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
+++ b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
@@ -10,7 +10,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicSendmmsgBatchWriter : public QuicUdpBatchWriter {
+class QUICHE_EXPORT QuicSendmmsgBatchWriter : public QuicUdpBatchWriter {
public:
QuicSendmmsgBatchWriter(std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
int fd);
diff --git a/quiche/quic/core/chlo_extractor.h b/quiche/quic/core/chlo_extractor.h
index fd83233..80c265c 100644
--- a/quiche/quic/core/chlo_extractor.h
+++ b/quiche/quic/core/chlo_extractor.h
@@ -12,9 +12,9 @@
// A utility for extracting QUIC Client Hello messages from packets,
// without needing to spin up a full QuicSession.
-class QUIC_NO_EXPORT ChloExtractor {
+class QUICHE_EXPORT ChloExtractor {
public:
- class QUIC_NO_EXPORT Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/congestion_control/bandwidth_sampler.h b/quiche/quic/core/congestion_control/bandwidth_sampler.h
index 3ca09d1..87989dc 100644
--- a/quiche/quic/core/congestion_control/bandwidth_sampler.h
+++ b/quiche/quic/core/congestion_control/bandwidth_sampler.h
@@ -26,7 +26,7 @@
// A subset of BandwidthSampler::ConnectionStateOnSentPacket which is returned
// to the caller when the packet is acked or lost.
-struct QUIC_EXPORT_PRIVATE SendTimeState {
+struct QUICHE_EXPORT SendTimeState {
SendTimeState()
: is_valid(false),
is_app_limited(false),
@@ -48,8 +48,8 @@
SendTimeState(const SendTimeState& other) = default;
SendTimeState& operator=(const SendTimeState& other) = default;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const SendTimeState& s);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const SendTimeState& s);
// Whether other states in this object is valid.
bool is_valid;
@@ -76,7 +76,7 @@
QuicByteCount bytes_in_flight;
};
-struct QUIC_NO_EXPORT ExtraAckedEvent {
+struct QUICHE_EXPORT ExtraAckedEvent {
// The excess bytes acknowlwedged in the time delta for this event.
QuicByteCount extra_acked = 0;
@@ -94,7 +94,7 @@
}
};
-struct QUIC_EXPORT_PRIVATE BandwidthSample {
+struct QUICHE_EXPORT BandwidthSample {
// The bandwidth at that particular sample. Zero if no valid bandwidth sample
// is available.
QuicBandwidth bandwidth = QuicBandwidth::Zero();
@@ -113,7 +113,7 @@
// MaxAckHeightTracker is part of the BandwidthSampler. It is called after every
// ack event to keep track the degree of ack aggregation(a.k.a "ack height").
-class QUIC_EXPORT_PRIVATE MaxAckHeightTracker {
+class QUICHE_EXPORT MaxAckHeightTracker {
public:
explicit MaxAckHeightTracker(QuicRoundTripCount initial_filter_window)
: max_ack_height_filter_(initial_filter_window, ExtraAckedEvent(), 0) {}
@@ -184,7 +184,7 @@
// An interface common to any class that can provide bandwidth samples from the
// information per individual acknowledged packet.
-class QUIC_EXPORT_PRIVATE BandwidthSamplerInterface {
+class QUICHE_EXPORT BandwidthSamplerInterface {
public:
virtual ~BandwidthSamplerInterface() {}
@@ -199,7 +199,7 @@
virtual void OnPacketNeutered(QuicPacketNumber packet_number) = 0;
- struct QUIC_NO_EXPORT CongestionEventSample {
+ struct QUICHE_EXPORT CongestionEventSample {
// The maximum bandwidth sample from all acked packets.
// QuicBandwidth::Zero() if no samples are available.
QuicBandwidth sample_max_bandwidth = QuicBandwidth::Zero();
@@ -332,7 +332,7 @@
// up until an ack for a packet that was sent after OnAppLimited() was called.
// Note that while the scenario above is not the only scenario when the
// connection is app-limited, the approach works in other cases too.
-class QUIC_EXPORT_PRIVATE BandwidthSampler : public BandwidthSamplerInterface {
+class QUICHE_EXPORT BandwidthSampler : public BandwidthSamplerInterface {
public:
BandwidthSampler(const QuicUnackedPacketMap* unacked_packet_map,
QuicRoundTripCount max_height_tracker_window_length);
@@ -397,18 +397,18 @@
}
// AckPoint represents a point on the ack line.
- struct QUIC_NO_EXPORT AckPoint {
+ struct QUICHE_EXPORT AckPoint {
QuicTime ack_time = QuicTime::Zero();
QuicByteCount total_bytes_acked = 0;
- friend QUIC_NO_EXPORT std::ostream& operator<<(std::ostream& os,
- const AckPoint& ack_point) {
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const AckPoint& ack_point) {
return os << ack_point.ack_time << ":" << ack_point.total_bytes_acked;
}
};
// RecentAckPoints maintains the most recent 2 ack points at distinct times.
- class QUIC_NO_EXPORT RecentAckPoints {
+ class QUICHE_EXPORT RecentAckPoints {
public:
void Update(QuicTime ack_time, QuicByteCount total_bytes_acked) {
QUICHE_DCHECK_GE(total_bytes_acked, ack_points_[1].total_bytes_acked);
@@ -454,7 +454,7 @@
// and the state of the connection at the moment the packet was sent,
// specifically the information about the most recently acknowledged packet at
// that moment.
- struct QUIC_EXPORT_PRIVATE ConnectionStateOnSentPacket {
+ struct QUICHE_EXPORT ConnectionStateOnSentPacket {
// Time at which the packet is sent.
QuicTime sent_time;
@@ -502,7 +502,7 @@
last_acked_packet_sent_time(QuicTime::Zero()),
last_acked_packet_ack_time(QuicTime::Zero()) {}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const ConnectionStateOnSentPacket& p) {
os << "{sent_time:" << p.sent_time << ", size:" << p.size
<< ", total_bytes_sent_at_last_acked_packet:"
diff --git a/quiche/quic/core/congestion_control/bbr2_drain.h b/quiche/quic/core/congestion_control/bbr2_drain.h
index 1d61a41..7741f53 100644
--- a/quiche/quic/core/congestion_control/bbr2_drain.h
+++ b/quiche/quic/core/congestion_control/bbr2_drain.h
@@ -13,7 +13,7 @@
namespace quic {
class Bbr2Sender;
-class QUIC_EXPORT_PRIVATE Bbr2DrainMode final : public Bbr2ModeBase {
+class QUICHE_EXPORT Bbr2DrainMode final : public Bbr2ModeBase {
public:
using Bbr2ModeBase::Bbr2ModeBase;
@@ -39,7 +39,7 @@
return Bbr2Mode::DRAIN;
}
- struct QUIC_EXPORT_PRIVATE DebugState {
+ struct QUICHE_EXPORT DebugState {
QuicByteCount drain_target;
};
@@ -51,8 +51,8 @@
QuicByteCount DrainTarget() const;
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const Bbr2DrainMode::DebugState& state);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const Bbr2DrainMode::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_misc.h b/quiche/quic/core/congestion_control/bbr2_misc.h
index 8f0f8f6..c621983 100644
--- a/quiche/quic/core/congestion_control/bbr2_misc.h
+++ b/quiche/quic/core/congestion_control/bbr2_misc.h
@@ -21,7 +21,7 @@
namespace quic {
template <typename T>
-class QUIC_EXPORT_PRIVATE Limits {
+class QUICHE_EXPORT Limits {
public:
Limits(T min, T max) : min_(min), max_(max) {}
@@ -40,34 +40,34 @@
};
template <typename T>
-QUIC_EXPORT_PRIVATE inline Limits<T> MinMax(T min, T max) {
+QUICHE_EXPORT inline Limits<T> MinMax(T min, T max) {
return Limits<T>(min, max);
}
template <typename T>
-QUIC_EXPORT_PRIVATE inline Limits<T> NoLessThan(T min) {
+QUICHE_EXPORT inline Limits<T> NoLessThan(T min) {
return Limits<T>(min, std::numeric_limits<T>::max());
}
template <typename T>
-QUIC_EXPORT_PRIVATE inline Limits<T> NoGreaterThan(T max) {
+QUICHE_EXPORT inline Limits<T> NoGreaterThan(T max) {
return Limits<T>(std::numeric_limits<T>::min(), max);
}
template <typename T>
-QUIC_EXPORT_PRIVATE inline Limits<T> Unlimited() {
+QUICHE_EXPORT inline Limits<T> Unlimited() {
return Limits<T>(std::numeric_limits<T>::min(),
std::numeric_limits<T>::max());
}
template <typename T>
-QUIC_EXPORT_PRIVATE inline std::ostream& operator<<(std::ostream& os,
- const Limits<T>& limits) {
+QUICHE_EXPORT inline std::ostream& operator<<(std::ostream& os,
+ const Limits<T>& limits) {
return os << "[" << limits.Min() << ", " << limits.Max() << "]";
}
// Bbr2Params contains all parameters of a Bbr2Sender.
-struct QUIC_EXPORT_PRIVATE Bbr2Params {
+struct QUICHE_EXPORT Bbr2Params {
Bbr2Params(QuicByteCount cwnd_min, QuicByteCount cwnd_max)
: cwnd_limits(cwnd_min, cwnd_max) {}
@@ -224,7 +224,7 @@
bool decrease_startup_pacing_at_end_of_round = false;
};
-class QUIC_EXPORT_PRIVATE RoundTripCounter {
+class QUICHE_EXPORT RoundTripCounter {
public:
RoundTripCounter();
@@ -247,7 +247,7 @@
QuicPacketNumber end_of_round_trip_;
};
-class QUIC_EXPORT_PRIVATE MinRttFilter {
+class QUICHE_EXPORT MinRttFilter {
public:
MinRttFilter(QuicTime::Delta initial_min_rtt,
QuicTime initial_min_rtt_timestamp);
@@ -266,7 +266,7 @@
QuicTime min_rtt_timestamp_;
};
-class QUIC_EXPORT_PRIVATE Bbr2MaxBandwidthFilter {
+class QUICHE_EXPORT Bbr2MaxBandwidthFilter {
public:
void Update(QuicBandwidth sample) {
max_bandwidth_[1] = std::max(sample, max_bandwidth_[1]);
@@ -292,7 +292,7 @@
// Information that are meaningful only when Bbr2Sender::OnCongestionEvent is
// running.
-struct QUIC_EXPORT_PRIVATE Bbr2CongestionEvent {
+struct QUICHE_EXPORT Bbr2CongestionEvent {
QuicTime event_time = QuicTime::Zero();
// The congestion window prior to the processing of the ack/loss events.
@@ -334,7 +334,7 @@
// Bbr2NetworkModel takes low level congestion signals(packets sent/acked/lost)
// as input and produces BBRv2 model parameters like inflight_(hi|lo),
// bandwidth_(hi|lo), bandwidth and rtt estimates, etc.
-class QUIC_EXPORT_PRIVATE Bbr2NetworkModel {
+class QUICHE_EXPORT Bbr2NetworkModel {
public:
Bbr2NetworkModel(const Bbr2Params* params, QuicTime::Delta initial_rtt,
QuicTime initial_rtt_timestamp, float cwnd_gain,
@@ -613,8 +613,8 @@
PROBE_RTT,
};
-QUIC_EXPORT_PRIVATE inline std::ostream& operator<<(std::ostream& os,
- const Bbr2Mode& mode) {
+QUICHE_EXPORT inline std::ostream& operator<<(std::ostream& os,
+ const Bbr2Mode& mode) {
switch (mode) {
case Bbr2Mode::STARTUP:
return os << "STARTUP";
@@ -631,7 +631,7 @@
// The base class for all BBRv2 modes. A Bbr2Sender is in one mode at a time,
// this interface is used to implement mode-specific behaviors.
class Bbr2Sender;
-class QUIC_EXPORT_PRIVATE Bbr2ModeBase {
+class QUICHE_EXPORT Bbr2ModeBase {
public:
Bbr2ModeBase(const Bbr2Sender* sender, Bbr2NetworkModel* model)
: sender_(sender), model_(model) {}
@@ -664,7 +664,7 @@
Bbr2NetworkModel* model_;
};
-QUIC_EXPORT_PRIVATE inline QuicByteCount BytesInFlight(
+QUICHE_EXPORT inline QuicByteCount BytesInFlight(
const SendTimeState& send_state) {
QUICHE_DCHECK(send_state.is_valid);
if (send_state.bytes_in_flight != 0) {
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_bw.h b/quiche/quic/core/congestion_control/bbr2_probe_bw.h
index 7a2448d..b5a1703 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_bw.h
+++ b/quiche/quic/core/congestion_control/bbr2_probe_bw.h
@@ -16,7 +16,7 @@
namespace quic {
class Bbr2Sender;
-class QUIC_EXPORT_PRIVATE Bbr2ProbeBwMode final : public Bbr2ModeBase {
+class QUICHE_EXPORT Bbr2ProbeBwMode final : public Bbr2ModeBase {
public:
using Bbr2ModeBase::Bbr2ModeBase;
@@ -48,7 +48,7 @@
static const char* CyclePhaseToString(CyclePhase phase);
- struct QUIC_EXPORT_PRIVATE DebugState {
+ struct QUICHE_EXPORT DebugState {
CyclePhase phase;
QuicTime cycle_start_time = QuicTime::Zero();
QuicTime phase_start_time = QuicTime::Zero();
@@ -106,7 +106,7 @@
void RaiseInflightHighSlope();
void ProbeInflightHighUpward(const Bbr2CongestionEvent& congestion_event);
- struct QUIC_EXPORT_PRIVATE Cycle {
+ struct QUICHE_EXPORT Cycle {
QuicTime cycle_start_time = QuicTime::Zero();
CyclePhase phase = CyclePhase::PROBE_NOT_STARTED;
uint64_t rounds_in_phase = 0;
@@ -127,11 +127,11 @@
bool last_cycle_stopped_risky_probe_;
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const Bbr2ProbeBwMode::DebugState& state);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const Bbr2ProbeBwMode::CyclePhase phase);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const Bbr2ProbeBwMode::CyclePhase phase);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_rtt.h b/quiche/quic/core/congestion_control/bbr2_probe_rtt.h
index a6edbb3..f832476 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_rtt.h
+++ b/quiche/quic/core/congestion_control/bbr2_probe_rtt.h
@@ -13,7 +13,7 @@
namespace quic {
class Bbr2Sender;
-class QUIC_EXPORT_PRIVATE Bbr2ProbeRttMode final : public Bbr2ModeBase {
+class QUICHE_EXPORT Bbr2ProbeRttMode final : public Bbr2ModeBase {
public:
using Bbr2ModeBase::Bbr2ModeBase;
@@ -35,7 +35,7 @@
Bbr2Mode OnExitQuiescence(QuicTime now,
QuicTime quiescence_start_time) override;
- struct QUIC_EXPORT_PRIVATE DebugState {
+ struct QUICHE_EXPORT DebugState {
QuicByteCount inflight_target;
QuicTime exit_time = QuicTime::Zero();
};
@@ -50,7 +50,7 @@
QuicTime exit_time_ = QuicTime::Zero();
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const Bbr2ProbeRttMode::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_sender.h b/quiche/quic/core/congestion_control/bbr2_sender.h
index 171028a..a49cda1 100644
--- a/quiche/quic/core/congestion_control/bbr2_sender.h
+++ b/quiche/quic/core/congestion_control/bbr2_sender.h
@@ -24,7 +24,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE Bbr2Sender final : public SendAlgorithmInterface {
+class QUICHE_EXPORT Bbr2Sender final : public SendAlgorithmInterface {
public:
Bbr2Sender(QuicTime now, const RttStats* rtt_stats,
const QuicUnackedPacketMap* unacked_packets,
@@ -112,7 +112,7 @@
return model_.IsBandwidthOverestimateAvoidanceEnabled();
}
- struct QUIC_EXPORT_PRIVATE DebugState {
+ struct QUICHE_EXPORT DebugState {
Bbr2Mode mode;
// Shared states.
@@ -210,8 +210,8 @@
friend class Bbr2ProbeRttMode;
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const Bbr2Sender::DebugState& state);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const Bbr2Sender::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_startup.h b/quiche/quic/core/congestion_control/bbr2_startup.h
index b246b3c..64fa5b0 100644
--- a/quiche/quic/core/congestion_control/bbr2_startup.h
+++ b/quiche/quic/core/congestion_control/bbr2_startup.h
@@ -14,7 +14,7 @@
namespace quic {
class Bbr2Sender;
-class QUIC_EXPORT_PRIVATE Bbr2StartupMode final : public Bbr2ModeBase {
+class QUICHE_EXPORT Bbr2StartupMode final : public Bbr2ModeBase {
public:
Bbr2StartupMode(const Bbr2Sender* sender, Bbr2NetworkModel* model,
QuicTime now);
@@ -44,7 +44,7 @@
return Bbr2Mode::STARTUP;
}
- struct QUIC_EXPORT_PRIVATE DebugState {
+ struct QUICHE_EXPORT DebugState {
bool full_bandwidth_reached;
QuicBandwidth full_bandwidth_baseline = QuicBandwidth::Zero();
QuicRoundTripCount round_trips_without_bandwidth_growth;
@@ -60,7 +60,7 @@
QuicBandwidth max_bw_at_round_beginning_ = QuicBandwidth::Zero();
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const Bbr2StartupMode::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr_sender.h b/quiche/quic/core/congestion_control/bbr_sender.h
index 1504004..61ad946 100644
--- a/quiche/quic/core/congestion_control/bbr_sender.h
+++ b/quiche/quic/core/congestion_control/bbr_sender.h
@@ -36,7 +36,7 @@
// pacing is disabled.
//
// TODO(vasilvv): implement traffic policer (long-term sampling) mode.
-class QUIC_EXPORT_PRIVATE BbrSender : public SendAlgorithmInterface {
+class QUICHE_EXPORT BbrSender : public SendAlgorithmInterface {
public:
enum Mode {
// Startup phase of the connection.
@@ -64,7 +64,7 @@
// Debug state can be exported in order to troubleshoot potential congestion
// control issues.
- struct QUIC_EXPORT_PRIVATE DebugState {
+ struct QUICHE_EXPORT DebugState {
explicit DebugState(const BbrSender& sender);
DebugState(const DebugState& state);
@@ -381,10 +381,10 @@
QuicByteCount max_congestion_window_with_network_parameters_adjusted_;
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const BbrSender::Mode& mode);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const BbrSender::DebugState& state);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const BbrSender::Mode& mode);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const BbrSender::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/cubic_bytes.h b/quiche/quic/core/congestion_control/cubic_bytes.h
index 6eb43ab..b580bcb 100644
--- a/quiche/quic/core/congestion_control/cubic_bytes.h
+++ b/quiche/quic/core/congestion_control/cubic_bytes.h
@@ -22,7 +22,7 @@
class CubicBytesTest;
} // namespace test
-class QUIC_EXPORT_PRIVATE CubicBytes {
+class QUICHE_EXPORT CubicBytes {
public:
explicit CubicBytes(const QuicClock* clock);
CubicBytes(const CubicBytes&) = delete;
diff --git a/quiche/quic/core/congestion_control/general_loss_algorithm.h b/quiche/quic/core/congestion_control/general_loss_algorithm.h
index 7e58616..875047f 100644
--- a/quiche/quic/core/congestion_control/general_loss_algorithm.h
+++ b/quiche/quic/core/congestion_control/general_loss_algorithm.h
@@ -20,7 +20,7 @@
// Class which can be configured to implement's TCP's approach of detecting loss
// when 3 nacks have been received for a packet or with a time threshold.
// Also implements TCP's early retransmit(RFC5827).
-class QUIC_EXPORT_PRIVATE GeneralLossAlgorithm : public LossDetectionInterface {
+class QUICHE_EXPORT GeneralLossAlgorithm : public LossDetectionInterface {
public:
GeneralLossAlgorithm() = default;
GeneralLossAlgorithm(const GeneralLossAlgorithm&) = delete;
diff --git a/quiche/quic/core/congestion_control/hybrid_slow_start.h b/quiche/quic/core/congestion_control/hybrid_slow_start.h
index 73c7670..5ba7599 100644
--- a/quiche/quic/core/congestion_control/hybrid_slow_start.h
+++ b/quiche/quic/core/congestion_control/hybrid_slow_start.h
@@ -24,7 +24,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE HybridSlowStart {
+class QUICHE_EXPORT HybridSlowStart {
public:
HybridSlowStart();
HybridSlowStart(const HybridSlowStart&) = delete;
diff --git a/quiche/quic/core/congestion_control/loss_detection_interface.h b/quiche/quic/core/congestion_control/loss_detection_interface.h
index c81702e..9b61698 100644
--- a/quiche/quic/core/congestion_control/loss_detection_interface.h
+++ b/quiche/quic/core/congestion_control/loss_detection_interface.h
@@ -19,14 +19,14 @@
class QuicUnackedPacketMap;
class RttStats;
-class QUIC_EXPORT_PRIVATE LossDetectionInterface {
+class QUICHE_EXPORT LossDetectionInterface {
public:
virtual ~LossDetectionInterface() {}
virtual void SetFromConfig(const QuicConfig& config,
Perspective perspective) = 0;
- struct QUIC_NO_EXPORT DetectionStats {
+ struct QUICHE_EXPORT DetectionStats {
// Maximum sequence reordering observed in newly acked packets.
QuicPacketCount sent_packets_max_sequence_reordering = 0;
QuicPacketCount sent_packets_num_borderline_time_reorderings = 0;
diff --git a/quiche/quic/core/congestion_control/pacing_sender.h b/quiche/quic/core/congestion_control/pacing_sender.h
index 73c08d4..239f745 100644
--- a/quiche/quic/core/congestion_control/pacing_sender.h
+++ b/quiche/quic/core/congestion_control/pacing_sender.h
@@ -28,7 +28,7 @@
class QuicSentPacketManagerPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE PacingSender {
+class QUICHE_EXPORT PacingSender {
public:
PacingSender();
PacingSender(const PacingSender&) = delete;
diff --git a/quiche/quic/core/congestion_control/prr_sender.h b/quiche/quic/core/congestion_control/prr_sender.h
index 4e17840..ae84fee 100644
--- a/quiche/quic/core/congestion_control/prr_sender.h
+++ b/quiche/quic/core/congestion_control/prr_sender.h
@@ -13,7 +13,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE PrrSender {
+class QUICHE_EXPORT PrrSender {
public:
PrrSender();
// OnPacketLost should be called on the first loss that triggers a recovery
diff --git a/quiche/quic/core/congestion_control/rtt_stats.h b/quiche/quic/core/congestion_control/rtt_stats.h
index 04a0148..1dc6708 100644
--- a/quiche/quic/core/congestion_control/rtt_stats.h
+++ b/quiche/quic/core/congestion_control/rtt_stats.h
@@ -21,12 +21,12 @@
class RttStatsPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE RttStats {
+class QUICHE_EXPORT RttStats {
public:
// Calculates running standard-deviation using Welford's algorithm:
// https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#
// Welford's_Online_algorithm.
- struct QUIC_EXPORT_PRIVATE StandardDeviationCaculator {
+ struct QUICHE_EXPORT StandardDeviationCaculator {
StandardDeviationCaculator() {}
// Called when a new RTT sample is available.
diff --git a/quiche/quic/core/congestion_control/send_algorithm_interface.h b/quiche/quic/core/congestion_control/send_algorithm_interface.h
index e5e8d58..ba471ba 100644
--- a/quiche/quic/core/congestion_control/send_algorithm_interface.h
+++ b/quiche/quic/core/congestion_control/send_algorithm_interface.h
@@ -29,10 +29,10 @@
class CachedNetworkParameters;
class RttStats;
-class QUIC_EXPORT_PRIVATE SendAlgorithmInterface {
+class QUICHE_EXPORT SendAlgorithmInterface {
public:
// Network Params for AdjustNetworkParameters.
- struct QUIC_NO_EXPORT NetworkParams {
+ struct QUICHE_EXPORT NetworkParams {
NetworkParams() = default;
NetworkParams(const QuicBandwidth& bandwidth, const QuicTime::Delta& rtt,
bool allow_cwnd_to_decrease)
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
index 184357d..cc6aa4e 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
@@ -31,7 +31,7 @@
class TcpCubicSenderBytesPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE TcpCubicSenderBytes : public SendAlgorithmInterface {
+class QUICHE_EXPORT TcpCubicSenderBytes : public SendAlgorithmInterface {
public:
TcpCubicSenderBytes(const QuicClock* clock, const RttStats* rtt_stats,
bool reno, QuicPacketCount initial_tcp_congestion_window,
diff --git a/quiche/quic/core/congestion_control/uber_loss_algorithm.h b/quiche/quic/core/congestion_control/uber_loss_algorithm.h
index febea73..19e3d9c 100644
--- a/quiche/quic/core/congestion_control/uber_loss_algorithm.h
+++ b/quiche/quic/core/congestion_control/uber_loss_algorithm.h
@@ -18,13 +18,13 @@
} // namespace test
-struct QUIC_EXPORT_PRIVATE LossDetectionParameters {
+struct QUICHE_EXPORT LossDetectionParameters {
// See GeneralLossAlgorithm for the meaning of reordering_(shift|threshold).
absl::optional<int> reordering_shift;
absl::optional<QuicPacketCount> reordering_threshold;
};
-class QUIC_EXPORT_PRIVATE LossDetectionTunerInterface {
+class QUICHE_EXPORT LossDetectionTunerInterface {
public:
virtual ~LossDetectionTunerInterface() {}
@@ -41,7 +41,7 @@
};
// This class comprises multiple loss algorithms, each per packet number space.
-class QUIC_EXPORT_PRIVATE UberLossAlgorithm : public LossDetectionInterface {
+class QUICHE_EXPORT UberLossAlgorithm : public LossDetectionInterface {
public:
UberLossAlgorithm();
UberLossAlgorithm(const UberLossAlgorithm&) = delete;
diff --git a/quiche/quic/core/congestion_control/windowed_filter.h b/quiche/quic/core/congestion_control/windowed_filter.h
index 9326a08..6309d93 100644
--- a/quiche/quic/core/congestion_control/windowed_filter.h
+++ b/quiche/quic/core/congestion_control/windowed_filter.h
@@ -38,14 +38,14 @@
// Compares two values and returns true if the first is less than or equal
// to the second.
template <class T>
-struct QUIC_EXPORT_PRIVATE MinFilter {
+struct QUICHE_EXPORT MinFilter {
bool operator()(const T& lhs, const T& rhs) const { return lhs <= rhs; }
};
// Compares two values and returns true if the first is greater than or equal
// to the second.
template <class T>
-struct QUIC_EXPORT_PRIVATE MaxFilter {
+struct QUICHE_EXPORT MaxFilter {
bool operator()(const T& lhs, const T& rhs) const { return lhs >= rhs; }
};
@@ -63,7 +63,7 @@
// two timestamps. Has to be the type of (a - b) if both |a| and |b| are
// of type TimeT.
template <class T, class Compare, typename TimeT, typename TimeDeltaT>
-class QUIC_EXPORT_PRIVATE WindowedFilter {
+class QUICHE_EXPORT WindowedFilter {
public:
// |window_length| is the period after which a best estimate expires.
// |zero_value| is used as the uninitialized value for objects of T.
@@ -146,7 +146,7 @@
T GetThirdBest() const { return estimates_[2].sample; }
private:
- struct QUIC_EXPORT_PRIVATE Sample {
+ struct QUICHE_EXPORT Sample {
T sample;
TimeT time;
Sample(T init_sample, TimeT init_time)
diff --git a/quiche/quic/core/connection_id_generator.h b/quiche/quic/core/connection_id_generator.h
index d27b44f..3e46a9e 100644
--- a/quiche/quic/core/connection_id_generator.h
+++ b/quiche/quic/core/connection_id_generator.h
@@ -10,7 +10,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE ConnectionIdGeneratorInterface {
+class QUICHE_EXPORT ConnectionIdGeneratorInterface {
// Interface which is responsible for generating new connection IDs from an
// existing connection ID.
public:
diff --git a/quiche/quic/core/crypto/aead_base_decrypter.h b/quiche/quic/core/crypto/aead_base_decrypter.h
index b123b13..0454919 100644
--- a/quiche/quic/core/crypto/aead_base_decrypter.h
+++ b/quiche/quic/core/crypto/aead_base_decrypter.h
@@ -15,7 +15,7 @@
namespace quic {
// AeadBaseDecrypter is the base class of AEAD QuicDecrypter subclasses.
-class QUIC_EXPORT_PRIVATE AeadBaseDecrypter : public QuicDecrypter {
+class QUICHE_EXPORT AeadBaseDecrypter : public QuicDecrypter {
public:
// This takes the function pointer rather than the EVP_AEAD itself so
// subclasses do not need to call CRYPTO_library_init.
diff --git a/quiche/quic/core/crypto/aead_base_encrypter.h b/quiche/quic/core/crypto/aead_base_encrypter.h
index 205b232..cf2c8cd 100644
--- a/quiche/quic/core/crypto/aead_base_encrypter.h
+++ b/quiche/quic/core/crypto/aead_base_encrypter.h
@@ -15,7 +15,7 @@
namespace quic {
// AeadBaseEncrypter is the base class of AEAD QuicEncrypter subclasses.
-class QUIC_EXPORT_PRIVATE AeadBaseEncrypter : public QuicEncrypter {
+class QUICHE_EXPORT AeadBaseEncrypter : public QuicEncrypter {
public:
// This takes the function pointer rather than the EVP_AEAD itself so
// subclasses do not need to call CRYPTO_library_init.
diff --git a/quiche/quic/core/crypto/aes_128_gcm_12_decrypter.h b/quiche/quic/core/crypto/aes_128_gcm_12_decrypter.h
index 38a9419..ec2afdb 100644
--- a/quiche/quic/core/crypto/aes_128_gcm_12_decrypter.h
+++ b/quiche/quic/core/crypto/aes_128_gcm_12_decrypter.h
@@ -18,7 +18,7 @@
//
// It uses an authentication tag of 12 bytes (96 bits). The fixed prefix
// of the nonce is four bytes.
-class QUIC_EXPORT_PRIVATE Aes128Gcm12Decrypter : public AesBaseDecrypter {
+class QUICHE_EXPORT Aes128Gcm12Decrypter : public AesBaseDecrypter {
public:
enum {
// Authentication tags are truncated to 96 bits.
diff --git a/quiche/quic/core/crypto/aes_128_gcm_12_encrypter.h b/quiche/quic/core/crypto/aes_128_gcm_12_encrypter.h
index 64f0292..16112e2 100644
--- a/quiche/quic/core/crypto/aes_128_gcm_12_encrypter.h
+++ b/quiche/quic/core/crypto/aes_128_gcm_12_encrypter.h
@@ -16,7 +16,7 @@
//
// It uses an authentication tag of 12 bytes (96 bits). The fixed prefix
// of the nonce is four bytes.
-class QUIC_EXPORT_PRIVATE Aes128Gcm12Encrypter : public AesBaseEncrypter {
+class QUICHE_EXPORT Aes128Gcm12Encrypter : public AesBaseEncrypter {
public:
enum {
// Authentication tags are truncated to 96 bits.
diff --git a/quiche/quic/core/crypto/aes_128_gcm_decrypter.h b/quiche/quic/core/crypto/aes_128_gcm_decrypter.h
index c5f4d17..754d25d 100644
--- a/quiche/quic/core/crypto/aes_128_gcm_decrypter.h
+++ b/quiche/quic/core/crypto/aes_128_gcm_decrypter.h
@@ -17,7 +17,7 @@
//
// It uses an authentication tag of 16 bytes (128 bits). It uses a 12 byte IV
// that is XOR'd with the packet number to compute the nonce.
-class QUIC_EXPORT_PRIVATE Aes128GcmDecrypter : public AesBaseDecrypter {
+class QUICHE_EXPORT Aes128GcmDecrypter : public AesBaseDecrypter {
public:
enum {
kAuthTagSize = 16,
diff --git a/quiche/quic/core/crypto/aes_128_gcm_encrypter.h b/quiche/quic/core/crypto/aes_128_gcm_encrypter.h
index a40735c..d36e0ea 100644
--- a/quiche/quic/core/crypto/aes_128_gcm_encrypter.h
+++ b/quiche/quic/core/crypto/aes_128_gcm_encrypter.h
@@ -15,7 +15,7 @@
//
// It uses an authentication tag of 16 bytes (128 bits). It uses a 12 byte IV
// that is XOR'd with the packet number to compute the nonce.
-class QUIC_EXPORT_PRIVATE Aes128GcmEncrypter : public AesBaseEncrypter {
+class QUICHE_EXPORT Aes128GcmEncrypter : public AesBaseEncrypter {
public:
enum {
kAuthTagSize = 16,
diff --git a/quiche/quic/core/crypto/aes_256_gcm_decrypter.h b/quiche/quic/core/crypto/aes_256_gcm_decrypter.h
index dc4f8c0..77aca53 100644
--- a/quiche/quic/core/crypto/aes_256_gcm_decrypter.h
+++ b/quiche/quic/core/crypto/aes_256_gcm_decrypter.h
@@ -17,7 +17,7 @@
//
// It uses an authentication tag of 16 bytes (128 bits). It uses a 12 byte IV
// that is XOR'd with the packet number to compute the nonce.
-class QUIC_EXPORT_PRIVATE Aes256GcmDecrypter : public AesBaseDecrypter {
+class QUICHE_EXPORT Aes256GcmDecrypter : public AesBaseDecrypter {
public:
enum {
kAuthTagSize = 16,
diff --git a/quiche/quic/core/crypto/aes_256_gcm_encrypter.h b/quiche/quic/core/crypto/aes_256_gcm_encrypter.h
index 9ba47f1..0718077 100644
--- a/quiche/quic/core/crypto/aes_256_gcm_encrypter.h
+++ b/quiche/quic/core/crypto/aes_256_gcm_encrypter.h
@@ -15,7 +15,7 @@
//
// It uses an authentication tag of 16 bytes (128 bits). It uses a 12 byte IV
// that is XOR'd with the packet number to compute the nonce.
-class QUIC_EXPORT_PRIVATE Aes256GcmEncrypter : public AesBaseEncrypter {
+class QUICHE_EXPORT Aes256GcmEncrypter : public AesBaseEncrypter {
public:
enum {
kAuthTagSize = 16,
diff --git a/quiche/quic/core/crypto/aes_base_decrypter.h b/quiche/quic/core/crypto/aes_base_decrypter.h
index 9fa35cf..17296a9 100644
--- a/quiche/quic/core/crypto/aes_base_decrypter.h
+++ b/quiche/quic/core/crypto/aes_base_decrypter.h
@@ -14,7 +14,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE AesBaseDecrypter : public AeadBaseDecrypter {
+class QUICHE_EXPORT AesBaseDecrypter : public AeadBaseDecrypter {
public:
using AeadBaseDecrypter::AeadBaseDecrypter;
diff --git a/quiche/quic/core/crypto/aes_base_encrypter.h b/quiche/quic/core/crypto/aes_base_encrypter.h
index c4fdb86..d596579 100644
--- a/quiche/quic/core/crypto/aes_base_encrypter.h
+++ b/quiche/quic/core/crypto/aes_base_encrypter.h
@@ -14,7 +14,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE AesBaseEncrypter : public AeadBaseEncrypter {
+class QUICHE_EXPORT AesBaseEncrypter : public AeadBaseEncrypter {
public:
using AeadBaseEncrypter::AeadBaseEncrypter;
diff --git a/quiche/quic/core/crypto/boring_utils.h b/quiche/quic/core/crypto/boring_utils.h
index d6a1dd4..d083ab3 100644
--- a/quiche/quic/core/crypto/boring_utils.h
+++ b/quiche/quic/core/crypto/boring_utils.h
@@ -11,20 +11,19 @@
namespace quic {
-inline QUIC_EXPORT_PRIVATE absl::string_view CbsToStringPiece(CBS cbs) {
+inline QUICHE_EXPORT absl::string_view CbsToStringPiece(CBS cbs) {
return absl::string_view(reinterpret_cast<const char*>(CBS_data(&cbs)),
CBS_len(&cbs));
}
-inline QUIC_EXPORT_PRIVATE CBS StringPieceToCbs(absl::string_view piece) {
+inline QUICHE_EXPORT CBS StringPieceToCbs(absl::string_view piece) {
CBS result;
CBS_init(&result, reinterpret_cast<const uint8_t*>(piece.data()),
piece.size());
return result;
}
-inline QUIC_EXPORT_PRIVATE bool AddStringToCbb(CBB* cbb,
- absl::string_view piece) {
+inline QUICHE_EXPORT bool AddStringToCbb(CBB* cbb, absl::string_view piece) {
return 1 == CBB_add_bytes(cbb, reinterpret_cast<const uint8_t*>(piece.data()),
piece.size());
}
diff --git a/quiche/quic/core/crypto/cert_compressor.h b/quiche/quic/core/crypto/cert_compressor.h
index 9509ccd..2e3fe42 100644
--- a/quiche/quic/core/crypto/cert_compressor.h
+++ b/quiche/quic/core/crypto/cert_compressor.h
@@ -22,7 +22,7 @@
// 2) Otherwise the certificates are compressed with zlib using a pre-shared
// dictionary that consists of the certificates handled with the above
// methods and a small chunk of common substrings.
-class QUIC_EXPORT_PRIVATE CertCompressor {
+class QUICHE_EXPORT CertCompressor {
public:
CertCompressor() = delete;
diff --git a/quiche/quic/core/crypto/certificate_util.h b/quiche/quic/core/crypto/certificate_util.h
index 35bb561..c6593db 100644
--- a/quiche/quic/core/crypto/certificate_util.h
+++ b/quiche/quic/core/crypto/certificate_util.h
@@ -14,7 +14,7 @@
namespace quic {
-struct QUIC_NO_EXPORT CertificateTimestamp {
+struct QUICHE_EXPORT CertificateTimestamp {
uint16_t year;
uint8_t month;
uint8_t day;
@@ -23,7 +23,7 @@
uint8_t second;
};
-struct QUIC_NO_EXPORT CertificateOptions {
+struct QUICHE_EXPORT CertificateOptions {
absl::string_view subject;
uint64_t serial_number;
CertificateTimestamp validity_start; // a.k.a not_valid_before
@@ -31,14 +31,13 @@
};
// Creates a ECDSA P-256 key pair.
-QUIC_EXPORT_PRIVATE bssl::UniquePtr<EVP_PKEY>
-MakeKeyPairForSelfSignedCertificate();
+QUICHE_EXPORT bssl::UniquePtr<EVP_PKEY> MakeKeyPairForSelfSignedCertificate();
// Creates a self-signed, DER-encoded X.509 certificate.
// |key| must be a ECDSA P-256 key.
// This is mostly stolen from Chromium's net/cert/x509_util.h, with
// modifications to make it work in QUICHE.
-QUIC_EXPORT_PRIVATE std::string CreateSelfSignedCertificate(
+QUICHE_EXPORT std::string CreateSelfSignedCertificate(
EVP_PKEY& key, const CertificateOptions& options);
} // namespace quic
diff --git a/quiche/quic/core/crypto/certificate_view.cc b/quiche/quic/core/crypto/certificate_view.cc
index c3b187c..b02c58c 100644
--- a/quiche/quic/core/crypto/certificate_view.cc
+++ b/quiche/quic/core/crypto/certificate_view.cc
@@ -99,7 +99,7 @@
}
}
-QUIC_EXPORT_PRIVATE QuicSignatureAlgorithmVector
+QUICHE_EXPORT QuicSignatureAlgorithmVector
SupportedSignatureAlgorithmsForQuic() {
// This should be kept in sync with the list in
// PublicKeyTypeFromSignatureAlgorithm().
diff --git a/quiche/quic/core/crypto/certificate_view.h b/quiche/quic/core/crypto/certificate_view.h
index 5c2aafc..4a190a0 100644
--- a/quiche/quic/core/crypto/certificate_view.h
+++ b/quiche/quic/core/crypto/certificate_view.h
@@ -22,7 +22,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE PemReadResult {
+struct QUICHE_EXPORT PemReadResult {
enum Status { kOk, kEof, kError };
Status status;
std::string contents;
@@ -32,7 +32,7 @@
};
// Reads |input| line-by-line and returns the next available PEM message.
-QUIC_EXPORT_PRIVATE PemReadResult ReadNextPemMessage(std::istream* input);
+QUICHE_EXPORT PemReadResult ReadNextPemMessage(std::istream* input);
// Cryptograhpic algorithms recognized in X.509.
enum class PublicKeyType {
@@ -42,20 +42,20 @@
kEd25519,
kUnknown,
};
-QUIC_EXPORT_PRIVATE std::string PublicKeyTypeToString(PublicKeyType type);
-QUIC_EXPORT_PRIVATE PublicKeyType
+QUICHE_EXPORT std::string PublicKeyTypeToString(PublicKeyType type);
+QUICHE_EXPORT PublicKeyType
PublicKeyTypeFromSignatureAlgorithm(uint16_t signature_algorithm);
// Returns the list of the signature algorithms that can be processed by
// CertificateView::VerifySignature() and CertificatePrivateKey::Sign().
-QUIC_EXPORT_PRIVATE QuicSignatureAlgorithmVector
+QUICHE_EXPORT QuicSignatureAlgorithmVector
SupportedSignatureAlgorithmsForQuic();
// CertificateView represents a parsed version of a single X.509 certificate. As
// the word "view" implies, it does not take ownership of the underlying strings
// and consists primarily of pointers into the certificate that is passed into
// the parser.
-class QUIC_EXPORT_PRIVATE CertificateView {
+class QUICHE_EXPORT CertificateView {
public:
// Parses a single DER-encoded X.509 certificate. Returns nullptr on parse
// error.
@@ -109,7 +109,7 @@
// CertificatePrivateKey represents a private key that can be used with an X.509
// certificate.
-class QUIC_EXPORT_PRIVATE CertificatePrivateKey {
+class QUICHE_EXPORT CertificatePrivateKey {
public:
explicit CertificatePrivateKey(bssl::UniquePtr<EVP_PKEY> private_key)
: private_key_(std::move(private_key)) {}
@@ -143,12 +143,11 @@
};
// Parses a DER-encoded X.509 NameAttribute. Exposed primarily for testing.
-QUIC_EXPORT_PRIVATE absl::optional<std::string> X509NameAttributeToString(
- CBS input);
+QUICHE_EXPORT absl::optional<std::string> X509NameAttributeToString(CBS input);
// Parses a DER time based on the specified ASN.1 tag. Exposed primarily for
// testing.
-QUIC_EXPORT_PRIVATE absl::optional<quic::QuicWallTime> ParseDerTime(
+QUICHE_EXPORT absl::optional<quic::QuicWallTime> ParseDerTime(
unsigned tag, absl::string_view payload);
} // namespace quic
diff --git a/quiche/quic/core/crypto/chacha20_poly1305_decrypter.h b/quiche/quic/core/crypto/chacha20_poly1305_decrypter.h
index 6eb6c87..c516190 100644
--- a/quiche/quic/core/crypto/chacha20_poly1305_decrypter.h
+++ b/quiche/quic/core/crypto/chacha20_poly1305_decrypter.h
@@ -19,8 +19,7 @@
//
// It uses an authentication tag of 12 bytes (96 bits). The fixed prefix of the
// nonce is four bytes.
-class QUIC_EXPORT_PRIVATE ChaCha20Poly1305Decrypter
- : public ChaChaBaseDecrypter {
+class QUICHE_EXPORT ChaCha20Poly1305Decrypter : public ChaChaBaseDecrypter {
public:
enum {
kAuthTagSize = 12,
diff --git a/quiche/quic/core/crypto/chacha20_poly1305_encrypter.h b/quiche/quic/core/crypto/chacha20_poly1305_encrypter.h
index d37f26c..9f969ab 100644
--- a/quiche/quic/core/crypto/chacha20_poly1305_encrypter.h
+++ b/quiche/quic/core/crypto/chacha20_poly1305_encrypter.h
@@ -17,8 +17,7 @@
//
// It uses an authentication tag of 12 bytes (96 bits). The fixed prefix of the
// nonce is four bytes.
-class QUIC_EXPORT_PRIVATE ChaCha20Poly1305Encrypter
- : public ChaChaBaseEncrypter {
+class QUICHE_EXPORT ChaCha20Poly1305Encrypter : public ChaChaBaseEncrypter {
public:
enum {
kAuthTagSize = 12,
diff --git a/quiche/quic/core/crypto/chacha20_poly1305_tls_decrypter.h b/quiche/quic/core/crypto/chacha20_poly1305_tls_decrypter.h
index f8108f2..15a7970 100644
--- a/quiche/quic/core/crypto/chacha20_poly1305_tls_decrypter.h
+++ b/quiche/quic/core/crypto/chacha20_poly1305_tls_decrypter.h
@@ -17,8 +17,7 @@
//
// It uses an authentication tag of 16 bytes (128 bits). It uses a 12 bytes IV
// that is XOR'd with the packet number to compute the nonce.
-class QUIC_EXPORT_PRIVATE ChaCha20Poly1305TlsDecrypter
- : public ChaChaBaseDecrypter {
+class QUICHE_EXPORT ChaCha20Poly1305TlsDecrypter : public ChaChaBaseDecrypter {
public:
enum {
kAuthTagSize = 16,
diff --git a/quiche/quic/core/crypto/chacha20_poly1305_tls_encrypter.h b/quiche/quic/core/crypto/chacha20_poly1305_tls_encrypter.h
index e5d8f37..2a77102 100644
--- a/quiche/quic/core/crypto/chacha20_poly1305_tls_encrypter.h
+++ b/quiche/quic/core/crypto/chacha20_poly1305_tls_encrypter.h
@@ -15,8 +15,7 @@
//
// It uses an authentication tag of 16 bytes (128 bits). It uses a 12 byte IV
// that is XOR'd with the packet number to compute the nonce.
-class QUIC_EXPORT_PRIVATE ChaCha20Poly1305TlsEncrypter
- : public ChaChaBaseEncrypter {
+class QUICHE_EXPORT ChaCha20Poly1305TlsEncrypter : public ChaChaBaseEncrypter {
public:
enum {
kAuthTagSize = 16,
diff --git a/quiche/quic/core/crypto/chacha_base_decrypter.h b/quiche/quic/core/crypto/chacha_base_decrypter.h
index 5cd08c7..c33367e 100644
--- a/quiche/quic/core/crypto/chacha_base_decrypter.h
+++ b/quiche/quic/core/crypto/chacha_base_decrypter.h
@@ -13,7 +13,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE ChaChaBaseDecrypter : public AeadBaseDecrypter {
+class QUICHE_EXPORT ChaChaBaseDecrypter : public AeadBaseDecrypter {
public:
using AeadBaseDecrypter::AeadBaseDecrypter;
diff --git a/quiche/quic/core/crypto/chacha_base_encrypter.h b/quiche/quic/core/crypto/chacha_base_encrypter.h
index 14773ec..cd57974 100644
--- a/quiche/quic/core/crypto/chacha_base_encrypter.h
+++ b/quiche/quic/core/crypto/chacha_base_encrypter.h
@@ -13,7 +13,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE ChaChaBaseEncrypter : public AeadBaseEncrypter {
+class QUICHE_EXPORT ChaChaBaseEncrypter : public AeadBaseEncrypter {
public:
using AeadBaseEncrypter::AeadBaseEncrypter;
diff --git a/quiche/quic/core/crypto/channel_id.h b/quiche/quic/core/crypto/channel_id.h
index 2f8a527..a4cfa18 100644
--- a/quiche/quic/core/crypto/channel_id.h
+++ b/quiche/quic/core/crypto/channel_id.h
@@ -15,7 +15,7 @@
namespace quic {
// ChannelIDVerifier verifies ChannelID signatures.
-class QUIC_EXPORT_PRIVATE ChannelIDVerifier {
+class QUICHE_EXPORT ChannelIDVerifier {
public:
ChannelIDVerifier() = delete;
diff --git a/quiche/quic/core/crypto/client_proof_source.h b/quiche/quic/core/crypto/client_proof_source.h
index d1450f7..f2ceb12 100644
--- a/quiche/quic/core/crypto/client_proof_source.h
+++ b/quiche/quic/core/crypto/client_proof_source.h
@@ -15,13 +15,13 @@
// ClientProofSource is the interface for a QUIC client to provide client certs
// and keys based on server hostname. It is only used by TLS handshakes.
-class QUIC_EXPORT_PRIVATE ClientProofSource {
+class QUICHE_EXPORT ClientProofSource {
public:
using Chain = ProofSource::Chain;
virtual ~ClientProofSource() {}
- struct QUIC_EXPORT_PRIVATE CertAndKey {
+ struct QUICHE_EXPORT CertAndKey {
CertAndKey(quiche::QuicheReferenceCountedPointer<Chain> chain,
CertificatePrivateKey private_key)
: chain(std::move(chain)), private_key(std::move(private_key)) {}
@@ -43,7 +43,7 @@
// DefaultClientProofSource is an implementation that simply keeps an in memory
// map of server hostnames to certs.
-class QUIC_EXPORT_PRIVATE DefaultClientProofSource : public ClientProofSource {
+class QUICHE_EXPORT DefaultClientProofSource : public ClientProofSource {
public:
~DefaultClientProofSource() override {}
diff --git a/quiche/quic/core/crypto/crypto_framer.h b/quiche/quic/core/crypto/crypto_framer.h
index 8d20bdc..7bcb89e 100644
--- a/quiche/quic/core/crypto/crypto_framer.h
+++ b/quiche/quic/core/crypto/crypto_framer.h
@@ -23,7 +23,7 @@
class QuicData;
class QuicDataWriter;
-class QUIC_EXPORT_PRIVATE CryptoFramerVisitorInterface {
+class QUICHE_EXPORT CryptoFramerVisitorInterface {
public:
virtual ~CryptoFramerVisitorInterface() {}
@@ -36,7 +36,7 @@
// A class for framing the crypto messages that are exchanged in a QUIC
// session.
-class QUIC_EXPORT_PRIVATE CryptoFramer : public CryptoMessageParser {
+class QUICHE_EXPORT CryptoFramer : public CryptoMessageParser {
public:
CryptoFramer();
diff --git a/quiche/quic/core/crypto/crypto_handshake.h b/quiche/quic/core/crypto/crypto_handshake.h
index 6a4b274..89eb6fb 100644
--- a/quiche/quic/core/crypto/crypto_handshake.h
+++ b/quiche/quic/core/crypto/crypto_handshake.h
@@ -87,7 +87,7 @@
static_assert(MAX_FAILURE_REASON <= 32, "failure reason out of sync");
// A CrypterPair contains the encrypter and decrypter for an encryption level.
-struct QUIC_EXPORT_PRIVATE CrypterPair {
+struct QUICHE_EXPORT CrypterPair {
CrypterPair();
CrypterPair(CrypterPair&&) = default;
~CrypterPair();
@@ -97,7 +97,7 @@
};
// Parameters negotiated by the crypto handshake.
-struct QUIC_EXPORT_PRIVATE QuicCryptoNegotiatedParameters
+struct QUICHE_EXPORT QuicCryptoNegotiatedParameters
: public quiche::QuicheReferenceCounted {
// Initializes the members to 0 or empty values.
QuicCryptoNegotiatedParameters();
@@ -157,7 +157,7 @@
};
// QuicCryptoConfig contains common configuration between clients and servers.
-class QUIC_EXPORT_PRIVATE QuicCryptoConfig {
+class QUICHE_EXPORT QuicCryptoConfig {
public:
// kInitialLabel is a constant that is used when deriving the initial
// (non-forward secure) keys for the connection in order to tie the resulting
diff --git a/quiche/quic/core/crypto/crypto_handshake_message.h b/quiche/quic/core/crypto/crypto_handshake_message.h
index b50c559..cc51ce3 100644
--- a/quiche/quic/core/crypto/crypto_handshake_message.h
+++ b/quiche/quic/core/crypto/crypto_handshake_message.h
@@ -20,7 +20,7 @@
// An intermediate format of a handshake message that's convenient for a
// CryptoFramer to serialize from or parse into.
-class QUIC_EXPORT_PRIVATE CryptoHandshakeMessage {
+class QUICHE_EXPORT CryptoHandshakeMessage {
public:
CryptoHandshakeMessage();
CryptoHandshakeMessage(const CryptoHandshakeMessage& other);
diff --git a/quiche/quic/core/crypto/crypto_message_parser.h b/quiche/quic/core/crypto/crypto_message_parser.h
index f819209..b24c5ad 100644
--- a/quiche/quic/core/crypto/crypto_message_parser.h
+++ b/quiche/quic/core/crypto/crypto_message_parser.h
@@ -13,7 +13,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE CryptoMessageParser {
+class QUICHE_EXPORT CryptoMessageParser {
public:
virtual ~CryptoMessageParser() {}
diff --git a/quiche/quic/core/crypto/crypto_secret_boxer.h b/quiche/quic/core/crypto/crypto_secret_boxer.h
index 5d334c3..964d760 100644
--- a/quiche/quic/core/crypto/crypto_secret_boxer.h
+++ b/quiche/quic/core/crypto/crypto_secret_boxer.h
@@ -20,7 +20,7 @@
// CryptoSecretBoxer encrypts small chunks of plaintext (called 'boxing') and
// then, later, can authenticate+decrypt the resulting boxes. This object is
// thread-safe.
-class QUIC_EXPORT_PRIVATE CryptoSecretBoxer {
+class QUICHE_EXPORT CryptoSecretBoxer {
public:
CryptoSecretBoxer();
CryptoSecretBoxer(const CryptoSecretBoxer&) = delete;
diff --git a/quiche/quic/core/crypto/crypto_utils.h b/quiche/quic/core/crypto/crypto_utils.h
index adc818d..12822aa 100644
--- a/quiche/quic/core/crypto/crypto_utils.h
+++ b/quiche/quic/core/crypto/crypto_utils.h
@@ -27,14 +27,14 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE CryptoUtils {
+class QUICHE_EXPORT CryptoUtils {
public:
CryptoUtils() = delete;
// Diversification is a utility class that's used to act like a union type.
// Values can be created by calling the functions like |NoDiversification|,
// below.
- class QUIC_EXPORT_PRIVATE Diversification {
+ class QUICHE_EXPORT Diversification {
public:
enum Mode {
NEVER, // Key diversification will never be used. Forward secure
diff --git a/quiche/quic/core/crypto/curve25519_key_exchange.h b/quiche/quic/core/crypto/curve25519_key_exchange.h
index b6e06f3..8354c1a 100644
--- a/quiche/quic/core/crypto/curve25519_key_exchange.h
+++ b/quiche/quic/core/crypto/curve25519_key_exchange.h
@@ -17,8 +17,7 @@
// Curve25519KeyExchange implements a SynchronousKeyExchange using
// elliptic-curve Diffie-Hellman on curve25519. See http://cr.yp.to/ecdh.html
-class QUIC_EXPORT_PRIVATE Curve25519KeyExchange
- : public SynchronousKeyExchange {
+class QUICHE_EXPORT Curve25519KeyExchange : public SynchronousKeyExchange {
public:
~Curve25519KeyExchange() override;
diff --git a/quiche/quic/core/crypto/key_exchange.h b/quiche/quic/core/crypto/key_exchange.h
index 573b289..029a283 100644
--- a/quiche/quic/core/crypto/key_exchange.h
+++ b/quiche/quic/core/crypto/key_exchange.h
@@ -18,13 +18,13 @@
// Interface for a Diffie-Hellman key exchange with an asynchronous interface.
// This allows for implementations which hold the private key locally, as well
// as ones which make an RPC to an external key-exchange service.
-class QUIC_EXPORT_PRIVATE AsynchronousKeyExchange {
+class QUICHE_EXPORT AsynchronousKeyExchange {
public:
virtual ~AsynchronousKeyExchange() = default;
// Callback base class for receiving the results of an async call to
// CalculateSharedKeys.
- class QUIC_EXPORT_PRIVATE Callback {
+ class QUICHE_EXPORT Callback {
public:
Callback() = default;
virtual ~Callback() = default;
@@ -57,8 +57,7 @@
// Interface for a Diffie-Hellman key exchange with both synchronous and
// asynchronous interfaces. Only implementations which hold the private key
// locally should implement this interface.
-class QUIC_EXPORT_PRIVATE SynchronousKeyExchange
- : public AsynchronousKeyExchange {
+class QUICHE_EXPORT SynchronousKeyExchange : public AsynchronousKeyExchange {
public:
virtual ~SynchronousKeyExchange() = default;
diff --git a/quiche/quic/core/crypto/null_decrypter.h b/quiche/quic/core/crypto/null_decrypter.h
index 9b6fb45..0db63df 100644
--- a/quiche/quic/core/crypto/null_decrypter.h
+++ b/quiche/quic/core/crypto/null_decrypter.h
@@ -21,7 +21,7 @@
// A NullDecrypter is a QuicDecrypter used before a crypto negotiation
// has occurred. It does not actually decrypt the payload, but does
// verify a hash (fnv128) over both the payload and associated data.
-class QUIC_EXPORT_PRIVATE NullDecrypter : public QuicDecrypter {
+class QUICHE_EXPORT NullDecrypter : public QuicDecrypter {
public:
explicit NullDecrypter(Perspective perspective);
NullDecrypter(const NullDecrypter&) = delete;
diff --git a/quiche/quic/core/crypto/null_encrypter.h b/quiche/quic/core/crypto/null_encrypter.h
index c5e599f..3789623 100644
--- a/quiche/quic/core/crypto/null_encrypter.h
+++ b/quiche/quic/core/crypto/null_encrypter.h
@@ -17,7 +17,7 @@
// A NullEncrypter is a QuicEncrypter used before a crypto negotiation
// has occurred. It does not actually encrypt the payload, but does
// generate a MAC (fnv128) over both the payload and associated data.
-class QUIC_EXPORT_PRIVATE NullEncrypter : public QuicEncrypter {
+class QUICHE_EXPORT NullEncrypter : public QuicEncrypter {
public:
explicit NullEncrypter(Perspective perspective);
NullEncrypter(const NullEncrypter&) = delete;
diff --git a/quiche/quic/core/crypto/p256_key_exchange.h b/quiche/quic/core/crypto/p256_key_exchange.h
index 1341331..2a3b80c 100644
--- a/quiche/quic/core/crypto/p256_key_exchange.h
+++ b/quiche/quic/core/crypto/p256_key_exchange.h
@@ -17,7 +17,7 @@
// P256KeyExchange implements a SynchronousKeyExchange using elliptic-curve
// Diffie-Hellman on NIST P-256.
-class QUIC_EXPORT_PRIVATE P256KeyExchange : public SynchronousKeyExchange {
+class QUICHE_EXPORT P256KeyExchange : public SynchronousKeyExchange {
public:
~P256KeyExchange() override;
diff --git a/quiche/quic/core/crypto/proof_source.h b/quiche/quic/core/crypto/proof_source.h
index 7721554..01907c1 100644
--- a/quiche/quic/core/crypto/proof_source.h
+++ b/quiche/quic/core/crypto/proof_source.h
@@ -26,7 +26,7 @@
// CryptoBuffers is a RAII class to own a std::vector<CRYPTO_BUFFER*> and the
// buffers the elements point to.
-struct QUIC_EXPORT_PRIVATE CryptoBuffers {
+struct QUICHE_EXPORT CryptoBuffers {
CryptoBuffers() = default;
CryptoBuffers(const CryptoBuffers&) = delete;
CryptoBuffers(CryptoBuffers&&) = default;
@@ -37,11 +37,11 @@
// ProofSource is an interface by which a QUIC server can obtain certificate
// chains and signatures that prove its identity.
-class QUIC_EXPORT_PRIVATE ProofSource {
+class QUICHE_EXPORT ProofSource {
public:
// Chain is a reference-counted wrapper for a vector of stringified
// certificates.
- struct QUIC_EXPORT_PRIVATE Chain : public quiche::QuicheReferenceCounted {
+ struct QUICHE_EXPORT Chain : public quiche::QuicheReferenceCounted {
explicit Chain(const std::vector<std::string>& certs);
Chain(const Chain&) = delete;
Chain& operator=(const Chain&) = delete;
@@ -56,13 +56,13 @@
// Details is an abstract class which acts as a container for any
// implementation-specific details that a ProofSource wants to return.
- class QUIC_EXPORT_PRIVATE Details {
+ class QUICHE_EXPORT Details {
public:
virtual ~Details() {}
};
// Callback base class for receiving the results of an async call to GetProof.
- class QUIC_EXPORT_PRIVATE Callback {
+ class QUICHE_EXPORT Callback {
public:
Callback() {}
virtual ~Callback() {}
@@ -93,7 +93,7 @@
};
// Base class for signalling the completion of a call to ComputeTlsSignature.
- class QUIC_EXPORT_PRIVATE SignatureCallback {
+ class QUICHE_EXPORT SignatureCallback {
public:
SignatureCallback() {}
virtual ~SignatureCallback() = default;
@@ -183,7 +183,7 @@
virtual QuicSignatureAlgorithmVector SupportedTlsSignatureAlgorithms()
const = 0;
- class QUIC_EXPORT_PRIVATE DecryptCallback {
+ class QUICHE_EXPORT DecryptCallback {
public:
DecryptCallback() = default;
virtual ~DecryptCallback() = default;
@@ -201,7 +201,7 @@
// Encrypt/Seal operation and a potentially asynchronous Decrypt/Open
// operation. This interface allows for ticket decryptions to be performed on
// a remote service.
- class QUIC_EXPORT_PRIVATE TicketCrypter {
+ class QUICHE_EXPORT TicketCrypter {
public:
TicketCrypter() = default;
virtual ~TicketCrypter() = default;
@@ -241,7 +241,7 @@
// the operations in ProofSourceHandle completes.
// TODO(wub): Consider deprecating ProofSource by moving all functionalities of
// ProofSource into ProofSourceHandle.
-class QUIC_EXPORT_PRIVATE ProofSourceHandleCallback {
+class QUICHE_EXPORT ProofSourceHandleCallback {
public:
virtual ~ProofSourceHandleCallback() = default;
@@ -290,7 +290,7 @@
// be invoked.
//
// A handle will have at most one async operation pending at a time.
-class QUIC_EXPORT_PRIVATE ProofSourceHandle {
+class QUICHE_EXPORT ProofSourceHandle {
public:
virtual ~ProofSourceHandle() = default;
@@ -345,7 +345,7 @@
// Returns true if |chain| contains a parsable DER-encoded X.509 leaf cert and
// it matches with |key|.
-QUIC_EXPORT_PRIVATE bool ValidateCertAndKey(
+QUICHE_EXPORT bool ValidateCertAndKey(
const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
const CertificatePrivateKey& key);
diff --git a/quiche/quic/core/crypto/proof_source_x509.h b/quiche/quic/core/crypto/proof_source_x509.h
index fa62bbf..37b3246 100644
--- a/quiche/quic/core/crypto/proof_source_x509.h
+++ b/quiche/quic/core/crypto/proof_source_x509.h
@@ -19,7 +19,7 @@
// ProofSourceX509 accepts X.509 certificates with private keys and picks a
// certificate internally based on its SubjectAltName value.
-class QUIC_EXPORT_PRIVATE ProofSourceX509 : public ProofSource {
+class QUICHE_EXPORT ProofSourceX509 : public ProofSource {
public:
// Creates a proof source that uses |default_chain| when no SubjectAltName
// value matches. Returns nullptr if |default_chain| is invalid.
@@ -64,7 +64,7 @@
std::string& /*leaf_cert_scts*/) {}
private:
- struct QUIC_EXPORT_PRIVATE Certificate {
+ struct QUICHE_EXPORT Certificate {
quiche::QuicheReferenceCountedPointer<Chain> chain;
CertificatePrivateKey key;
};
diff --git a/quiche/quic/core/crypto/proof_verifier.h b/quiche/quic/core/crypto/proof_verifier.h
index e9c6f03..b771784 100644
--- a/quiche/quic/core/crypto/proof_verifier.h
+++ b/quiche/quic/core/crypto/proof_verifier.h
@@ -19,7 +19,7 @@
// ProofVerifyDetails is an abstract class that acts as a container for any
// implementation specific details that a ProofVerifier wishes to return. These
// details are saved in the CachedState for the origin in question.
-class QUIC_EXPORT_PRIVATE ProofVerifyDetails {
+class QUICHE_EXPORT ProofVerifyDetails {
public:
virtual ~ProofVerifyDetails() {}
@@ -30,14 +30,14 @@
// ProofVerifyContext is an abstract class that acts as a container for any
// implementation specific context that a ProofVerifier needs.
-class QUIC_EXPORT_PRIVATE ProofVerifyContext {
+class QUICHE_EXPORT ProofVerifyContext {
public:
virtual ~ProofVerifyContext() {}
};
// ProofVerifierCallback provides a generic mechanism for a ProofVerifier to
// call back after an asynchronous verification.
-class QUIC_EXPORT_PRIVATE ProofVerifierCallback {
+class QUICHE_EXPORT ProofVerifierCallback {
public:
virtual ~ProofVerifierCallback() {}
@@ -53,7 +53,7 @@
// A ProofVerifier checks the signature on a server config, and the certificate
// chain that backs the public key.
-class QUIC_EXPORT_PRIVATE ProofVerifier {
+class QUICHE_EXPORT ProofVerifier {
public:
virtual ~ProofVerifier() {}
diff --git a/quiche/quic/core/crypto/quic_client_session_cache.h b/quiche/quic/core/crypto/quic_client_session_cache.h
index e568db6..7ef7ed0 100644
--- a/quiche/quic/core/crypto/quic_client_session_cache.h
+++ b/quiche/quic/core/crypto/quic_client_session_cache.h
@@ -19,7 +19,7 @@
// QuicClientSessionCache maps from QuicServerId to information used to resume
// TLS sessions for that server.
-class QUIC_EXPORT_PRIVATE QuicClientSessionCache : public SessionCache {
+class QUICHE_EXPORT QuicClientSessionCache : public SessionCache {
public:
QuicClientSessionCache();
explicit QuicClientSessionCache(size_t max_entries);
@@ -48,7 +48,7 @@
private:
friend class test::QuicClientSessionCachePeer;
- struct QUIC_EXPORT_PRIVATE Entry {
+ struct QUICHE_EXPORT Entry {
Entry();
Entry(Entry&&);
~Entry();
diff --git a/quiche/quic/core/crypto/quic_compressed_certs_cache.h b/quiche/quic/core/crypto/quic_compressed_certs_cache.h
index 918981e..7c973bd 100644
--- a/quiche/quic/core/crypto/quic_compressed_certs_cache.h
+++ b/quiche/quic/core/crypto/quic_compressed_certs_cache.h
@@ -15,7 +15,7 @@
namespace quic {
// QuicCompressedCertsCache is a cache to track most recently compressed certs.
-class QUIC_EXPORT_PRIVATE QuicCompressedCertsCache {
+class QUICHE_EXPORT QuicCompressedCertsCache {
public:
explicit QuicCompressedCertsCache(int64_t max_num_certs);
~QuicCompressedCertsCache();
@@ -50,7 +50,7 @@
// A wrapper of the tuple:
// |chain, client_cached_cert_hashes|
// to identify uncompressed representation of certs.
- struct QUIC_EXPORT_PRIVATE UncompressedCerts {
+ struct QUICHE_EXPORT UncompressedCerts {
UncompressedCerts();
UncompressedCerts(
const quiche::QuicheReferenceCountedPointer<ProofSource::Chain>& chain,
@@ -64,7 +64,7 @@
// Certs stored by QuicCompressedCertsCache where uncompressed certs data is
// used to identify the uncompressed representation of certs and
// |compressed_cert| is the cached compressed representation.
- class QUIC_EXPORT_PRIVATE CachedCerts {
+ class QUICHE_EXPORT CachedCerts {
public:
CachedCerts();
CachedCerts(const UncompressedCerts& uncompressed_certs,
diff --git a/quiche/quic/core/crypto/quic_crypter.h b/quiche/quic/core/crypto/quic_crypter.h
index d57a8e6..07f97bc 100644
--- a/quiche/quic/core/crypto/quic_crypter.h
+++ b/quiche/quic/core/crypto/quic_crypter.h
@@ -15,7 +15,7 @@
// Its purpose is to provide an interface for using methods that are common to
// both classes when operations are being done that apply to both encrypters and
// decrypters.
-class QUIC_EXPORT_PRIVATE QuicCrypter {
+class QUICHE_EXPORT QuicCrypter {
public:
virtual ~QuicCrypter() {}
diff --git a/quiche/quic/core/crypto/quic_crypto_client_config.h b/quiche/quic/core/crypto/quic_crypto_client_config.h
index 02c3643..30cddcc 100644
--- a/quiche/quic/core/crypto/quic_crypto_client_config.h
+++ b/quiche/quic/core/crypto/quic_crypto_client_config.h
@@ -32,7 +32,7 @@
// QuicResumptionState stores the state a client needs for performing connection
// resumption.
-struct QUIC_EXPORT_PRIVATE QuicResumptionState {
+struct QUICHE_EXPORT QuicResumptionState {
// |tls_session| holds the cryptographic state necessary for a resumption. It
// includes the ALPN negotiated on the connection where the ticket was
// received.
@@ -56,7 +56,7 @@
// SessionCache is an interface for managing storing and retrieving
// QuicResumptionState structs.
-class QUIC_EXPORT_PRIVATE SessionCache {
+class QUICHE_EXPORT SessionCache {
public:
virtual ~SessionCache() {}
@@ -97,12 +97,12 @@
// QuicCryptoClientConfig contains crypto-related configuration settings for a
// client. Note that this object isn't thread-safe. It's designed to be used on
// a single thread at a time.
-class QUIC_EXPORT_PRIVATE QuicCryptoClientConfig : public QuicCryptoConfig {
+class QUICHE_EXPORT QuicCryptoClientConfig : public QuicCryptoConfig {
public:
// A CachedState contains the information that the client needs in order to
// perform a 0-RTT handshake with a server. This information can be reused
// over several connections to the same server.
- class QUIC_EXPORT_PRIVATE CachedState {
+ class QUICHE_EXPORT CachedState {
public:
// Enum to track if the server config is valid or not. If it is not valid,
// it specifies why it is invalid.
@@ -227,7 +227,7 @@
};
// Used to filter server ids for partial config deletion.
- class QUIC_EXPORT_PRIVATE ServerIdFilter {
+ class QUICHE_EXPORT ServerIdFilter {
public:
virtual ~ServerIdFilter() {}
diff --git a/quiche/quic/core/crypto/quic_crypto_proof.h b/quiche/quic/core/crypto/quic_crypto_proof.h
index 579d264..f808277 100644
--- a/quiche/quic/core/crypto/quic_crypto_proof.h
+++ b/quiche/quic/core/crypto/quic_crypto_proof.h
@@ -12,7 +12,7 @@
namespace quic {
// Contains the crypto-related data provided by ProofSource
-struct QUIC_EXPORT_PRIVATE QuicCryptoProof {
+struct QUICHE_EXPORT QuicCryptoProof {
QuicCryptoProof();
// Signature generated by ProofSource
diff --git a/quiche/quic/core/crypto/quic_crypto_server_config.h b/quiche/quic/core/crypto/quic_crypto_server_config.h
index 5805c88..c9e6c13 100644
--- a/quiche/quic/core/crypto/quic_crypto_server_config.h
+++ b/quiche/quic/core/crypto/quic_crypto_server_config.h
@@ -41,7 +41,7 @@
// ClientHelloInfo contains information about a client hello message that is
// only kept for as long as it's being processed.
-struct QUIC_EXPORT_PRIVATE ClientHelloInfo {
+struct QUICHE_EXPORT ClientHelloInfo {
ClientHelloInfo(const QuicIpAddress& in_client_ip, QuicWallTime in_now);
ClientHelloInfo(const ClientHelloInfo& other);
~ClientHelloInfo();
@@ -68,7 +68,7 @@
} // namespace test
// Hook that allows application code to subscribe to primary config changes.
-class QUIC_EXPORT_PRIVATE PrimaryConfigChangedCallback {
+class QUICHE_EXPORT PrimaryConfigChangedCallback {
public:
PrimaryConfigChangedCallback();
PrimaryConfigChangedCallback(const PrimaryConfigChangedCallback&) = delete;
@@ -79,11 +79,11 @@
};
// Callback used to accept the result of the |client_hello| validation step.
-class QUIC_EXPORT_PRIVATE ValidateClientHelloResultCallback {
+class QUICHE_EXPORT ValidateClientHelloResultCallback {
public:
// Opaque token that holds information about the client_hello and
// its validity. Can be interpreted by calling ProcessClientHello.
- struct QUIC_EXPORT_PRIVATE Result : public quiche::QuicheReferenceCounted {
+ struct QUICHE_EXPORT Result : public quiche::QuicheReferenceCounted {
Result(const CryptoHandshakeMessage& in_client_hello,
QuicIpAddress in_client_ip, QuicWallTime in_now);
@@ -110,7 +110,7 @@
};
// Callback used to accept the result of the ProcessClientHello method.
-class QUIC_EXPORT_PRIVATE ProcessClientHelloResultCallback {
+class QUICHE_EXPORT ProcessClientHelloResultCallback {
public:
ProcessClientHelloResultCallback();
ProcessClientHelloResultCallback(const ProcessClientHelloResultCallback&) =
@@ -126,7 +126,7 @@
// Callback used to receive the results of a call to
// BuildServerConfigUpdateMessage.
-class QUIC_EXPORT_PRIVATE BuildServerConfigUpdateMessageResultCallback {
+class QUICHE_EXPORT BuildServerConfigUpdateMessageResultCallback {
public:
BuildServerConfigUpdateMessageResultCallback() = default;
virtual ~BuildServerConfigUpdateMessageResultCallback() {}
@@ -139,7 +139,7 @@
// Object that is interested in built rejections (which include REJ, SREJ and
// cheap SREJ).
-class QUIC_EXPORT_PRIVATE RejectionObserver {
+class QUICHE_EXPORT RejectionObserver {
public:
RejectionObserver() = default;
virtual ~RejectionObserver() {}
@@ -151,7 +151,7 @@
};
// Factory for creating KeyExchange objects.
-class QUIC_EXPORT_PRIVATE KeyExchangeSource {
+class QUICHE_EXPORT KeyExchangeSource {
public:
virtual ~KeyExchangeSource() = default;
@@ -173,10 +173,10 @@
// order to support clients resuming with a previous configuration.
// TODO(agl): when adding configurations at runtime is added, this object will
// need to consider locking.
-class QUIC_EXPORT_PRIVATE QuicCryptoServerConfig {
+class QUICHE_EXPORT QuicCryptoServerConfig {
public:
// ConfigOptions contains options for generating server configs.
- struct QUIC_EXPORT_PRIVATE ConfigOptions {
+ struct QUICHE_EXPORT ConfigOptions {
ConfigOptions();
ConfigOptions(const ConfigOptions& other);
~ConfigOptions();
@@ -473,8 +473,8 @@
// Config represents a server config: a collection of preferences and
// Diffie-Hellman public values.
- class QUIC_EXPORT_PRIVATE Config : public QuicCryptoConfig,
- public quiche::QuicheReferenceCounted {
+ class QUICHE_EXPORT Config : public QuicCryptoConfig,
+ public quiche::QuicheReferenceCounted {
public:
Config();
Config(const Config&) = delete;
@@ -540,7 +540,7 @@
QUIC_SHARED_LOCKS_REQUIRED(configs_lock_);
// A snapshot of the configs associated with an in-progress handshake.
- struct QUIC_EXPORT_PRIVATE Configs {
+ struct QUICHE_EXPORT Configs {
quiche::QuicheReferenceCountedPointer<Config> requested;
quiche::QuicheReferenceCountedPointer<Config> primary;
quiche::QuicheReferenceCountedPointer<Config> fallback;
@@ -582,7 +582,7 @@
// Convenience class which carries the arguments passed to
// |ProcessClientHellp| along.
- class QUIC_EXPORT_PRIVATE ProcessClientHelloContext {
+ class QUICHE_EXPORT ProcessClientHelloContext {
public:
ProcessClientHelloContext(
quiche::QuicheReferenceCountedPointer<
@@ -943,7 +943,7 @@
bool validate_source_address_token_;
};
-struct QUIC_EXPORT_PRIVATE QuicSignedServerConfig
+struct QUICHE_EXPORT QuicSignedServerConfig
: public quiche::QuicheReferenceCounted {
QuicSignedServerConfig();
diff --git a/quiche/quic/core/crypto/quic_decrypter.h b/quiche/quic/core/crypto/quic_decrypter.h
index 8e3c754..9f32dd0 100644
--- a/quiche/quic/core/crypto/quic_decrypter.h
+++ b/quiche/quic/core/crypto/quic_decrypter.h
@@ -18,7 +18,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicDecrypter : public QuicCrypter {
+class QUICHE_EXPORT QuicDecrypter : public QuicCrypter {
public:
virtual ~QuicDecrypter() {}
diff --git a/quiche/quic/core/crypto/quic_encrypter.h b/quiche/quic/core/crypto/quic_encrypter.h
index 7b8c4fa..d22d166 100644
--- a/quiche/quic/core/crypto/quic_encrypter.h
+++ b/quiche/quic/core/crypto/quic_encrypter.h
@@ -15,7 +15,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicEncrypter : public QuicCrypter {
+class QUICHE_EXPORT QuicEncrypter : public QuicCrypter {
public:
virtual ~QuicEncrypter() {}
diff --git a/quiche/quic/core/crypto/quic_hkdf.h b/quiche/quic/core/crypto/quic_hkdf.h
index 3e30f1c..36b287f 100644
--- a/quiche/quic/core/crypto/quic_hkdf.h
+++ b/quiche/quic/core/crypto/quic_hkdf.h
@@ -16,7 +16,7 @@
// QuicHKDF implements the key derivation function specified in RFC 5869
// (using SHA-256) and outputs key material, as needed by QUIC.
// See https://tools.ietf.org/html/rfc5869 for details.
-class QUIC_EXPORT_PRIVATE QuicHKDF {
+class QUICHE_EXPORT QuicHKDF {
public:
// |secret|: the input shared secret (or, from RFC 5869, the IKM).
// |salt|: an (optional) public salt / non-secret random value. While
diff --git a/quiche/quic/core/crypto/tls_client_connection.h b/quiche/quic/core/crypto/tls_client_connection.h
index 3bf35ce..187da35 100644
--- a/quiche/quic/core/crypto/tls_client_connection.h
+++ b/quiche/quic/core/crypto/tls_client_connection.h
@@ -11,11 +11,11 @@
// TlsClientConnection receives calls for client-specific BoringSSL callbacks
// and calls its Delegate for the implementation of those callbacks.
-class QUIC_EXPORT_PRIVATE TlsClientConnection : public TlsConnection {
+class QUICHE_EXPORT TlsClientConnection : public TlsConnection {
public:
// A TlsClientConnection::Delegate implements the client-specific methods that
// are set as callbacks for an SSL object.
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/crypto/tls_connection.h b/quiche/quic/core/crypto/tls_connection.h
index ca9f70b..0b39d1e 100644
--- a/quiche/quic/core/crypto/tls_connection.h
+++ b/quiche/quic/core/crypto/tls_connection.h
@@ -22,11 +22,11 @@
// The owner of the TlsConnection is responsible for driving the TLS handshake
// (and other interactions with the SSL*). This class only handles mapping
// callbacks to the correct instance.
-class QUIC_EXPORT_PRIVATE TlsConnection {
+class QUICHE_EXPORT TlsConnection {
public:
// A TlsConnection::Delegate implements the methods that are set as callbacks
// of TlsConnection.
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/crypto/tls_server_connection.h b/quiche/quic/core/crypto/tls_server_connection.h
index 3c0eb7e..bdb58be 100644
--- a/quiche/quic/core/crypto/tls_server_connection.h
+++ b/quiche/quic/core/crypto/tls_server_connection.h
@@ -13,11 +13,11 @@
// TlsServerConnection receives calls for client-specific BoringSSL callbacks
// and calls its Delegate for the implementation of those callbacks.
-class QUIC_EXPORT_PRIVATE TlsServerConnection : public TlsConnection {
+class QUICHE_EXPORT TlsServerConnection : public TlsConnection {
public:
// A TlsServerConnection::Delegate implement the server-specific methods that
// are set as callbacks for an SSL object.
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/crypto/transport_parameters.h b/quiche/quic/core/crypto/transport_parameters.h
index 78c2202..ff57add 100644
--- a/quiche/quic/core/crypto/transport_parameters.h
+++ b/quiche/quic/core/crypto/transport_parameters.h
@@ -25,7 +25,7 @@
// exchanged during the TLS handshake. This struct is a mirror of the struct in
// the "Transport Parameter Encoding" section of draft-ietf-quic-transport.
// This struct currently uses the values from draft 29.
-struct QUIC_EXPORT_PRIVATE TransportParameters {
+struct QUICHE_EXPORT TransportParameters {
// The identifier used to differentiate transport parameters.
enum TransportParameterId : uint64_t;
// A map used to specify custom parameters.
@@ -33,7 +33,7 @@
// Represents an individual QUIC transport parameter that only encodes a
// variable length integer. Can only be created inside the constructor for
// TransportParameters.
- class QUIC_EXPORT_PRIVATE IntegerParameter {
+ class QUICHE_EXPORT IntegerParameter {
public:
// Forbid constructing and copying apart from TransportParameters.
IntegerParameter() = delete;
@@ -54,7 +54,7 @@
// |error_details|.
bool Read(QuicDataReader* reader, std::string* error_details);
// operator<< allows easily logging integer transport parameters.
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const IntegerParameter& param);
private:
@@ -86,7 +86,7 @@
// Represents the preferred_address transport parameter that a server can
// send to clients.
- struct QUIC_EXPORT_PRIVATE PreferredAddress {
+ struct QUICHE_EXPORT PreferredAddress {
PreferredAddress();
PreferredAddress(const PreferredAddress& other) = default;
PreferredAddress(PreferredAddress&& other) = default;
@@ -101,7 +101,7 @@
// Allows easily logging.
std::string ToString() const;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const TransportParameters& params);
};
@@ -109,7 +109,7 @@
// mechanism ported to QUIC+TLS. It is exchanged using transport parameter ID
// 0x4752 and will eventually be deprecated in favor of
// draft-ietf-quic-version-negotiation.
- struct QUIC_EXPORT_PRIVATE LegacyVersionInformation {
+ struct QUICHE_EXPORT LegacyVersionInformation {
LegacyVersionInformation();
LegacyVersionInformation(const LegacyVersionInformation& other) = default;
LegacyVersionInformation& operator=(const LegacyVersionInformation& other) =
@@ -132,14 +132,14 @@
// Allows easily logging.
std::string ToString() const;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os,
const LegacyVersionInformation& legacy_version_information);
};
// Version information used for version downgrade prevention and compatible
// version negotiation. See draft-ietf-quic-version-negotiation-05.
- struct QUIC_EXPORT_PRIVATE VersionInformation {
+ struct QUICHE_EXPORT VersionInformation {
VersionInformation();
VersionInformation(const VersionInformation& other) = default;
VersionInformation& operator=(const VersionInformation& other) = default;
@@ -159,7 +159,7 @@
// Allows easily logging.
std::string ToString() const;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const VersionInformation& version_information);
};
@@ -268,15 +268,15 @@
// Allows easily logging transport parameters.
std::string ToString() const;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const TransportParameters& params);
};
// Serializes a TransportParameters struct into the format for sending it in a
// TLS extension. The serialized bytes are written to |*out|. Returns if the
// parameters are valid and serialization succeeded.
-QUIC_EXPORT_PRIVATE bool SerializeTransportParameters(
- const TransportParameters& in, std::vector<uint8_t>* out);
+QUICHE_EXPORT bool SerializeTransportParameters(const TransportParameters& in,
+ std::vector<uint8_t>* out);
// Parses bytes from the quic_transport_parameters TLS extension and writes the
// parsed parameters into |*out|. Input is read from |in| for |in_len| bytes.
@@ -284,9 +284,11 @@
// This method returns true if the input was successfully parsed.
// On failure, this method will write a human-readable error message to
// |error_details|.
-QUIC_EXPORT_PRIVATE bool ParseTransportParameters(
- ParsedQuicVersion version, Perspective perspective, const uint8_t* in,
- size_t in_len, TransportParameters* out, std::string* error_details);
+QUICHE_EXPORT bool ParseTransportParameters(ParsedQuicVersion version,
+ Perspective perspective,
+ const uint8_t* in, size_t in_len,
+ TransportParameters* out,
+ std::string* error_details);
// Serializes |in| and |application_data| in a deterministic format so that
// multiple calls to SerializeTransportParametersForTicket with the same inputs
@@ -296,15 +298,14 @@
// accepted: Early data will only be accepted if the inputs to this function
// match what they were on the connection that issued an early data capable
// ticket.
-QUIC_EXPORT_PRIVATE bool SerializeTransportParametersForTicket(
+QUICHE_EXPORT bool SerializeTransportParametersForTicket(
const TransportParameters& in, const std::vector<uint8_t>& application_data,
std::vector<uint8_t>* out);
// Removes reserved values from custom_parameters and versions.
// The resulting value can be reliably compared with an original or other
// deserialized value.
-QUIC_EXPORT_PRIVATE void DegreaseTransportParameters(
- TransportParameters& parameters);
+QUICHE_EXPORT void DegreaseTransportParameters(TransportParameters& parameters);
} // namespace quic
diff --git a/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier.h b/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier.h
index ea1908d..c995a2b 100644
--- a/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier.h
+++ b/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier.h
@@ -19,7 +19,7 @@
// https://w3c.github.io/webrtc-pc/#dom-rtcdtlsfingerprint.
// TODO(vasilvv): remove this once all consumers of this API use
// WebTransportHash.
-struct QUIC_EXPORT_PRIVATE CertificateFingerprint {
+struct QUICHE_EXPORT CertificateFingerprint {
static constexpr char kSha256[] = "sha-256";
// An algorithm described by one of the names in
@@ -32,7 +32,7 @@
// Represents a fingerprint of an X.509 certificate in a format based on
// https://w3c.github.io/webtransport/#dictdef-webtransporthash.
-struct QUIC_EXPORT_PRIVATE WebTransportHash {
+struct QUICHE_EXPORT WebTransportHash {
static constexpr char kSha256[] = "sha-256";
// An algorithm described by one of the names in
@@ -49,7 +49,7 @@
// not too long and has not expired. Only the leaf is checked, the rest of the
// chain is ignored. Reference specification:
// https://wicg.github.io/web-transport/#dom-quictransportconfiguration-server_certificate_fingerprints
-class QUIC_EXPORT_PRIVATE WebTransportFingerprintProofVerifier
+class QUICHE_EXPORT WebTransportFingerprintProofVerifier
: public ProofVerifier {
public:
// Note: the entries in this list may be logged into a UMA histogram, and thus
@@ -66,7 +66,7 @@
kMaxValue = kDisallowedKeyAlgorithm,
};
- class QUIC_EXPORT_PRIVATE Details : public ProofVerifyDetails {
+ class QUICHE_EXPORT Details : public ProofVerifyDetails {
public:
explicit Details(Status status) : status_(status) {}
Status status() const { return status_; }
diff --git a/quiche/quic/core/deterministic_connection_id_generator.h b/quiche/quic/core/deterministic_connection_id_generator.h
index 74d42d9..fbb9900 100644
--- a/quiche/quic/core/deterministic_connection_id_generator.h
+++ b/quiche/quic/core/deterministic_connection_id_generator.h
@@ -14,7 +14,7 @@
// Generates connection IDs deterministically from the provided original
// connection ID.
-class QUIC_EXPORT_PRIVATE DeterministicConnectionIdGenerator
+class QUICHE_EXPORT DeterministicConnectionIdGenerator
: public ConnectionIdGeneratorInterface {
public:
DeterministicConnectionIdGenerator(uint8_t expected_connection_id_length);
diff --git a/quiche/quic/core/frames/quic_ack_frame.h b/quiche/quic/core/frames/quic_ack_frame.h
index 6828a8c..d0b8424 100644
--- a/quiche/quic/core/frames/quic_ack_frame.h
+++ b/quiche/quic/core/frames/quic_ack_frame.h
@@ -18,7 +18,7 @@
// A sequence of packet numbers where each number is unique. Intended to be used
// in a sliding window fashion, where smaller old packet numbers are removed and
// larger new packet numbers are added, with the occasional random access.
-class QUIC_EXPORT_PRIVATE PacketNumberQueue {
+class QUICHE_EXPORT PacketNumberQueue {
public:
PacketNumberQueue();
PacketNumberQueue(const PacketNumberQueue& other);
@@ -81,22 +81,22 @@
const_reverse_iterator rbegin() const;
const_reverse_iterator rend() const;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const PacketNumberQueue& q);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const PacketNumberQueue& q);
private:
QuicIntervalSet<QuicPacketNumber> packet_number_intervals_;
};
-struct QUIC_EXPORT_PRIVATE QuicAckFrame {
+struct QUICHE_EXPORT QuicAckFrame {
QuicAckFrame();
QuicAckFrame(const QuicAckFrame& other);
~QuicAckFrame();
void Clear();
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicAckFrame& ack_frame);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicAckFrame& ack_frame);
// The highest packet number we've observed from the peer. When |packets| is
// not empty, it should always be equal to packets.Max(). The |LargestAcked|
@@ -121,8 +121,7 @@
// The highest acked packet number we've observed from the peer. If no packets
// have been observed, return 0.
-inline QUIC_EXPORT_PRIVATE QuicPacketNumber
-LargestAcked(const QuicAckFrame& frame) {
+inline QUICHE_EXPORT QuicPacketNumber LargestAcked(const QuicAckFrame& frame) {
QUICHE_DCHECK(frame.packets.Empty() ||
frame.packets.Max() == frame.largest_acked);
return frame.largest_acked;
@@ -131,7 +130,7 @@
// True if the packet number is greater than largest_observed or is listed
// as missing.
// Always returns false for packet numbers less than least_unacked.
-QUIC_EXPORT_PRIVATE bool IsAwaitingPacket(
+QUICHE_EXPORT bool IsAwaitingPacket(
const QuicAckFrame& ack_frame, QuicPacketNumber packet_number,
QuicPacketNumber peer_least_packet_awaiting_ack);
diff --git a/quiche/quic/core/frames/quic_ack_frequency_frame.h b/quiche/quic/core/frames/quic_ack_frequency_frame.h
index c9b3519..03f8746 100644
--- a/quiche/quic/core/frames/quic_ack_frequency_frame.h
+++ b/quiche/quic/core/frames/quic_ack_frequency_frame.h
@@ -16,8 +16,8 @@
namespace quic {
// A frame that allows sender control of acknowledgement delays.
-struct QUIC_EXPORT_PRIVATE QuicAckFrequencyFrame {
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+struct QUICHE_EXPORT QuicAckFrequencyFrame {
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicAckFrequencyFrame& ack_frequency_frame);
QuicAckFrequencyFrame() = default;
diff --git a/quiche/quic/core/frames/quic_blocked_frame.h b/quiche/quic/core/frames/quic_blocked_frame.h
index 982e1e8..ae8b8d0 100644
--- a/quiche/quic/core/frames/quic_blocked_frame.h
+++ b/quiche/quic/core/frames/quic_blocked_frame.h
@@ -17,14 +17,14 @@
// endpoint believes itself to be flow-control blocked but otherwise ready to
// send data. The BLOCKED frame is purely advisory and optional.
// Based on SPDY's BLOCKED frame (undocumented as of 2014-01-28).
-struct QUIC_EXPORT_PRIVATE QuicBlockedFrame
+struct QUICHE_EXPORT QuicBlockedFrame
: public QuicInlinedFrame<QuicBlockedFrame> {
QuicBlockedFrame();
QuicBlockedFrame(QuicControlFrameId control_frame_id, QuicStreamId stream_id,
QuicStreamOffset offset);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicBlockedFrame& b);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicBlockedFrame& b);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_connection_close_frame.h b/quiche/quic/core/frames/quic_connection_close_frame.h
index cf780dd..105ebcd 100644
--- a/quiche/quic/core/frames/quic_connection_close_frame.h
+++ b/quiche/quic/core/frames/quic_connection_close_frame.h
@@ -15,7 +15,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicConnectionCloseFrame {
+struct QUICHE_EXPORT QuicConnectionCloseFrame {
QuicConnectionCloseFrame() = default;
// Builds a connection close frame based on the transport version
@@ -31,7 +31,7 @@
std::string error_phrase,
uint64_t transport_close_frame_type);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicConnectionCloseFrame& c);
// Indicates whether the the frame is a Google QUIC CONNECTION_CLOSE frame,
diff --git a/quiche/quic/core/frames/quic_crypto_frame.h b/quiche/quic/core/frames/quic_crypto_frame.h
index 19fb579..243f05d 100644
--- a/quiche/quic/core/frames/quic_crypto_frame.h
+++ b/quiche/quic/core/frames/quic_crypto_frame.h
@@ -14,7 +14,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicCryptoFrame {
+struct QUICHE_EXPORT QuicCryptoFrame {
QuicCryptoFrame() = default;
QuicCryptoFrame(EncryptionLevel level, QuicStreamOffset offset,
QuicPacketLength data_length);
@@ -22,8 +22,8 @@
absl::string_view data);
~QuicCryptoFrame();
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const QuicCryptoFrame& s);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicCryptoFrame& s);
// TODO(haoyuewang) Consider replace the EncryptionLevel here with
// PacketNumberSpace.
diff --git a/quiche/quic/core/frames/quic_frame.cc b/quiche/quic/core/frames/quic_frame.cc
index 2ed0550..df4d9d3 100644
--- a/quiche/quic/core/frames/quic_frame.cc
+++ b/quiche/quic/core/frames/quic_frame.cc
@@ -514,7 +514,7 @@
return os;
}
-QUIC_EXPORT_PRIVATE std::string QuicFrameToString(const QuicFrame& frame) {
+QUICHE_EXPORT std::string QuicFrameToString(const QuicFrame& frame) {
std::ostringstream os;
os << frame;
return os.str();
diff --git a/quiche/quic/core/frames/quic_frame.h b/quiche/quic/core/frames/quic_frame.h
index 3b7196e..289b08d 100644
--- a/quiche/quic/core/frames/quic_frame.h
+++ b/quiche/quic/core/frames/quic_frame.h
@@ -46,7 +46,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicFrame {
+struct QUICHE_EXPORT QuicFrame {
QuicFrame();
// Please keep the constructors in the same order as the union below.
explicit QuicFrame(QuicPaddingFrame padding_frame);
@@ -74,8 +74,8 @@
explicit QuicFrame(QuicCryptoFrame* crypto_frame);
explicit QuicFrame(QuicAckFrequencyFrame* ack_frequency_frame);
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
- const QuicFrame& frame);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicFrame& frame);
union {
// Inlined frames.
@@ -132,42 +132,40 @@
using QuicFrames = absl::InlinedVector<QuicFrame, 1>;
// Deletes all the sub-frames contained in |frames|.
-QUIC_EXPORT_PRIVATE void DeleteFrames(QuicFrames* frames);
+QUICHE_EXPORT void DeleteFrames(QuicFrames* frames);
// Delete the sub-frame contained in |frame|.
-QUIC_EXPORT_PRIVATE void DeleteFrame(QuicFrame* frame);
+QUICHE_EXPORT void DeleteFrame(QuicFrame* frame);
// Deletes all the QuicStreamFrames for the specified |stream_id|.
-QUIC_EXPORT_PRIVATE void RemoveFramesForStream(QuicFrames* frames,
- QuicStreamId stream_id);
+QUICHE_EXPORT void RemoveFramesForStream(QuicFrames* frames,
+ QuicStreamId stream_id);
// Returns true if |type| is a retransmittable control frame.
-QUIC_EXPORT_PRIVATE bool IsControlFrame(QuicFrameType type);
+QUICHE_EXPORT bool IsControlFrame(QuicFrameType type);
// Returns control_frame_id of |frame|. Returns kInvalidControlFrameId if
// |frame| does not have a valid control_frame_id.
-QUIC_EXPORT_PRIVATE QuicControlFrameId
-GetControlFrameId(const QuicFrame& frame);
+QUICHE_EXPORT QuicControlFrameId GetControlFrameId(const QuicFrame& frame);
// Sets control_frame_id of |frame| to |control_frame_id|.
-QUIC_EXPORT_PRIVATE void SetControlFrameId(QuicControlFrameId control_frame_id,
- QuicFrame* frame);
+QUICHE_EXPORT void SetControlFrameId(QuicControlFrameId control_frame_id,
+ QuicFrame* frame);
// Returns a copy of |frame|.
-QUIC_EXPORT_PRIVATE QuicFrame
-CopyRetransmittableControlFrame(const QuicFrame& frame);
+QUICHE_EXPORT QuicFrame CopyRetransmittableControlFrame(const QuicFrame& frame);
// Returns a copy of |frame|.
-QUIC_EXPORT_PRIVATE QuicFrame
-CopyQuicFrame(quiche::QuicheBufferAllocator* allocator, const QuicFrame& frame);
+QUICHE_EXPORT QuicFrame CopyQuicFrame(quiche::QuicheBufferAllocator* allocator,
+ const QuicFrame& frame);
// Returns a copy of |frames|.
-QUIC_EXPORT_PRIVATE QuicFrames CopyQuicFrames(
+QUICHE_EXPORT QuicFrames CopyQuicFrames(
quiche::QuicheBufferAllocator* allocator, const QuicFrames& frames);
// Human-readable description suitable for logging.
-QUIC_EXPORT_PRIVATE std::string QuicFrameToString(const QuicFrame& frame);
-QUIC_EXPORT_PRIVATE std::string QuicFramesToString(const QuicFrames& frames);
+QUICHE_EXPORT std::string QuicFrameToString(const QuicFrame& frame);
+QUICHE_EXPORT std::string QuicFramesToString(const QuicFrames& frames);
} // namespace quic
diff --git a/quiche/quic/core/frames/quic_goaway_frame.h b/quiche/quic/core/frames/quic_goaway_frame.h
index c094889..f05d8bd 100644
--- a/quiche/quic/core/frames/quic_goaway_frame.h
+++ b/quiche/quic/core/frames/quic_goaway_frame.h
@@ -14,13 +14,13 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicGoAwayFrame {
+struct QUICHE_EXPORT QuicGoAwayFrame {
QuicGoAwayFrame() = default;
QuicGoAwayFrame(QuicControlFrameId control_frame_id, QuicErrorCode error_code,
QuicStreamId last_good_stream_id, const std::string& reason);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const QuicGoAwayFrame& g);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicGoAwayFrame& g);
// A unique identifier of this control frame. 0 when this frame is received,
// and non-zero when sent.
diff --git a/quiche/quic/core/frames/quic_handshake_done_frame.h b/quiche/quic/core/frames/quic_handshake_done_frame.h
index aa5cbfc..59e98c8 100644
--- a/quiche/quic/core/frames/quic_handshake_done_frame.h
+++ b/quiche/quic/core/frames/quic_handshake_done_frame.h
@@ -14,12 +14,12 @@
// A HANDSHAKE_DONE frame contains no payload, and it is retransmittable,
// and ACK'd just like other normal frames.
-struct QUIC_EXPORT_PRIVATE QuicHandshakeDoneFrame
+struct QUICHE_EXPORT QuicHandshakeDoneFrame
: public QuicInlinedFrame<QuicHandshakeDoneFrame> {
QuicHandshakeDoneFrame();
explicit QuicHandshakeDoneFrame(QuicControlFrameId control_frame_id);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicHandshakeDoneFrame& handshake_done_frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_inlined_frame.h b/quiche/quic/core/frames/quic_inlined_frame.h
index 8cab158..e50e599 100644
--- a/quiche/quic/core/frames/quic_inlined_frame.h
+++ b/quiche/quic/core/frames/quic_inlined_frame.h
@@ -17,7 +17,7 @@
// at offset 0, such that QuicFrame.type can get the correct frame type for both
// inline and out-of-line frame types.
template <typename DerivedT>
-struct QUIC_EXPORT_PRIVATE QuicInlinedFrame {
+struct QUICHE_EXPORT QuicInlinedFrame {
QuicInlinedFrame(QuicFrameType type) {
static_cast<DerivedT*>(this)->type = type;
static_assert(std::is_standard_layout<DerivedT>::value,
diff --git a/quiche/quic/core/frames/quic_max_streams_frame.h b/quiche/quic/core/frames/quic_max_streams_frame.h
index eaee69a..de9f9bf 100644
--- a/quiche/quic/core/frames/quic_max_streams_frame.h
+++ b/quiche/quic/core/frames/quic_max_streams_frame.h
@@ -17,13 +17,13 @@
// IETF format MAX_STREAMS frame.
// This frame is used by the sender to inform the peer of the number of
// streams that the peer may open and that the sender will accept.
-struct QUIC_EXPORT_PRIVATE QuicMaxStreamsFrame
+struct QUICHE_EXPORT QuicMaxStreamsFrame
: public QuicInlinedFrame<QuicMaxStreamsFrame> {
QuicMaxStreamsFrame();
QuicMaxStreamsFrame(QuicControlFrameId control_frame_id,
QuicStreamCount stream_count, bool unidirectional);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicMaxStreamsFrame& frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_message_frame.h b/quiche/quic/core/frames/quic_message_frame.h
index 91f7364..0bb86de 100644
--- a/quiche/quic/core/frames/quic_message_frame.h
+++ b/quiche/quic/core/frames/quic_message_frame.h
@@ -15,7 +15,7 @@
using QuicMessageData = absl::InlinedVector<quiche::QuicheMemSlice, 1>;
-struct QUIC_EXPORT_PRIVATE QuicMessageFrame {
+struct QUICHE_EXPORT QuicMessageFrame {
QuicMessageFrame() = default;
explicit QuicMessageFrame(QuicMessageId message_id);
QuicMessageFrame(QuicMessageId message_id,
@@ -31,8 +31,8 @@
~QuicMessageFrame();
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicMessageFrame& s);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicMessageFrame& s);
// message_id is only used on the sender side and does not get serialized on
// wire.
diff --git a/quiche/quic/core/frames/quic_mtu_discovery_frame.h b/quiche/quic/core/frames/quic_mtu_discovery_frame.h
index 7189463..0f7f6c6 100644
--- a/quiche/quic/core/frames/quic_mtu_discovery_frame.h
+++ b/quiche/quic/core/frames/quic_mtu_discovery_frame.h
@@ -13,7 +13,7 @@
// A path MTU discovery frame contains no payload and is serialized as a ping
// frame.
-struct QUIC_EXPORT_PRIVATE QuicMtuDiscoveryFrame
+struct QUICHE_EXPORT QuicMtuDiscoveryFrame
: public QuicInlinedFrame<QuicMtuDiscoveryFrame> {
QuicMtuDiscoveryFrame() : QuicInlinedFrame(MTU_DISCOVERY_FRAME) {}
diff --git a/quiche/quic/core/frames/quic_new_connection_id_frame.h b/quiche/quic/core/frames/quic_new_connection_id_frame.h
index 8f5e9ba..d5efcc8 100644
--- a/quiche/quic/core/frames/quic_new_connection_id_frame.h
+++ b/quiche/quic/core/frames/quic_new_connection_id_frame.h
@@ -14,7 +14,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicNewConnectionIdFrame {
+struct QUICHE_EXPORT QuicNewConnectionIdFrame {
QuicNewConnectionIdFrame() = default;
QuicNewConnectionIdFrame(QuicControlFrameId control_frame_id,
QuicConnectionId connection_id,
@@ -22,7 +22,7 @@
StatelessResetToken stateless_reset_token,
uint64_t retire_prior_to);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicNewConnectionIdFrame& frame);
// A unique identifier of this control frame. 0 when this frame is received,
diff --git a/quiche/quic/core/frames/quic_new_token_frame.h b/quiche/quic/core/frames/quic_new_token_frame.h
index 9761ed0..35b09d5 100644
--- a/quiche/quic/core/frames/quic_new_token_frame.h
+++ b/quiche/quic/core/frames/quic_new_token_frame.h
@@ -15,13 +15,13 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicNewTokenFrame {
+struct QUICHE_EXPORT QuicNewTokenFrame {
QuicNewTokenFrame() = default;
QuicNewTokenFrame(QuicControlFrameId control_frame_id,
absl::string_view token);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicNewTokenFrame& s);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicNewTokenFrame& s);
// A unique identifier of this control frame. 0 when this frame is received,
// and non-zero when sent.
diff --git a/quiche/quic/core/frames/quic_padding_frame.h b/quiche/quic/core/frames/quic_padding_frame.h
index a903c5d..71df7cd 100644
--- a/quiche/quic/core/frames/quic_padding_frame.h
+++ b/quiche/quic/core/frames/quic_padding_frame.h
@@ -15,13 +15,13 @@
namespace quic {
// A padding frame contains no payload.
-struct QUIC_EXPORT_PRIVATE QuicPaddingFrame
+struct QUICHE_EXPORT QuicPaddingFrame
: public QuicInlinedFrame<QuicPaddingFrame> {
QuicPaddingFrame() : QuicInlinedFrame(PADDING_FRAME) {}
explicit QuicPaddingFrame(int num_padding_bytes)
: QuicInlinedFrame(PADDING_FRAME), num_padding_bytes(num_padding_bytes) {}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicPaddingFrame& padding_frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_path_challenge_frame.h b/quiche/quic/core/frames/quic_path_challenge_frame.h
index 34dd40b..e37f4ae 100644
--- a/quiche/quic/core/frames/quic_path_challenge_frame.h
+++ b/quiche/quic/core/frames/quic_path_challenge_frame.h
@@ -14,14 +14,14 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicPathChallengeFrame
+struct QUICHE_EXPORT QuicPathChallengeFrame
: public QuicInlinedFrame<QuicPathChallengeFrame> {
QuicPathChallengeFrame();
QuicPathChallengeFrame(QuicControlFrameId control_frame_id,
const QuicPathFrameBuffer& data_buff);
~QuicPathChallengeFrame() = default;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicPathChallengeFrame& frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_path_response_frame.h b/quiche/quic/core/frames/quic_path_response_frame.h
index 5c6a667..84e7a4e 100644
--- a/quiche/quic/core/frames/quic_path_response_frame.h
+++ b/quiche/quic/core/frames/quic_path_response_frame.h
@@ -14,14 +14,14 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicPathResponseFrame
+struct QUICHE_EXPORT QuicPathResponseFrame
: public QuicInlinedFrame<QuicPathResponseFrame> {
QuicPathResponseFrame();
QuicPathResponseFrame(QuicControlFrameId control_frame_id,
const QuicPathFrameBuffer& data_buff);
~QuicPathResponseFrame() = default;
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicPathResponseFrame& frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_ping_frame.h b/quiche/quic/core/frames/quic_ping_frame.h
index 2603b65..fc5a2ee 100644
--- a/quiche/quic/core/frames/quic_ping_frame.h
+++ b/quiche/quic/core/frames/quic_ping_frame.h
@@ -14,12 +14,11 @@
// A ping frame contains no payload, though it is retransmittable,
// and ACK'd just like other normal frames.
-struct QUIC_EXPORT_PRIVATE QuicPingFrame
- : public QuicInlinedFrame<QuicPingFrame> {
+struct QUICHE_EXPORT QuicPingFrame : public QuicInlinedFrame<QuicPingFrame> {
QuicPingFrame();
explicit QuicPingFrame(QuicControlFrameId control_frame_id);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicPingFrame& ping_frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_retire_connection_id_frame.h b/quiche/quic/core/frames/quic_retire_connection_id_frame.h
index fcff696..4c7c468 100644
--- a/quiche/quic/core/frames/quic_retire_connection_id_frame.h
+++ b/quiche/quic/core/frames/quic_retire_connection_id_frame.h
@@ -13,12 +13,12 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicRetireConnectionIdFrame {
+struct QUICHE_EXPORT QuicRetireConnectionIdFrame {
QuicRetireConnectionIdFrame() = default;
QuicRetireConnectionIdFrame(QuicControlFrameId control_frame_id,
QuicConnectionIdSequenceNumber sequence_number);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicRetireConnectionIdFrame& frame);
// A unique identifier of this control frame. 0 when this frame is received,
diff --git a/quiche/quic/core/frames/quic_rst_stream_frame.h b/quiche/quic/core/frames/quic_rst_stream_frame.h
index c346aff..30cc9d3 100644
--- a/quiche/quic/core/frames/quic_rst_stream_frame.h
+++ b/quiche/quic/core/frames/quic_rst_stream_frame.h
@@ -13,7 +13,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicRstStreamFrame {
+struct QUICHE_EXPORT QuicRstStreamFrame {
QuicRstStreamFrame() = default;
QuicRstStreamFrame(QuicControlFrameId control_frame_id,
QuicStreamId stream_id, QuicRstStreamErrorCode error_code,
@@ -22,8 +22,8 @@
QuicStreamId stream_id, QuicResetStreamError error,
QuicStreamOffset bytes_written);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicRstStreamFrame& r);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicRstStreamFrame& r);
// A unique identifier of this control frame. 0 when this frame is received,
// and non-zero when sent.
diff --git a/quiche/quic/core/frames/quic_stop_sending_frame.h b/quiche/quic/core/frames/quic_stop_sending_frame.h
index 8a7b8c6..960d234 100644
--- a/quiche/quic/core/frames/quic_stop_sending_frame.h
+++ b/quiche/quic/core/frames/quic_stop_sending_frame.h
@@ -14,7 +14,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicStopSendingFrame
+struct QUICHE_EXPORT QuicStopSendingFrame
: public QuicInlinedFrame<QuicStopSendingFrame> {
QuicStopSendingFrame();
QuicStopSendingFrame(QuicControlFrameId control_frame_id,
@@ -23,7 +23,7 @@
QuicStopSendingFrame(QuicControlFrameId control_frame_id,
QuicStreamId stream_id, QuicResetStreamError error);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicStopSendingFrame& frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_stop_waiting_frame.h b/quiche/quic/core/frames/quic_stop_waiting_frame.h
index 526ea01..6f55c00 100644
--- a/quiche/quic/core/frames/quic_stop_waiting_frame.h
+++ b/quiche/quic/core/frames/quic_stop_waiting_frame.h
@@ -13,12 +13,12 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicStopWaitingFrame
+struct QUICHE_EXPORT QuicStopWaitingFrame
: public QuicInlinedFrame<QuicStopWaitingFrame> {
QuicStopWaitingFrame();
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicStopWaitingFrame& s);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicStopWaitingFrame& s);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_stream_frame.h b/quiche/quic/core/frames/quic_stream_frame.h
index a6b965a..915d967 100644
--- a/quiche/quic/core/frames/quic_stream_frame.h
+++ b/quiche/quic/core/frames/quic_stream_frame.h
@@ -15,7 +15,7 @@
namespace quic {
-struct QUIC_EXPORT_PRIVATE QuicStreamFrame
+struct QUICHE_EXPORT QuicStreamFrame
: public QuicInlinedFrame<QuicStreamFrame> {
QuicStreamFrame();
QuicStreamFrame(QuicStreamId stream_id, bool fin, QuicStreamOffset offset,
@@ -23,8 +23,8 @@
QuicStreamFrame(QuicStreamId stream_id, bool fin, QuicStreamOffset offset,
QuicPacketLength data_length);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const QuicStreamFrame& s);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicStreamFrame& s);
bool operator==(const QuicStreamFrame& rhs) const;
diff --git a/quiche/quic/core/frames/quic_streams_blocked_frame.h b/quiche/quic/core/frames/quic_streams_blocked_frame.h
index cc60f31..e97dbb9 100644
--- a/quiche/quic/core/frames/quic_streams_blocked_frame.h
+++ b/quiche/quic/core/frames/quic_streams_blocked_frame.h
@@ -17,13 +17,13 @@
// IETF format STREAMS_BLOCKED frame.
// The sender uses this to inform the peer that the sender wished to
// open a new stream, exceeding the limit on the number of streams.
-struct QUIC_EXPORT_PRIVATE QuicStreamsBlockedFrame
+struct QUICHE_EXPORT QuicStreamsBlockedFrame
: public QuicInlinedFrame<QuicStreamsBlockedFrame> {
QuicStreamsBlockedFrame();
QuicStreamsBlockedFrame(QuicControlFrameId control_frame_id,
QuicStreamCount stream_count, bool unidirectional);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicStreamsBlockedFrame& frame);
QuicFrameType type;
diff --git a/quiche/quic/core/frames/quic_window_update_frame.h b/quiche/quic/core/frames/quic_window_update_frame.h
index 1cbd7ff..893fd56 100644
--- a/quiche/quic/core/frames/quic_window_update_frame.h
+++ b/quiche/quic/core/frames/quic_window_update_frame.h
@@ -16,14 +16,14 @@
// Flow control updates per-stream and at the connection level.
// Based on SPDY's WINDOW_UPDATE frame, but uses an absolute max data bytes
// rather than a window delta.
-struct QUIC_EXPORT_PRIVATE QuicWindowUpdateFrame
+struct QUICHE_EXPORT QuicWindowUpdateFrame
: public QuicInlinedFrame<QuicWindowUpdateFrame> {
QuicWindowUpdateFrame();
QuicWindowUpdateFrame(QuicControlFrameId control_frame_id,
QuicStreamId stream_id, QuicByteCount max_data);
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicWindowUpdateFrame& w);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicWindowUpdateFrame& w);
QuicFrameType type;
diff --git a/quiche/quic/core/handshaker_delegate_interface.h b/quiche/quic/core/handshaker_delegate_interface.h
index 9c0adef..f10ba4a 100644
--- a/quiche/quic/core/handshaker_delegate_interface.h
+++ b/quiche/quic/core/handshaker_delegate_interface.h
@@ -15,7 +15,7 @@
class QuicEncrypter;
// Pure virtual class to get notified when particular handshake events occurred.
-class QUIC_EXPORT_PRIVATE HandshakerDelegateInterface {
+class QUICHE_EXPORT HandshakerDelegateInterface {
public:
virtual ~HandshakerDelegateInterface() {}
diff --git a/quiche/quic/core/http/http_constants.h b/quiche/quic/core/http/http_constants.h
index a8b5fd3..210fb4d 100644
--- a/quiche/quic/core/http/http_constants.h
+++ b/quiche/quic/core/http/http_constants.h
@@ -51,7 +51,7 @@
};
// Returns HTTP/3 SETTINGS identifier as a string.
-QUIC_EXPORT std::string H3SettingsToString(
+QUICHE_EXPORT std::string H3SettingsToString(
Http3AndQpackSettingsIdentifiers identifier);
// Default maximum dynamic table capacity, communicated via
@@ -70,7 +70,7 @@
// SETTINGS_QPACK_BLOCKED_STREAMS.
enum : uint64_t { kDefaultMaximumBlockedStreams = 100 };
-ABSL_CONST_INIT QUIC_EXPORT_PRIVATE extern const absl::string_view
+ABSL_CONST_INIT QUICHE_EXPORT extern const absl::string_view
kUserAgentHeaderName;
} // namespace quic
diff --git a/quiche/quic/core/http/http_decoder.h b/quiche/quic/core/http/http_decoder.h
index d582841..d8cd6a8 100644
--- a/quiche/quic/core/http/http_decoder.h
+++ b/quiche/quic/core/http/http_decoder.h
@@ -25,9 +25,9 @@
// A class for decoding the HTTP frames that are exchanged in an HTTP over QUIC
// session.
-class QUIC_EXPORT_PRIVATE HttpDecoder {
+class QUICHE_EXPORT HttpDecoder {
public:
- class QUIC_EXPORT_PRIVATE Visitor {
+ class QUICHE_EXPORT Visitor {
public:
virtual ~Visitor() {}
diff --git a/quiche/quic/core/http/http_encoder.h b/quiche/quic/core/http/http_encoder.h
index 28a8a2c..d0d8408 100644
--- a/quiche/quic/core/http/http_encoder.h
+++ b/quiche/quic/core/http/http_encoder.h
@@ -19,7 +19,7 @@
// A class for encoding the HTTP frames that are exchanged in an HTTP over QUIC
// session.
-class QUIC_EXPORT_PRIVATE HttpEncoder {
+class QUICHE_EXPORT HttpEncoder {
public:
HttpEncoder() = delete;
diff --git a/quiche/quic/core/http/http_frames.h b/quiche/quic/core/http/http_frames.h
index 56caca8..874dc10 100644
--- a/quiche/quic/core/http/http_frames.h
+++ b/quiche/quic/core/http/http_frames.h
@@ -41,7 +41,7 @@
//
// DATA frames (type=0x0) convey arbitrary, variable-length sequences of
// octets associated with an HTTP request or response payload.
-struct QUIC_EXPORT_PRIVATE DataFrame {
+struct QUICHE_EXPORT DataFrame {
absl::string_view data;
};
@@ -49,7 +49,7 @@
//
// The HEADERS frame (type=0x1) is used to carry a header block,
// compressed using QPACK.
-struct QUIC_EXPORT_PRIVATE HeadersFrame {
+struct QUICHE_EXPORT HeadersFrame {
absl::string_view headers;
};
@@ -61,7 +61,7 @@
using SettingsMap = absl::flat_hash_map<uint64_t, uint64_t>;
-struct QUIC_EXPORT_PRIVATE SettingsFrame {
+struct QUICHE_EXPORT SettingsFrame {
SettingsMap values;
bool operator==(const SettingsFrame& rhs) const {
@@ -79,8 +79,8 @@
}
return s;
}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const SettingsFrame& s) {
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const SettingsFrame& s) {
os << s.ToString();
return os;
}
@@ -90,7 +90,7 @@
//
// The GOAWAY frame (type=0x7) is used to initiate shutdown of a connection by
// either endpoint.
-struct QUIC_EXPORT_PRIVATE GoAwayFrame {
+struct QUICHE_EXPORT GoAwayFrame {
// When sent from server to client, |id| is a stream ID that should refer to
// a client-initiated bidirectional stream.
// When sent from client to server, |id| is a push ID.
@@ -110,7 +110,7 @@
// Length of a priority frame's first byte.
const QuicByteCount kPriorityFirstByteLength = 1;
-struct QUIC_EXPORT_PRIVATE PriorityUpdateFrame {
+struct QUICHE_EXPORT PriorityUpdateFrame {
uint64_t prioritized_element_id = 0;
std::string priority_field_value;
@@ -124,8 +124,8 @@
", priority_field_value: ", priority_field_value, "}");
}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const PriorityUpdateFrame& s) {
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const PriorityUpdateFrame& s) {
os << s.ToString();
return os;
}
@@ -134,7 +134,7 @@
// ACCEPT_CH
// https://tools.ietf.org/html/draft-davidben-http-client-hint-reliability-02
//
-struct QUIC_EXPORT_PRIVATE AcceptChFrame {
+struct QUICHE_EXPORT AcceptChFrame {
std::vector<spdy::AcceptChOriginValuePair> entries;
bool operator==(const AcceptChFrame& rhs) const {
@@ -148,8 +148,8 @@
return s.str();
}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const AcceptChFrame& frame) {
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const AcceptChFrame& frame) {
os << "ACCEPT_CH frame with " << frame.entries.size() << " entries: ";
for (auto& entry : frame.entries) {
os << "origin: " << entry.origin << "; value: " << entry.value;
diff --git a/quiche/quic/core/http/quic_client_promised_info.h b/quiche/quic/core/http/quic_client_promised_info.h
index 7b4f460..84fbf4f 100644
--- a/quiche/quic/core/http/quic_client_promised_info.h
+++ b/quiche/quic/core/http/quic_client_promised_info.h
@@ -27,7 +27,7 @@
// stream from the time a PUSH_PROMISE is received until rendezvous
// between the promised response and the corresponding client request
// is complete.
-class QUIC_EXPORT_PRIVATE QuicClientPromisedInfo
+class QUICHE_EXPORT QuicClientPromisedInfo
: public QuicClientPushPromiseIndex::TryHandle {
public:
// Interface to QuicSpdyClientStream
@@ -84,8 +84,7 @@
private:
friend class test::QuicClientPromisedInfoPeer;
- class QUIC_EXPORT_PRIVATE CleanupAlarm
- : public QuicAlarm::DelegateWithoutContext {
+ class QUICHE_EXPORT CleanupAlarm : public QuicAlarm::DelegateWithoutContext {
public:
explicit CleanupAlarm(QuicClientPromisedInfo* promised)
: promised_(promised) {}
diff --git a/quiche/quic/core/http/quic_client_push_promise_index.h b/quiche/quic/core/http/quic_client_push_promise_index.h
index c00a17e..2492c23 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index.h
+++ b/quiche/quic/core/http/quic_client_push_promise_index.h
@@ -20,11 +20,11 @@
// same browser users profile), since cross-origin pushes are allowed
// (subject to authority constraints).
-class QUIC_EXPORT_PRIVATE QuicClientPushPromiseIndex {
+class QUICHE_EXPORT QuicClientPushPromiseIndex {
public:
// Delegate is used to complete the rendezvous that began with
// |Try()|.
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
@@ -48,7 +48,7 @@
virtual void OnRendezvousResult(QuicSpdyStream* stream) = 0;
};
- class QUIC_EXPORT_PRIVATE TryHandle {
+ class QUICHE_EXPORT TryHandle {
public:
// Cancel the request.
virtual void Cancel() = 0;
diff --git a/quiche/quic/core/http/quic_header_list.h b/quiche/quic/core/http/quic_header_list.h
index ac25f89..335cf4b 100644
--- a/quiche/quic/core/http/quic_header_list.h
+++ b/quiche/quic/core/http/quic_header_list.h
@@ -19,8 +19,7 @@
namespace quic {
// A simple class that accumulates header pairs
-class QUIC_EXPORT_PRIVATE QuicHeaderList
- : public spdy::SpdyHeadersHandlerInterface {
+class QUICHE_EXPORT QuicHeaderList : public spdy::SpdyHeadersHandlerInterface {
public:
using ListType =
quiche::QuicheCircularDeque<std::pair<std::string, std::string>>;
diff --git a/quiche/quic/core/http/quic_headers_stream.h b/quiche/quic/core/http/quic_headers_stream.h
index ba3a27b..ce8010e 100644
--- a/quiche/quic/core/http/quic_headers_stream.h
+++ b/quiche/quic/core/http/quic_headers_stream.h
@@ -25,7 +25,7 @@
// Headers in QUIC are sent as HTTP/2 HEADERS or PUSH_PROMISE frames over a
// reserved stream with the id 3. Each endpoint (client and server) will
// allocate an instance of QuicHeadersStream to send and receive headers.
-class QUIC_EXPORT_PRIVATE QuicHeadersStream : public QuicStream {
+class QUICHE_EXPORT QuicHeadersStream : public QuicStream {
public:
explicit QuicHeadersStream(QuicSpdySession* session);
QuicHeadersStream(const QuicHeadersStream&) = delete;
@@ -54,7 +54,7 @@
// CompressedHeaderInfo includes simple information of a header, including
// offset in headers stream, unacked length and ack listener of this header.
- struct QUIC_EXPORT_PRIVATE CompressedHeaderInfo {
+ struct QUICHE_EXPORT CompressedHeaderInfo {
CompressedHeaderInfo(
QuicStreamOffset headers_stream_offset, QuicStreamOffset full_length,
quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
diff --git a/quiche/quic/core/http/quic_receive_control_stream.h b/quiche/quic/core/http/quic_receive_control_stream.h
index 71d0bf2..e3ad39d 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.h
+++ b/quiche/quic/core/http/quic_receive_control_stream.h
@@ -16,9 +16,8 @@
// 3.2.1 Control Stream.
// The receive control stream is peer initiated and is read only.
-class QUIC_EXPORT_PRIVATE QuicReceiveControlStream
- : public QuicStream,
- public HttpDecoder::Visitor {
+class QUICHE_EXPORT QuicReceiveControlStream : public QuicStream,
+ public HttpDecoder::Visitor {
public:
explicit QuicReceiveControlStream(PendingStream* pending,
QuicSpdySession* spdy_session);
diff --git a/quiche/quic/core/http/quic_send_control_stream.h b/quiche/quic/core/http/quic_send_control_stream.h
index fa8b96a..ea6b0f8 100644
--- a/quiche/quic/core/http/quic_send_control_stream.h
+++ b/quiche/quic/core/http/quic_send_control_stream.h
@@ -19,7 +19,7 @@
// 6.2.1 Control Stream.
// The send control stream is self initiated and is write only.
-class QUIC_EXPORT_PRIVATE QuicSendControlStream : public QuicStream {
+class QUICHE_EXPORT QuicSendControlStream : public QuicStream {
public:
// |session| can't be nullptr, and the ownership is not passed. The stream can
// only be accessed through the session.
diff --git a/quiche/quic/core/http/quic_server_initiated_spdy_stream.h b/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
index a47a712..ce0ba63 100644
--- a/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
+++ b/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
@@ -13,8 +13,7 @@
// QuicServerInitiatedSpdyStream is a subclass of QuicSpdyStream meant to handle
// WebTransport traffic on server-initiated bidirectional streams. Receiving or
// sending any other traffic on this stream will result in a CONNECTION_CLOSE.
-class QUIC_EXPORT_PRIVATE QuicServerInitiatedSpdyStream
- : public QuicSpdyStream {
+class QUICHE_EXPORT QuicServerInitiatedSpdyStream : public QuicSpdyStream {
public:
using QuicSpdyStream::QuicSpdyStream;
diff --git a/quiche/quic/core/http/quic_server_session_base.h b/quiche/quic/core/http/quic_server_session_base.h
index fcfda0e..a06cb14 100644
--- a/quiche/quic/core/http/quic_server_session_base.h
+++ b/quiche/quic/core/http/quic_server_session_base.h
@@ -30,7 +30,7 @@
class QuicSimpleServerSessionPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE QuicServerSessionBase : public QuicSpdySession {
+class QUICHE_EXPORT QuicServerSessionBase : public QuicSpdySession {
public:
// Does not take ownership of |connection|. |crypto_config| must outlive the
// session. |helper| must outlive any created crypto streams.
diff --git a/quiche/quic/core/http/quic_spdy_client_session.h b/quiche/quic/core/http/quic_spdy_client_session.h
index 27cfb76..34d255a 100644
--- a/quiche/quic/core/http/quic_spdy_client_session.h
+++ b/quiche/quic/core/http/quic_spdy_client_session.h
@@ -20,8 +20,7 @@
class QuicConnection;
class QuicServerId;
-class QUIC_EXPORT_PRIVATE QuicSpdyClientSession
- : public QuicSpdyClientSessionBase {
+class QUICHE_EXPORT QuicSpdyClientSession : public QuicSpdyClientSessionBase {
public:
// Takes ownership of |connection|. Caller retains ownership of
// |promised_by_url|.
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.h b/quiche/quic/core/http/quic_spdy_client_session_base.h
index 39746b6..eae401e 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.h
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.h
@@ -33,7 +33,7 @@
const int64_t kPushPromiseTimeoutSecs = 60;
// Base class for all client-specific QuicSession subclasses.
-class QUIC_EXPORT_PRIVATE QuicSpdyClientSessionBase
+class QUICHE_EXPORT QuicSpdyClientSessionBase
: public QuicSpdySession,
public QuicCryptoClientStream::ProofHandler {
public:
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.h b/quiche/quic/core/http/quic_spdy_client_stream.h
index 3f35d7d..a5b5886 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.h
+++ b/quiche/quic/core/http/quic_spdy_client_stream.h
@@ -21,7 +21,7 @@
// All this does right now is send an SPDY request, and aggregate the
// SPDY response.
-class QUIC_EXPORT_PRIVATE QuicSpdyClientStream : public QuicSpdyStream {
+class QUICHE_EXPORT QuicSpdyClientStream : public QuicSpdyStream {
public:
QuicSpdyClientStream(QuicStreamId id, QuicSpdyClientSession* session,
StreamType type);
diff --git a/quiche/quic/core/http/quic_spdy_server_stream_base.h b/quiche/quic/core/http/quic_spdy_server_stream_base.h
index d547841..984f909 100644
--- a/quiche/quic/core/http/quic_spdy_server_stream_base.h
+++ b/quiche/quic/core/http/quic_spdy_server_stream_base.h
@@ -9,7 +9,7 @@
namespace quic {
-class QUIC_NO_EXPORT QuicSpdyServerStreamBase : public QuicSpdyStream {
+class QUICHE_EXPORT QuicSpdyServerStreamBase : public QuicSpdyStream {
public:
QuicSpdyServerStreamBase(QuicStreamId id, QuicSpdySession* session,
StreamType type);
diff --git a/quiche/quic/core/http/quic_spdy_session.h b/quiche/quic/core/http/quic_spdy_session.h
index ddd0e5f..9863e46 100644
--- a/quiche/quic/core/http/quic_spdy_session.h
+++ b/quiche/quic/core/http/quic_spdy_session.h
@@ -43,9 +43,9 @@
class WebTransportHttp3UnidirectionalStream;
-QUIC_EXPORT_PRIVATE extern const size_t kMaxUnassociatedWebTransportStreams;
+QUICHE_EXPORT extern const size_t kMaxUnassociatedWebTransportStreams;
-class QUIC_EXPORT_PRIVATE Http3DebugVisitor {
+class QUICHE_EXPORT Http3DebugVisitor {
public:
Http3DebugVisitor();
Http3DebugVisitor(const Http3DebugVisitor&) = delete;
@@ -145,13 +145,13 @@
WebTransportHttp3VersionSet({WebTransportHttp3Version::kDraft02,
WebTransportHttp3Version::kDraft07});
-QUIC_EXPORT_PRIVATE std::string HttpDatagramSupportToString(
+QUICHE_EXPORT std::string HttpDatagramSupportToString(
HttpDatagramSupport http_datagram_support);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const HttpDatagramSupport& http_datagram_support);
// A QUIC session for HTTP.
-class QUIC_EXPORT_PRIVATE QuicSpdySession
+class QUICHE_EXPORT QuicSpdySession
: public QuicSession,
public QpackEncoder::DecoderStreamErrorDelegate,
public QpackDecoder::EncoderStreamErrorDelegate {
@@ -568,8 +568,7 @@
class SpdyFramerVisitor;
// Proxies OnDatagramProcessed() calls to the session.
- class QUIC_EXPORT_PRIVATE DatagramObserver
- : public QuicDatagramQueue::Observer {
+ class QUICHE_EXPORT DatagramObserver : public QuicDatagramQueue::Observer {
public:
explicit DatagramObserver(QuicSpdySession* session) : session_(session) {}
void OnDatagramProcessed(absl::optional<MessageStatus> status) override;
@@ -578,7 +577,7 @@
QuicSpdySession* session_; // not owned
};
- struct QUIC_EXPORT_PRIVATE BufferedWebTransportStream {
+ struct QUICHE_EXPORT BufferedWebTransportStream {
WebTransportSessionId session_id;
QuicStreamId stream_id;
};
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index a43e9fb..9c0086c 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -52,13 +52,13 @@
class WebTransportHttp3;
// A QUIC stream that can send and receive HTTP2 (SPDY) headers.
-class QUIC_EXPORT_PRIVATE QuicSpdyStream
+class QUICHE_EXPORT QuicSpdyStream
: public QuicStream,
public quiche::CapsuleParser::Visitor,
public QpackDecodedHeadersAccumulator::Visitor {
public:
// Visitor receives callbacks from the stream.
- class QUIC_EXPORT_PRIVATE Visitor {
+ class QUICHE_EXPORT Visitor {
public:
Visitor() {}
Visitor(const Visitor&) = delete;
@@ -266,7 +266,7 @@
// to allow mocking in tests.
virtual MessageStatus SendHttp3Datagram(absl::string_view payload);
- class QUIC_EXPORT_PRIVATE Http3DatagramVisitor {
+ class QUICHE_EXPORT Http3DatagramVisitor {
public:
virtual ~Http3DatagramVisitor() {}
@@ -293,7 +293,7 @@
// Mainly meant to be used by the visitors' move operators.
void ReplaceHttp3DatagramVisitor(Http3DatagramVisitor* visitor);
- class QUIC_EXPORT_PRIVATE ConnectIpVisitor {
+ class QUICHE_EXPORT ConnectIpVisitor {
public:
virtual ~ConnectIpVisitor() {}
@@ -389,7 +389,7 @@
friend class QuicStreamUtils;
class HttpDecoderVisitor;
- struct QUIC_EXPORT_PRIVATE WebTransportDataStream {
+ struct QUICHE_EXPORT WebTransportDataStream {
WebTransportDataStream(QuicSpdyStream* stream,
WebTransportSessionId session_id);
diff --git a/quiche/quic/core/http/quic_spdy_stream_body_manager.h b/quiche/quic/core/http/quic_spdy_stream_body_manager.h
index 04c130b..f7a1ab8 100644
--- a/quiche/quic/core/http/quic_spdy_stream_body_manager.h
+++ b/quiche/quic/core/http/quic_spdy_stream_body_manager.h
@@ -26,7 +26,7 @@
// it calculates the total number of bytes (including non-body bytes) the caller
// needs to mark consumed (with QuicStreamSequencer) when non-body bytes are
// received or when body is consumed.
-class QUIC_EXPORT_PRIVATE QuicSpdyStreamBodyManager {
+class QUICHE_EXPORT QuicSpdyStreamBodyManager {
public:
QuicSpdyStreamBodyManager();
~QuicSpdyStreamBodyManager() = default;
@@ -88,7 +88,7 @@
// A Fragment instance represents a body fragment with a count of bytes
// received afterwards but before the next body fragment that can be marked
// consumed as soon as all of the body fragment is read.
- struct QUIC_EXPORT_PRIVATE Fragment {
+ struct QUICHE_EXPORT Fragment {
// |body| must not be empty.
absl::string_view body;
// Might be zero.
diff --git a/quiche/quic/core/http/spdy_server_push_utils.h b/quiche/quic/core/http/spdy_server_push_utils.h
index a924158..82166cd 100644
--- a/quiche/quic/core/http/spdy_server_push_utils.h
+++ b/quiche/quic/core/http/spdy_server_push_utils.h
@@ -11,7 +11,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE SpdyServerPushUtils {
+class QUICHE_EXPORT SpdyServerPushUtils {
public:
SpdyServerPushUtils() = delete;
diff --git a/quiche/quic/core/http/spdy_utils.h b/quiche/quic/core/http/spdy_utils.h
index 05a237d..ff93b69 100644
--- a/quiche/quic/core/http/spdy_utils.h
+++ b/quiche/quic/core/http/spdy_utils.h
@@ -19,7 +19,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE SpdyUtils {
+class QUICHE_EXPORT SpdyUtils {
public:
SpdyUtils() = delete;
diff --git a/quiche/quic/core/http/web_transport_http3.cc b/quiche/quic/core/http/web_transport_http3.cc
index 19e07f7..31a1a35 100644
--- a/quiche/quic/core/http/web_transport_http3.cc
+++ b/quiche/quic/core/http/web_transport_http3.cc
@@ -30,7 +30,7 @@
namespace quic {
namespace {
-class QUIC_NO_EXPORT NoopWebTransportVisitor : public WebTransportVisitor {
+class NoopWebTransportVisitor : public WebTransportVisitor {
void OnSessionReady() override {}
void OnSessionClosed(WebTransportSessionError /*error_code*/,
const std::string& /*error_message*/) override {}
diff --git a/quiche/quic/core/http/web_transport_http3.h b/quiche/quic/core/http/web_transport_http3.h
index e74335e..bb5444a 100644
--- a/quiche/quic/core/http/web_transport_http3.h
+++ b/quiche/quic/core/http/web_transport_http3.h
@@ -40,7 +40,7 @@
//
// WebTransport over HTTP/3 specification:
// <https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3>
-class QUIC_EXPORT_PRIVATE WebTransportHttp3
+class QUICHE_EXPORT WebTransportHttp3
: public WebTransportSession,
public QuicSpdyStream::Http3DatagramVisitor {
public:
@@ -139,8 +139,7 @@
std::string error_message_ = "";
};
-class QUIC_EXPORT_PRIVATE WebTransportHttp3UnidirectionalStream
- : public QuicStream {
+class QUICHE_EXPORT WebTransportHttp3UnidirectionalStream : public QuicStream {
public:
// Incoming stream.
WebTransportHttp3UnidirectionalStream(PendingStream* pending,
@@ -177,16 +176,16 @@
// Remaps HTTP/3 error code into a WebTransport error code. Returns nullopt if
// the provided code is outside of valid range.
-QUIC_EXPORT_PRIVATE absl::optional<WebTransportStreamError>
-Http3ErrorToWebTransport(uint64_t http3_error_code);
+QUICHE_EXPORT absl::optional<WebTransportStreamError> Http3ErrorToWebTransport(
+ uint64_t http3_error_code);
// Same as above, but returns default error value (zero) when none could be
// mapped.
-QUIC_EXPORT_PRIVATE WebTransportStreamError
+QUICHE_EXPORT WebTransportStreamError
Http3ErrorToWebTransportOrDefault(uint64_t http3_error_code);
// Remaps WebTransport error code into an HTTP/3 error code.
-QUIC_EXPORT_PRIVATE uint64_t
+QUICHE_EXPORT uint64_t
WebTransportErrorToHttp3(WebTransportStreamError webtransport_error_code);
} // namespace quic
diff --git a/quiche/quic/core/http/web_transport_stream_adapter.h b/quiche/quic/core/http/web_transport_stream_adapter.h
index c664347..24c250a 100644
--- a/quiche/quic/core/http/web_transport_stream_adapter.h
+++ b/quiche/quic/core/http/web_transport_stream_adapter.h
@@ -16,8 +16,7 @@
// Converts WebTransportStream API calls into QuicStream API calls. The users
// of this class can either subclass it, or wrap around it.
-class QUIC_EXPORT_PRIVATE WebTransportStreamAdapter
- : public WebTransportStream {
+class QUICHE_EXPORT WebTransportStreamAdapter : public WebTransportStream {
public:
WebTransportStreamAdapter(QuicSession* session, QuicStream* stream,
QuicStreamSequencer* sequencer);
diff --git a/quiche/quic/core/io/event_loop_connecting_client_socket.h b/quiche/quic/core/io/event_loop_connecting_client_socket.h
index a7fb32c..16d4a57 100644
--- a/quiche/quic/core/io/event_loop_connecting_client_socket.h
+++ b/quiche/quic/core/io/event_loop_connecting_client_socket.h
@@ -23,9 +23,8 @@
// A connection-based client socket implemented using an underlying
// QuicEventLoop.
-class QUICHE_EXPORT EventLoopConnectingClientSocket
- : public ConnectingClientSocket,
- public QuicSocketEventListener {
+class EventLoopConnectingClientSocket : public ConnectingClientSocket,
+ public QuicSocketEventListener {
public:
// Will use platform default buffer size if `receive_buffer_size` or
// `send_buffer_size` is zero. `async_visitor` may be null if no async
diff --git a/quiche/quic/core/io/event_loop_socket_factory.h b/quiche/quic/core/io/event_loop_socket_factory.h
index 8edf020..a8326c2 100644
--- a/quiche/quic/core/io/event_loop_socket_factory.h
+++ b/quiche/quic/core/io/event_loop_socket_factory.h
@@ -19,7 +19,7 @@
// A socket factory that creates sockets implemented using an underlying
// QuicEventLoop.
-class QUICHE_EXPORT EventLoopSocketFactory : public SocketFactory {
+class EventLoopSocketFactory : public SocketFactory {
public:
// `event_loop` and `buffer_allocator` must outlive the created factory.
EventLoopSocketFactory(QuicEventLoop* event_loop,
diff --git a/quiche/quic/core/io/quic_default_event_loop.h b/quiche/quic/core/io/quic_default_event_loop.h
index 6073a6e..4a2c080 100644
--- a/quiche/quic/core/io/quic_default_event_loop.h
+++ b/quiche/quic/core/io/quic_default_event_loop.h
@@ -14,12 +14,12 @@
// Returns the default implementation of QuicheEventLoop. The embedders can
// override this using the platform API. The factory pointer returned is an
// unowned static variable.
-QUICHE_NO_EXPORT QuicEventLoopFactory* GetDefaultEventLoop();
+QuicEventLoopFactory* GetDefaultEventLoop();
// Returns the factory objects for all event loops. This is particularly useful
// for the unit tests. The factory pointers returned are unowned static
// variables.
-QUICHE_NO_EXPORT std::vector<QuicEventLoopFactory*> GetAllSupportedEventLoops();
+std::vector<QuicEventLoopFactory*> GetAllSupportedEventLoops();
} // namespace quic
diff --git a/quiche/quic/core/io/quic_event_loop.h b/quiche/quic/core/io/quic_event_loop.h
index 6a446ea..53707b4 100644
--- a/quiche/quic/core/io/quic_event_loop.h
+++ b/quiche/quic/core/io/quic_event_loop.h
@@ -24,7 +24,7 @@
class QuicEventLoop;
// A listener associated with a file descriptor.
-class QUICHE_NO_EXPORT QuicSocketEventListener {
+class QuicSocketEventListener {
public:
virtual ~QuicSocketEventListener() = default;
@@ -38,7 +38,7 @@
// Note on error handling: while most of the methods below return a boolean to
// indicate whether the operation has succeeded or not, some will QUIC_BUG
// instead.
-class QUICHE_NO_EXPORT QuicEventLoop {
+class QuicEventLoop {
public:
virtual ~QuicEventLoop() = default;
@@ -83,7 +83,7 @@
// A factory object for the event loop. Every implementation is expected to have
// a static singleton instance.
-class QUICHE_NO_EXPORT QuicEventLoopFactory {
+class QuicEventLoopFactory {
public:
virtual ~QuicEventLoopFactory() {}
diff --git a/quiche/quic/core/io/quic_poll_event_loop.h b/quiche/quic/core/io/quic_poll_event_loop.h
index 7c7f4bf..db29598 100644
--- a/quiche/quic/core/io/quic_poll_event_loop.h
+++ b/quiche/quic/core/io/quic_poll_event_loop.h
@@ -39,7 +39,7 @@
// processing, when all of the state for the event loop is consistent.
// 2. The callbacks are stored as weak pointers, since other callbacks can
// cause them to be unregistered.
-class QUICHE_NO_EXPORT QuicPollEventLoop : public QuicEventLoop {
+class QuicPollEventLoop : public QuicEventLoop {
public:
QuicPollEventLoop(QuicClock* clock);
@@ -148,7 +148,7 @@
bool has_artificial_events_pending_ = false;
};
-class QUICHE_NO_EXPORT QuicPollEventLoopFactory : public QuicEventLoopFactory {
+class QuicPollEventLoopFactory : public QuicEventLoopFactory {
public:
static QuicPollEventLoopFactory* Get() {
static QuicPollEventLoopFactory* factory = new QuicPollEventLoopFactory();
diff --git a/quiche/quic/core/io/socket.h b/quiche/quic/core/io/socket.h
index 8fc7732..edff4ee 100644
--- a/quiche/quic/core/io/socket.h
+++ b/quiche/quic/core/io/socket.h
@@ -55,7 +55,7 @@
return "unknown";
}
-struct QUICHE_EXPORT AcceptResult {
+struct AcceptResult {
// Socket for interacting with the accepted connection.
SocketFd fd;
diff --git a/quiche/quic/core/legacy_quic_stream_id_manager.h b/quiche/quic/core/legacy_quic_stream_id_manager.h
index 3c67028..2d76768 100644
--- a/quiche/quic/core/legacy_quic_stream_id_manager.h
+++ b/quiche/quic/core/legacy_quic_stream_id_manager.h
@@ -20,7 +20,7 @@
// Manages Google QUIC stream IDs. This manager is responsible for two
// questions: 1) can next outgoing stream ID be allocated (if yes, what is the
// next outgoing stream ID) and 2) can a new incoming stream be opened.
-class QUIC_EXPORT_PRIVATE LegacyQuicStreamIdManager {
+class QUICHE_EXPORT LegacyQuicStreamIdManager {
public:
LegacyQuicStreamIdManager(Perspective perspective,
QuicTransportVersion transport_version,
diff --git a/quiche/quic/core/packet_number_indexed_queue.h b/quiche/quic/core/packet_number_indexed_queue.h
index ef48bd1..446dea9 100644
--- a/quiche/quic/core/packet_number_indexed_queue.h
+++ b/quiche/quic/core/packet_number_indexed_queue.h
@@ -37,7 +37,7 @@
// TODO(wub): Update the comments when deprecating
// --quic_bw_sampler_remove_packets_once_per_congestion_event.
template <typename T>
-class QUIC_NO_EXPORT PacketNumberIndexedQueue {
+class QUICHE_EXPORT PacketNumberIndexedQueue {
public:
PacketNumberIndexedQueue() : number_of_present_entries_(0) {}
@@ -93,7 +93,7 @@
private:
// Wrapper around T used to mark whether the entry is actually in the map.
- struct QUIC_NO_EXPORT EntryWrapper : T {
+ struct QUICHE_EXPORT EntryWrapper : T {
// NOTE(wub): When quic_bw_sampler_remove_packets_once_per_congestion_event
// is enabled, |present| is false if and only if this is a placeholder entry
// for holes in the parent's |entries|.
diff --git a/quiche/quic/core/qpack/qpack_blocking_manager.h b/quiche/quic/core/qpack/qpack_blocking_manager.h
index 46e75b8..0189ad2 100644
--- a/quiche/quic/core/qpack/qpack_blocking_manager.h
+++ b/quiche/quic/core/qpack/qpack_blocking_manager.h
@@ -24,7 +24,7 @@
// Class to keep track of blocked streams and blocking dynamic table entries:
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#blocked-decoding
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#blocked-insertion
-class QUIC_EXPORT_PRIVATE QpackBlockingManager {
+class QUICHE_EXPORT QpackBlockingManager {
public:
using IndexSet = std::multiset<uint64_t>;
diff --git a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
index 0e6e31b..5fd00fa 100644
--- a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
+++ b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
@@ -23,7 +23,7 @@
// decoded headers in a QuicHeaderList, and keeps track of uncompressed and
// compressed size so that it can be passed to
// QuicHeaderList::OnHeaderBlockEnd().
-class QUIC_EXPORT_PRIVATE QpackDecodedHeadersAccumulator
+class QUICHE_EXPORT QpackDecodedHeadersAccumulator
: public QpackProgressiveDecoder::HeadersHandlerInterface {
public:
// Visitor interface to signal success or error.
@@ -31,7 +31,7 @@
// Methods may be called synchronously from Decode() and EndHeaderBlock(),
// or asynchronously.
// Method implementations are allowed to destroy |this|.
- class QUIC_EXPORT_PRIVATE Visitor {
+ class QUICHE_EXPORT Visitor {
public:
virtual ~Visitor() = default;
diff --git a/quiche/quic/core/qpack/qpack_decoder.h b/quiche/quic/core/qpack/qpack_decoder.h
index 1d12068..3dda666 100644
--- a/quiche/quic/core/qpack/qpack_decoder.h
+++ b/quiche/quic/core/qpack/qpack_decoder.h
@@ -27,7 +27,7 @@
// are stream errors.
// The only input of QpackDecoder is the encoder stream. Any error QpackDecoder
// signals is an encoder stream error, which is fatal to the connection.
-class QUIC_EXPORT_PRIVATE QpackDecoder
+class QUICHE_EXPORT QpackDecoder
: public QpackEncoderStreamReceiver::Delegate,
public QpackProgressiveDecoder::BlockedStreamLimitEnforcer,
public QpackProgressiveDecoder::DecodingCompletedVisitor {
@@ -35,7 +35,7 @@
// Interface for receiving notification that an error has occurred on the
// encoder stream. This MUST be treated as a connection error of type
// HTTP_QPACK_ENCODER_STREAM_ERROR.
- class QUIC_EXPORT_PRIVATE EncoderStreamErrorDelegate {
+ class QUICHE_EXPORT EncoderStreamErrorDelegate {
public:
virtual ~EncoderStreamErrorDelegate() {}
@@ -126,7 +126,7 @@
};
// QpackDecoder::EncoderStreamErrorDelegate implementation that does nothing.
-class QUIC_EXPORT_PRIVATE NoopEncoderStreamErrorDelegate
+class QUICHE_EXPORT NoopEncoderStreamErrorDelegate
: public QpackDecoder::EncoderStreamErrorDelegate {
public:
~NoopEncoderStreamErrorDelegate() override = default;
diff --git a/quiche/quic/core/qpack/qpack_decoder_stream_receiver.h b/quiche/quic/core/qpack/qpack_decoder_stream_receiver.h
index f78fca9..0151d5f 100644
--- a/quiche/quic/core/qpack/qpack_decoder_stream_receiver.h
+++ b/quiche/quic/core/qpack/qpack_decoder_stream_receiver.h
@@ -18,13 +18,13 @@
// This class decodes data received on the decoder stream,
// and passes it along to its Delegate.
-class QUIC_EXPORT_PRIVATE QpackDecoderStreamReceiver
+class QUICHE_EXPORT QpackDecoderStreamReceiver
: public QpackInstructionDecoder::Delegate,
public QpackStreamReceiver {
public:
// An interface for handling instructions decoded from the decoder stream, see
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#rfc.section.5.3
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() = default;
diff --git a/quiche/quic/core/qpack/qpack_decoder_stream_sender.h b/quiche/quic/core/qpack/qpack_decoder_stream_sender.h
index 443e850..32b19b3 100644
--- a/quiche/quic/core/qpack/qpack_decoder_stream_sender.h
+++ b/quiche/quic/core/qpack/qpack_decoder_stream_sender.h
@@ -16,7 +16,7 @@
// This class serializes instructions for transmission on the decoder stream.
// Serialized instructions are buffered until Flush() is called.
-class QUIC_EXPORT_PRIVATE QpackDecoderStreamSender {
+class QUICHE_EXPORT QpackDecoderStreamSender {
public:
QpackDecoderStreamSender();
QpackDecoderStreamSender(const QpackDecoderStreamSender&) = delete;
diff --git a/quiche/quic/core/qpack/qpack_encoder.h b/quiche/quic/core/qpack/qpack_encoder.h
index 89d08b1..bb34b20 100644
--- a/quiche/quic/core/qpack/qpack_encoder.h
+++ b/quiche/quic/core/qpack/qpack_encoder.h
@@ -31,13 +31,12 @@
} // namespace test
// QPACK encoder class. Exactly one instance should exist per QUIC connection.
-class QUIC_EXPORT_PRIVATE QpackEncoder
- : public QpackDecoderStreamReceiver::Delegate {
+class QUICHE_EXPORT QpackEncoder : public QpackDecoderStreamReceiver::Delegate {
public:
// Interface for receiving notification that an error has occurred on the
// decoder stream. This MUST be treated as a connection error of type
// HTTP_QPACK_DECODER_STREAM_ERROR.
- class QUIC_EXPORT_PRIVATE DecoderStreamErrorDelegate {
+ class QUICHE_EXPORT DecoderStreamErrorDelegate {
public:
virtual ~DecoderStreamErrorDelegate() {}
@@ -156,7 +155,7 @@
};
// QpackEncoder::DecoderStreamErrorDelegate implementation that does nothing.
-class QUIC_EXPORT_PRIVATE NoopDecoderStreamErrorDelegate
+class QUICHE_EXPORT NoopDecoderStreamErrorDelegate
: public QpackEncoder::DecoderStreamErrorDelegate {
public:
~NoopDecoderStreamErrorDelegate() override = default;
diff --git a/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h b/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h
index 6db91e1..d1b485c 100644
--- a/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h
+++ b/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h
@@ -17,13 +17,13 @@
namespace quic {
// This class decodes data received on the encoder stream.
-class QUIC_EXPORT_PRIVATE QpackEncoderStreamReceiver
+class QUICHE_EXPORT QpackEncoderStreamReceiver
: public QpackInstructionDecoder::Delegate,
public QpackStreamReceiver {
public:
// An interface for handling instructions decoded from the encoder stream, see
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#rfc.section.5.2
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() = default;
diff --git a/quiche/quic/core/qpack/qpack_encoder_stream_sender.h b/quiche/quic/core/qpack/qpack_encoder_stream_sender.h
index ab53a1d..a8c0bbc 100644
--- a/quiche/quic/core/qpack/qpack_encoder_stream_sender.h
+++ b/quiche/quic/core/qpack/qpack_encoder_stream_sender.h
@@ -17,7 +17,7 @@
// This class serializes instructions for transmission on the encoder stream.
// Serialized instructions are buffered until Flush() is called.
-class QUIC_EXPORT_PRIVATE QpackEncoderStreamSender {
+class QUICHE_EXPORT QpackEncoderStreamSender {
public:
QpackEncoderStreamSender();
QpackEncoderStreamSender(const QpackEncoderStreamSender&) = delete;
diff --git a/quiche/quic/core/qpack/qpack_header_table.h b/quiche/quic/core/qpack/qpack_header_table.h
index f882e75..9b87fcc 100644
--- a/quiche/quic/core/qpack/qpack_header_table.h
+++ b/quiche/quic/core/qpack/qpack_header_table.h
@@ -34,7 +34,7 @@
// absolute indices. The caller needs to perform the necessary transformations
// to and from relative indices and post-base indices.
template <typename DynamicEntryTable>
-class QUIC_EXPORT_PRIVATE QpackHeaderTableBase {
+class QUICHE_EXPORT QpackHeaderTableBase {
public:
QpackHeaderTableBase();
QpackHeaderTableBase(const QpackHeaderTableBase&) = delete;
@@ -155,21 +155,21 @@
namespace internal {
-QUIC_NO_EXPORT inline size_t GetSize(const QpackEntry& entry) {
+QUICHE_EXPORT inline size_t GetSize(const QpackEntry& entry) {
return entry.Size();
}
-QUIC_NO_EXPORT inline size_t GetSize(const std::unique_ptr<QpackEntry>& entry) {
+QUICHE_EXPORT inline size_t GetSize(const std::unique_ptr<QpackEntry>& entry) {
return entry->Size();
}
-QUIC_NO_EXPORT inline std::unique_ptr<QpackEntry> NewEntry(
+QUICHE_EXPORT inline std::unique_ptr<QpackEntry> NewEntry(
std::string name, std::string value, QpackEncoderDynamicTable& /*t*/) {
return std::make_unique<QpackEntry>(std::move(name), std::move(value));
}
-QUIC_NO_EXPORT inline QpackEntry NewEntry(std::string name, std::string value,
- QpackDecoderDynamicTable& /*t*/) {
+QUICHE_EXPORT inline QpackEntry NewEntry(std::string name, std::string value,
+ QpackDecoderDynamicTable& /*t*/) {
return QpackEntry{std::move(name), std::move(value)};
}
@@ -242,7 +242,7 @@
}
}
-class QUIC_EXPORT_PRIVATE QpackEncoderHeaderTable
+class QUICHE_EXPORT QpackEncoderHeaderTable
: public QpackHeaderTableBase<QpackEncoderDynamicTable> {
public:
// Result of header table lookup.
@@ -307,11 +307,11 @@
NameToEntryMap dynamic_name_index_;
};
-class QUIC_EXPORT_PRIVATE QpackDecoderHeaderTable
+class QUICHE_EXPORT QpackDecoderHeaderTable
: public QpackHeaderTableBase<QpackDecoderDynamicTable> {
public:
// Observer interface for dynamic table insertion.
- class QUIC_EXPORT_PRIVATE Observer {
+ class QUICHE_EXPORT Observer {
public:
virtual ~Observer() = default;
diff --git a/quiche/quic/core/qpack/qpack_index_conversions.h b/quiche/quic/core/qpack/qpack_index_conversions.h
index ddd51cf..f4987e4 100644
--- a/quiche/quic/core/qpack/qpack_index_conversions.h
+++ b/quiche/quic/core/qpack/qpack_index_conversions.h
@@ -24,28 +24,29 @@
// 32 bytes), overflow is not possible. The caller is responsible for providing
// input that does not underflow.
-QUIC_EXPORT_PRIVATE uint64_t QpackAbsoluteIndexToEncoderStreamRelativeIndex(
+QUICHE_EXPORT uint64_t QpackAbsoluteIndexToEncoderStreamRelativeIndex(
uint64_t absolute_index, uint64_t inserted_entry_count);
-QUIC_EXPORT_PRIVATE uint64_t QpackAbsoluteIndexToRequestStreamRelativeIndex(
+QUICHE_EXPORT uint64_t QpackAbsoluteIndexToRequestStreamRelativeIndex(
uint64_t absolute_index, uint64_t base);
// Conversion functions used in the decoder operate on input received from the
// network. These functions return false on overflow or underflow.
-QUIC_EXPORT_PRIVATE bool QpackEncoderStreamRelativeIndexToAbsoluteIndex(
+QUICHE_EXPORT bool QpackEncoderStreamRelativeIndexToAbsoluteIndex(
uint64_t relative_index, uint64_t inserted_entry_count,
uint64_t* absolute_index);
// On success, |*absolute_index| is guaranteed to be strictly less than
// std::numeric_limits<uint64_t>::max().
-QUIC_EXPORT_PRIVATE bool QpackRequestStreamRelativeIndexToAbsoluteIndex(
+QUICHE_EXPORT bool QpackRequestStreamRelativeIndexToAbsoluteIndex(
uint64_t relative_index, uint64_t base, uint64_t* absolute_index);
// On success, |*absolute_index| is guaranteed to be strictly less than
// std::numeric_limits<uint64_t>::max().
-QUIC_EXPORT_PRIVATE bool QpackPostBaseIndexToAbsoluteIndex(
- uint64_t post_base_index, uint64_t base, uint64_t* absolute_index);
+QUICHE_EXPORT bool QpackPostBaseIndexToAbsoluteIndex(uint64_t post_base_index,
+ uint64_t base,
+ uint64_t* absolute_index);
} // namespace quic
diff --git a/quiche/quic/core/qpack/qpack_instruction_decoder.h b/quiche/quic/core/qpack/qpack_instruction_decoder.h
index c848b3d..9b6c3f0 100644
--- a/quiche/quic/core/qpack/qpack_instruction_decoder.h
+++ b/quiche/quic/core/qpack/qpack_instruction_decoder.h
@@ -20,7 +20,7 @@
// Generic instruction decoder class. Takes a QpackLanguage that describes a
// language, that is, a set of instruction opcodes together with a list of
// fields that follow each instruction.
-class QUIC_EXPORT_PRIVATE QpackInstructionDecoder {
+class QUICHE_EXPORT QpackInstructionDecoder {
public:
enum class ErrorCode {
INTEGER_TOO_LARGE,
@@ -30,7 +30,7 @@
// Delegate is notified each time an instruction is decoded or when an error
// occurs.
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() = default;
diff --git a/quiche/quic/core/qpack/qpack_instruction_encoder.h b/quiche/quic/core/qpack/qpack_instruction_encoder.h
index 9b7551d..3d6003e 100644
--- a/quiche/quic/core/qpack/qpack_instruction_encoder.h
+++ b/quiche/quic/core/qpack/qpack_instruction_encoder.h
@@ -17,7 +17,7 @@
// Generic instruction encoder class. Takes a QpackLanguage that describes a
// language, that is, a set of instruction opcodes together with a list of
// fields that follow each instruction.
-class QUIC_EXPORT_PRIVATE QpackInstructionEncoder {
+class QUICHE_EXPORT QpackInstructionEncoder {
public:
QpackInstructionEncoder();
QpackInstructionEncoder(const QpackInstructionEncoder&) = delete;
diff --git a/quiche/quic/core/qpack/qpack_instructions.h b/quiche/quic/core/qpack/qpack_instructions.h
index a964242..ab80874 100644
--- a/quiche/quic/core/qpack/qpack_instructions.h
+++ b/quiche/quic/core/qpack/qpack_instructions.h
@@ -22,7 +22,7 @@
// Each instruction is identified with an opcode in the first byte.
// |mask| determines which bits are part of the opcode.
// |value| is the value of these bits. (Other bits in value must be zero.)
-struct QUIC_EXPORT_PRIVATE QpackInstructionOpcode {
+struct QUICHE_EXPORT QpackInstructionOpcode {
uint8_t value;
uint8_t mask;
};
@@ -54,7 +54,7 @@
// Each instruction field has a type and a parameter.
// The meaning of the parameter depends on the field type.
-struct QUIC_EXPORT_PRIVATE QpackInstructionField {
+struct QUICHE_EXPORT QpackInstructionField {
QpackInstructionFieldType type;
// For a kSbit field, |param| is a mask with exactly one bit set.
// For kVarint fields, |param| is the prefix length of the integer encoding.
@@ -70,7 +70,7 @@
// followed by a non-empty list of fields. The last field must be integer or
// string literal type to guarantee that all bytes of the instruction are
// consumed.
-struct QUIC_EXPORT_PRIVATE QpackInstruction {
+struct QUICHE_EXPORT QpackInstruction {
QpackInstruction(QpackInstructionOpcode opcode, QpackInstructionFields fields)
: opcode(std::move(opcode)), fields(std::move(fields)) {}
@@ -148,7 +148,7 @@
// Storage for instruction and field values to be encoded.
// This class can only be instantiated using factory methods that take exactly
// the arguments that the corresponding instruction needs.
-class QUIC_EXPORT_PRIVATE QpackInstructionWithValues {
+class QUICHE_EXPORT QpackInstructionWithValues {
public:
// 5.2 Encoder stream instructions
static QpackInstructionWithValues InsertWithNameReference(
diff --git a/quiche/quic/core/qpack/qpack_progressive_decoder.h b/quiche/quic/core/qpack/qpack_progressive_decoder.h
index 7616376..cfca2bd 100644
--- a/quiche/quic/core/qpack/qpack_progressive_decoder.h
+++ b/quiche/quic/core/qpack/qpack_progressive_decoder.h
@@ -22,12 +22,12 @@
class QpackDecoderHeaderTable;
// Class to decode a single header block.
-class QUIC_EXPORT_PRIVATE QpackProgressiveDecoder
+class QUICHE_EXPORT QpackProgressiveDecoder
: public QpackInstructionDecoder::Delegate,
public QpackDecoderHeaderTable::Observer {
public:
// Interface for receiving decoded header block from the decoder.
- class QUIC_EXPORT_PRIVATE HeadersHandlerInterface {
+ class QUICHE_EXPORT HeadersHandlerInterface {
public:
virtual ~HeadersHandlerInterface() {}
@@ -53,7 +53,7 @@
// Interface for keeping track of blocked streams for the purpose of enforcing
// the limit communicated to peer via QPACK_BLOCKED_STREAMS settings.
- class QUIC_EXPORT_PRIVATE BlockedStreamLimitEnforcer {
+ class QUICHE_EXPORT BlockedStreamLimitEnforcer {
public:
virtual ~BlockedStreamLimitEnforcer() {}
@@ -69,7 +69,7 @@
};
// Visitor to be notified when decoding is completed.
- class QUIC_EXPORT_PRIVATE DecodingCompletedVisitor {
+ class QUICHE_EXPORT DecodingCompletedVisitor {
public:
virtual ~DecodingCompletedVisitor() = default;
diff --git a/quiche/quic/core/qpack/qpack_receive_stream.h b/quiche/quic/core/qpack/qpack_receive_stream.h
index 20ad878..173d28c 100644
--- a/quiche/quic/core/qpack/qpack_receive_stream.h
+++ b/quiche/quic/core/qpack/qpack_receive_stream.h
@@ -15,7 +15,7 @@
// QPACK 4.2.1 Encoder and Decoder Streams.
// The QPACK receive stream is peer initiated and is read only.
-class QUIC_EXPORT_PRIVATE QpackReceiveStream : public QuicStream {
+class QUICHE_EXPORT QpackReceiveStream : public QuicStream {
public:
// Construct receive stream from pending stream, the |pending| object needs
// to be deleted after the construction.
diff --git a/quiche/quic/core/qpack/qpack_required_insert_count.h b/quiche/quic/core/qpack/qpack_required_insert_count.h
index 762dfb1..550cf27 100644
--- a/quiche/quic/core/qpack/qpack_required_insert_count.h
+++ b/quiche/quic/core/qpack/qpack_required_insert_count.h
@@ -14,14 +14,14 @@
// Calculate Encoded Required Insert Count from Required Insert Count and
// MaxEntries according to
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#ric.
-QUIC_EXPORT_PRIVATE uint64_t QpackEncodeRequiredInsertCount(
+QUICHE_EXPORT uint64_t QpackEncodeRequiredInsertCount(
uint64_t required_insert_count, uint64_t max_entries);
// Calculate Required Insert Count from Encoded Required Insert Count,
// MaxEntries, and total number of dynamic table insertions according to
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#ric. Returns true
// on success, false on invalid input or overflow/underflow.
-QUIC_EXPORT_PRIVATE bool QpackDecodeRequiredInsertCount(
+QUICHE_EXPORT bool QpackDecodeRequiredInsertCount(
uint64_t encoded_required_insert_count, uint64_t max_entries,
uint64_t total_number_of_inserts, uint64_t* required_insert_count);
diff --git a/quiche/quic/core/qpack/qpack_send_stream.h b/quiche/quic/core/qpack/qpack_send_stream.h
index 8c9a764..07e3927 100644
--- a/quiche/quic/core/qpack/qpack_send_stream.h
+++ b/quiche/quic/core/qpack/qpack_send_stream.h
@@ -19,8 +19,8 @@
// QPACK 4.2.1 Encoder and Decoder Streams.
// The QPACK send stream is self initiated and is write only.
-class QUIC_EXPORT_PRIVATE QpackSendStream : public QuicStream,
- public QpackStreamSenderDelegate {
+class QUICHE_EXPORT QpackSendStream : public QuicStream,
+ public QpackStreamSenderDelegate {
public:
// |session| can't be nullptr, and the ownership is not passed. |session| owns
// this stream.
diff --git a/quiche/quic/core/qpack/qpack_static_table.h b/quiche/quic/core/qpack/qpack_static_table.h
index 43fd297..7fc7895 100644
--- a/quiche/quic/core/qpack/qpack_static_table.h
+++ b/quiche/quic/core/qpack/qpack_static_table.h
@@ -18,13 +18,12 @@
// QPACK static table defined at
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#static-table.
-QUIC_EXPORT_PRIVATE const std::vector<QpackStaticEntry>&
-QpackStaticTableVector();
+QUICHE_EXPORT const std::vector<QpackStaticEntry>& QpackStaticTableVector();
// Returns a QpackStaticTable instance initialized with kQpackStaticTable.
// The instance is read-only, has static lifetime, and is safe to share amoung
// threads. This function is thread-safe.
-QUIC_EXPORT_PRIVATE const QpackStaticTable& ObtainQpackStaticTable();
+QUICHE_EXPORT const QpackStaticTable& ObtainQpackStaticTable();
} // namespace quic
diff --git a/quiche/quic/core/qpack/qpack_stream_receiver.h b/quiche/quic/core/qpack/qpack_stream_receiver.h
index ad95cce..4aadf2a 100644
--- a/quiche/quic/core/qpack/qpack_stream_receiver.h
+++ b/quiche/quic/core/qpack/qpack_stream_receiver.h
@@ -11,7 +11,7 @@
namespace quic {
// This interface decodes QPACK data that are received on a QpackReceiveStream.
-class QUIC_EXPORT_PRIVATE QpackStreamReceiver {
+class QUICHE_EXPORT QpackStreamReceiver {
public:
virtual ~QpackStreamReceiver() = default;
diff --git a/quiche/quic/core/qpack/qpack_stream_sender_delegate.h b/quiche/quic/core/qpack/qpack_stream_sender_delegate.h
index 8e267db..46cac5c 100644
--- a/quiche/quic/core/qpack/qpack_stream_sender_delegate.h
+++ b/quiche/quic/core/qpack/qpack_stream_sender_delegate.h
@@ -11,7 +11,7 @@
namespace quic {
// This interface writes encoder/decoder data to peer.
-class QUIC_EXPORT_PRIVATE QpackStreamSenderDelegate {
+class QUICHE_EXPORT QpackStreamSenderDelegate {
public:
virtual ~QpackStreamSenderDelegate() = default;
diff --git a/quiche/quic/core/qpack/value_splitting_header_list.h b/quiche/quic/core/qpack/value_splitting_header_list.h
index e275033..fb8d647 100644
--- a/quiche/quic/core/qpack/value_splitting_header_list.h
+++ b/quiche/quic/core/qpack/value_splitting_header_list.h
@@ -14,11 +14,11 @@
// A wrapper class around Http2HeaderBlock that splits header values along ';'
// separators (while also removing optional space following separator) for
// cookies and along '\0' separators for other header fields.
-class QUIC_EXPORT_PRIVATE ValueSplittingHeaderList {
+class QUICHE_EXPORT ValueSplittingHeaderList {
public:
using value_type = spdy::Http2HeaderBlock::value_type;
- class QUIC_EXPORT_PRIVATE const_iterator {
+ class QUICHE_EXPORT const_iterator {
public:
// |header_list| must outlive this object.
const_iterator(const spdy::Http2HeaderBlock* header_list,
diff --git a/quiche/quic/core/quic_ack_listener_interface.h b/quiche/quic/core/quic_ack_listener_interface.h
index edf4fd3..14d3773 100644
--- a/quiche/quic/core/quic_ack_listener_interface.h
+++ b/quiche/quic/core/quic_ack_listener_interface.h
@@ -13,7 +13,7 @@
namespace quic {
// Pure virtual class to listen for packet acknowledgements.
-class QUIC_EXPORT_PRIVATE QuicAckListenerInterface
+class QUICHE_EXPORT QuicAckListenerInterface
: public quiche::QuicheReferenceCounted {
public:
QuicAckListenerInterface() {}
diff --git a/quiche/quic/core/quic_alarm.h b/quiche/quic/core/quic_alarm.h
index 4352a44..25551bb 100644
--- a/quiche/quic/core/quic_alarm.h
+++ b/quiche/quic/core/quic_alarm.h
@@ -17,9 +17,9 @@
// An alarm may be cancelled, in which case it may or may not be
// removed from the underlying scheduling system, but in either case
// the task will not be executed.
-class QUIC_EXPORT_PRIVATE QuicAlarm {
+class QUICHE_EXPORT QuicAlarm {
public:
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
@@ -36,7 +36,7 @@
// DelegateWithContext is a Delegate with a QuicConnectionContext* stored as a
// member variable.
- class QUIC_EXPORT_PRIVATE DelegateWithContext : public Delegate {
+ class QUICHE_EXPORT DelegateWithContext : public Delegate {
public:
explicit DelegateWithContext(QuicConnectionContext* context)
: context_(context) {}
@@ -50,7 +50,7 @@
// DelegateWithoutContext is a Delegate that does not have a corresponding
// context. Typically this means one object of the child class deals with many
// connections.
- class QUIC_EXPORT_PRIVATE DelegateWithoutContext : public Delegate {
+ class QUICHE_EXPORT DelegateWithoutContext : public Delegate {
public:
~DelegateWithoutContext() override {}
QuicConnectionContext* GetConnectionContext() override { return nullptr; }
diff --git a/quiche/quic/core/quic_alarm_factory.h b/quiche/quic/core/quic_alarm_factory.h
index b1ce54c..c6bae38 100644
--- a/quiche/quic/core/quic_alarm_factory.h
+++ b/quiche/quic/core/quic_alarm_factory.h
@@ -12,7 +12,7 @@
namespace quic {
// Creates platform-specific alarms used throughout QUIC.
-class QUIC_EXPORT_PRIVATE QuicAlarmFactory {
+class QUICHE_EXPORT QuicAlarmFactory {
public:
virtual ~QuicAlarmFactory() {}
diff --git a/quiche/quic/core/quic_arena_scoped_ptr.h b/quiche/quic/core/quic_arena_scoped_ptr.h
index a0c4ed8..79d3d2c 100644
--- a/quiche/quic/core/quic_arena_scoped_ptr.h
+++ b/quiche/quic/core/quic_arena_scoped_ptr.h
@@ -19,7 +19,7 @@
namespace quic {
template <typename T>
-class QUIC_NO_EXPORT QuicArenaScopedPtr {
+class QUICHE_EXPORT QuicArenaScopedPtr {
static_assert(alignof(T*) > 1,
"QuicArenaScopedPtr can only store objects that are aligned to "
"greater than 1 byte.");
diff --git a/quiche/quic/core/quic_bandwidth.h b/quiche/quic/core/quic_bandwidth.h
index 33356ab..48c9eec 100644
--- a/quiche/quic/core/quic_bandwidth.h
+++ b/quiche/quic/core/quic_bandwidth.h
@@ -21,7 +21,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicBandwidth {
+class QUICHE_EXPORT QuicBandwidth {
public:
// Creates a new QuicBandwidth with an internal value of 0.
static constexpr QuicBandwidth Zero() { return QuicBandwidth(0); }
diff --git a/quiche/quic/core/quic_blocked_writer_interface.h b/quiche/quic/core/quic_blocked_writer_interface.h
index 062b5cc..c034eba 100644
--- a/quiche/quic/core/quic_blocked_writer_interface.h
+++ b/quiche/quic/core/quic_blocked_writer_interface.h
@@ -13,7 +13,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicBlockedWriterInterface {
+class QUICHE_EXPORT QuicBlockedWriterInterface {
public:
virtual ~QuicBlockedWriterInterface() {}
diff --git a/quiche/quic/core/quic_buffered_packet_store.h b/quiche/quic/core/quic_buffered_packet_store.h
index 95bb737..734980f 100644
--- a/quiche/quic/core/quic_buffered_packet_store.h
+++ b/quiche/quic/core/quic_buffered_packet_store.h
@@ -33,7 +33,7 @@
// of connections: connections with CHLO buffered and those without CHLO. The
// latter has its own upper limit along with the max number of connections this
// store can hold. The former pool can grow till this store is full.
-class QUIC_NO_EXPORT QuicBufferedPacketStore {
+class QUICHE_EXPORT QuicBufferedPacketStore {
public:
enum EnqueuePacketResult {
SUCCESS = 0,
@@ -41,7 +41,7 @@
TOO_MANY_CONNECTIONS // Too many connections stored up in the store.
};
- struct QUIC_NO_EXPORT BufferedPacket {
+ struct QUICHE_EXPORT BufferedPacket {
BufferedPacket(std::unique_ptr<QuicReceivedPacket> packet,
QuicSocketAddress self_address,
QuicSocketAddress peer_address);
@@ -57,7 +57,7 @@
};
// A queue of BufferedPackets for a connection.
- struct QUIC_NO_EXPORT BufferedPacketList {
+ struct QUICHE_EXPORT BufferedPacketList {
BufferedPacketList();
BufferedPacketList(BufferedPacketList&& other);
@@ -81,7 +81,7 @@
quiche::QuicheLinkedHashMap<QuicConnectionId, BufferedPacketList,
QuicConnectionIdHash>;
- class QUIC_NO_EXPORT VisitorInterface {
+ class QUICHE_EXPORT VisitorInterface {
public:
virtual ~VisitorInterface() {}
diff --git a/quiche/quic/core/quic_chaos_protector.h b/quiche/quic/core/quic_chaos_protector.h
index 6bcb335..9b7636f 100644
--- a/quiche/quic/core/quic_chaos_protector.h
+++ b/quiche/quic/core/quic_chaos_protector.h
@@ -26,8 +26,7 @@
// QuicChaosProtector will take a crypto frame and an amount of padding and
// build a data packet that will parse to something equivalent.
-class QUIC_EXPORT_PRIVATE QuicChaosProtector
- : public QuicStreamFrameDataProducer {
+class QUICHE_EXPORT QuicChaosProtector : public QuicStreamFrameDataProducer {
public:
// |framer| and |random| must be valid for the lifetime of QuicChaosProtector.
explicit QuicChaosProtector(const QuicCryptoFrame& crypto_frame,
diff --git a/quiche/quic/core/quic_clock.h b/quiche/quic/core/quic_clock.h
index 5e5fd5b..0eaf7ac 100644
--- a/quiche/quic/core/quic_clock.h
+++ b/quiche/quic/core/quic_clock.h
@@ -16,7 +16,7 @@
namespace quic {
// Interface for retrieving the current time.
-class QUIC_EXPORT_PRIVATE QuicClock {
+class QUICHE_EXPORT QuicClock {
public:
QuicClock() = default;
virtual ~QuicClock() = default;
diff --git a/quiche/quic/core/quic_coalesced_packet.h b/quiche/quic/core/quic_coalesced_packet.h
index b362937..5f3a020 100644
--- a/quiche/quic/core/quic_coalesced_packet.h
+++ b/quiche/quic/core/quic_coalesced_packet.h
@@ -15,7 +15,7 @@
// QuicCoalescedPacket is used to buffer multiple packets which can be coalesced
// into the same UDP datagram.
-class QUIC_EXPORT_PRIVATE QuicCoalescedPacket {
+class QUICHE_EXPORT QuicCoalescedPacket {
public:
QuicCoalescedPacket();
~QuicCoalescedPacket();
diff --git a/quiche/quic/core/quic_config.h b/quiche/quic/core/quic_config.h
index f60b481..152994b 100644
--- a/quiche/quic/core/quic_config.h
+++ b/quiche/quic/core/quic_config.h
@@ -44,7 +44,7 @@
// An abstract base class that stores a value that can be sent in CHLO/SHLO
// message. These values can be OPTIONAL or REQUIRED, depending on |presence_|.
-class QUIC_EXPORT_PRIVATE QuicConfigValue {
+class QUICHE_EXPORT QuicConfigValue {
public:
QuicConfigValue(QuicTag tag, QuicConfigPresence presence);
virtual ~QuicConfigValue();
@@ -64,7 +64,7 @@
};
// Stores uint32_t from CHLO or SHLO messages that are not negotiated.
-class QUIC_EXPORT_PRIVATE QuicFixedUint32 : public QuicConfigValue {
+class QUICHE_EXPORT QuicFixedUint32 : public QuicConfigValue {
public:
QuicFixedUint32(QuicTag tag, QuicConfigPresence presence);
~QuicFixedUint32() override;
@@ -99,7 +99,7 @@
// Stores 62bit numbers from handshake messages that unilaterally shared by each
// endpoint. IMPORTANT: these are serialized as 32-bit unsigned integers when
// using QUIC_CRYPTO versions and CryptoHandshakeMessage.
-class QUIC_EXPORT_PRIVATE QuicFixedUint62 : public QuicConfigValue {
+class QUICHE_EXPORT QuicFixedUint62 : public QuicConfigValue {
public:
QuicFixedUint62(QuicTag name, QuicConfigPresence presence);
~QuicFixedUint62() override;
@@ -135,8 +135,7 @@
// Stores StatelessResetToken from CHLO or SHLO messages that are not
// negotiated.
-class QUIC_EXPORT_PRIVATE QuicFixedStatelessResetToken
- : public QuicConfigValue {
+class QUICHE_EXPORT QuicFixedStatelessResetToken : public QuicConfigValue {
public:
QuicFixedStatelessResetToken(QuicTag tag, QuicConfigPresence presence);
~QuicFixedStatelessResetToken() override;
@@ -169,7 +168,7 @@
};
// Stores tag from CHLO or SHLO messages that are not negotiated.
-class QUIC_EXPORT_PRIVATE QuicFixedTagVector : public QuicConfigValue {
+class QUICHE_EXPORT QuicFixedTagVector : public QuicConfigValue {
public:
QuicFixedTagVector(QuicTag name, QuicConfigPresence presence);
QuicFixedTagVector(const QuicFixedTagVector& other);
@@ -205,7 +204,7 @@
};
// Stores QuicSocketAddress from CHLO or SHLO messages that are not negotiated.
-class QUIC_EXPORT_PRIVATE QuicFixedSocketAddress : public QuicConfigValue {
+class QUICHE_EXPORT QuicFixedSocketAddress : public QuicConfigValue {
public:
QuicFixedSocketAddress(QuicTag tag, QuicConfigPresence presence);
~QuicFixedSocketAddress() override;
@@ -239,7 +238,7 @@
// QuicConfig contains non-crypto configuration options that are negotiated in
// the crypto handshake.
-class QUIC_EXPORT_PRIVATE QuicConfig {
+class QUICHE_EXPORT QuicConfig {
public:
QuicConfig();
QuicConfig(const QuicConfig& other);
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 60dab8c..60a3432 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -75,7 +75,7 @@
// Class that receives callbacks from the connection when the path context is
// available.
-class QUIC_EXPORT_PRIVATE MultiPortPathContextObserver {
+class QUICHE_EXPORT MultiPortPathContextObserver {
public:
virtual void OnMultiPortPathContextAvailable(
std::unique_ptr<QuicPathValidationContext>) = 0;
@@ -85,7 +85,7 @@
// Class that receives callbacks from the connection when frames are received
// and when other interesting events happen.
-class QUIC_EXPORT_PRIVATE QuicConnectionVisitorInterface {
+class QUICHE_EXPORT QuicConnectionVisitorInterface {
public:
virtual ~QuicConnectionVisitorInterface() {}
@@ -271,7 +271,7 @@
// Interface which gets callbacks from the QuicConnection at interesting
// points. Implementations must not mutate the state of the connection
// as a result of these callbacks.
-class QUIC_EXPORT_PRIVATE QuicConnectionDebugVisitor
+class QUICHE_EXPORT QuicConnectionDebugVisitor
: public QuicSentPacketManager::DebugDelegate {
public:
~QuicConnectionDebugVisitor() override {}
@@ -465,7 +465,7 @@
absl::string_view /*client_hello*/) {}
};
-class QUIC_EXPORT_PRIVATE QuicConnectionHelperInterface {
+class QUICHE_EXPORT QuicConnectionHelperInterface {
public:
virtual ~QuicConnectionHelperInterface() {}
@@ -479,7 +479,7 @@
virtual quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() = 0;
};
-class QUIC_EXPORT_PRIVATE QuicConnection
+class QUICHE_EXPORT QuicConnection
: public QuicFramerVisitorInterface,
public QuicBlockedWriterInterface,
public QuicPacketCreator::DelegateInterface,
@@ -963,7 +963,7 @@
// pending. In addition, this flusher can be configured to ensure that an ACK
// frame is included in the first packet created, if there's new ack
// information to be sent.
- class QUIC_EXPORT_PRIVATE ScopedPacketFlusher {
+ class QUICHE_EXPORT ScopedPacketFlusher {
public:
explicit ScopedPacketFlusher(QuicConnection* connection);
~ScopedPacketFlusher();
@@ -977,7 +977,7 @@
const bool handshake_packet_sent_;
};
- class QUIC_EXPORT_PRIVATE ScopedEncryptionLevelContext {
+ class QUICHE_EXPORT ScopedEncryptionLevelContext {
public:
ScopedEncryptionLevelContext(QuicConnection* connection,
EncryptionLevel level);
@@ -1450,12 +1450,12 @@
kMaxValue,
};
- struct QUIC_EXPORT_PRIVATE PendingPathChallenge {
+ struct QUICHE_EXPORT PendingPathChallenge {
QuicPathFrameBuffer received_path_challenge;
QuicSocketAddress peer_address;
};
- struct QUIC_EXPORT_PRIVATE PathState {
+ struct QUICHE_EXPORT PathState {
PathState() = default;
PathState(const QuicSocketAddress& alternative_self_address,
@@ -1509,7 +1509,7 @@
// addresses) of those packets which are serialized but failed to send because
// socket is blocked. From unacked packet map and send algorithm's
// perspective, buffered packets are treated as sent.
- struct QUIC_EXPORT_PRIVATE BufferedPacket {
+ struct QUICHE_EXPORT BufferedPacket {
BufferedPacket(const SerializedPacket& packet,
const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
@@ -1539,7 +1539,7 @@
// ReceivedPacketInfo comprises the received packet information.
// TODO(fayang): move more fields to ReceivedPacketInfo.
- struct QUIC_EXPORT_PRIVATE ReceivedPacketInfo {
+ struct QUICHE_EXPORT ReceivedPacketInfo {
explicit ReceivedPacketInfo(QuicTime receipt_time);
ReceivedPacketInfo(const QuicSocketAddress& destination_address,
const QuicSocketAddress& source_address,
@@ -1565,12 +1565,12 @@
QuicSocketAddress actual_destination_address;
};
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
+ QUICHE_EXPORT friend std::ostream& operator<<(
std::ostream& os, const QuicConnection::ReceivedPacketInfo& info);
// UndecrytablePacket comprises a undecryptable packet and related
// information.
- struct QUIC_EXPORT_PRIVATE UndecryptablePacket {
+ struct QUICHE_EXPORT UndecryptablePacket {
UndecryptablePacket(const QuicEncryptedPacket& packet,
EncryptionLevel encryption_level,
const ReceivedPacketInfo& packet_info)
@@ -1642,7 +1642,7 @@
// A class which sets and clears in_probe_time_out_ when entering
// and exiting OnRetransmissionTimeout, respectively.
- class QUIC_EXPORT_PRIVATE ScopedRetransmissionTimeoutIndicator {
+ class QUICHE_EXPORT ScopedRetransmissionTimeoutIndicator {
public:
// |connection| must outlive this indicator.
explicit ScopedRetransmissionTimeoutIndicator(QuicConnection* connection);
diff --git a/quiche/quic/core/quic_connection_context.h b/quiche/quic/core/quic_connection_context.h
index 72d6b66..e5b2a4d 100644
--- a/quiche/quic/core/quic_connection_context.h
+++ b/quiche/quic/core/quic_connection_context.h
@@ -15,7 +15,7 @@
// QuicConnectionTracer is responsible for emit trace messages for a single
// QuicConnection.
// QuicConnectionTracer is part of the QuicConnectionContext.
-class QUIC_EXPORT_PRIVATE QuicConnectionTracer {
+class QUICHE_EXPORT QuicConnectionTracer {
public:
virtual ~QuicConnectionTracer() = default;
@@ -54,7 +54,7 @@
// QuicBugListener is a helper class for implementing QUIC_BUG. The QUIC_BUG
// implementation can send the bug information into quic::CurrentBugListener().
-class QUIC_EXPORT_PRIVATE QuicBugListener {
+class QUICHE_EXPORT QuicBugListener {
public:
virtual ~QuicBugListener() = default;
virtual void OnQuicBug(const char* bug_id, const char* file, int line,
@@ -64,7 +64,7 @@
// QuicConnectionProcessPacketContext is a member of QuicConnectionContext that
// contains information of the packet currently being processed by the owning
// QuicConnection.
-struct QUIC_EXPORT_PRIVATE QuicConnectionProcessPacketContext final {
+struct QUICHE_EXPORT QuicConnectionProcessPacketContext final {
// If !empty(), the decrypted payload of the packet currently being processed.
absl::string_view decrypted_payload;
@@ -88,7 +88,7 @@
//
// Like QuicConnection, all facilities in QuicConnectionContext are assumed to
// be called from a single thread at a time, they are NOT thread-safe.
-struct QUIC_EXPORT_PRIVATE QuicConnectionContext final {
+struct QUICHE_EXPORT QuicConnectionContext final {
// Get the context on the current executing thread. nullptr if the current
// function is not called from a 'top-level' QuicConnection function.
static QuicConnectionContext* Current();
@@ -102,7 +102,7 @@
// QuicConnectionContextSwitcher is a RAII object used for maintaining the
// thread-local QuicConnectionContext pointer.
-class QUIC_EXPORT_PRIVATE QuicConnectionContextSwitcher final {
+class QUICHE_EXPORT QuicConnectionContextSwitcher final {
public:
// The constructor switches from QuicConnectionContext::Current() to
// |new_context|.
diff --git a/quiche/quic/core/quic_connection_id.h b/quiche/quic/core/quic_connection_id.h
index b4e25fe..2e6e035 100644
--- a/quiche/quic/core/quic_connection_id.h
+++ b/quiche/quic/core/quic_connection_id.h
@@ -37,7 +37,7 @@
// the client must be at least this long.
const uint8_t kQuicMinimumInitialConnectionIdLength = 8;
-class QUIC_EXPORT_PRIVATE QuicConnectionId {
+class QUICHE_EXPORT QuicConnectionId {
public:
// Creates a connection ID of length zero.
QuicConnectionId();
@@ -86,8 +86,8 @@
std::string ToString() const;
// operator<< allows easily logging connection IDs.
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicConnectionId& v);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicConnectionId& v);
bool operator==(const QuicConnectionId& v) const;
bool operator!=(const QuicConnectionId& v) const;
@@ -118,7 +118,7 @@
// Creates a connection ID of length zero, unless the restart flag
// quic_connection_ids_network_byte_order is false in which case
// it returns an 8-byte all-zeroes connection ID.
-QUIC_EXPORT_PRIVATE QuicConnectionId EmptyQuicConnectionId();
+QUICHE_EXPORT QuicConnectionId EmptyQuicConnectionId();
// QuicConnectionIdHash can be passed as hash argument to hash tables.
// During the lifetime of a process, the output of QuicConnectionIdHash is
@@ -126,7 +126,7 @@
// Note however that this property is not guaranteed across process lifetimes.
// This makes QuicConnectionIdHash suitable for data structures such as hash
// tables but not for sending a hash over the network.
-class QUIC_EXPORT_PRIVATE QuicConnectionIdHash {
+class QUICHE_EXPORT QuicConnectionIdHash {
public:
size_t operator()(QuicConnectionId const& connection_id) const noexcept {
return connection_id.Hash();
diff --git a/quiche/quic/core/quic_connection_id_manager.h b/quiche/quic/core/quic_connection_id_manager.h
index dfc7e11..96c4c97 100644
--- a/quiche/quic/core/quic_connection_id_manager.h
+++ b/quiche/quic/core/quic_connection_id_manager.h
@@ -31,7 +31,7 @@
class QuicConnectionIdManagerPeer;
} // namespace test
-struct QUIC_EXPORT_PRIVATE QuicConnectionIdData {
+struct QUICHE_EXPORT QuicConnectionIdData {
QuicConnectionIdData(const QuicConnectionId& connection_id,
uint64_t sequence_number,
const StatelessResetToken& stateless_reset_token);
@@ -43,7 +43,7 @@
// Used by QuicSelfIssuedConnectionIdManager
// and QuicPeerIssuedConnectionIdManager.
-class QUIC_EXPORT_PRIVATE QuicConnectionIdManagerVisitorInterface {
+class QUICHE_EXPORT QuicConnectionIdManagerVisitorInterface {
public:
virtual ~QuicConnectionIdManagerVisitorInterface() = default;
virtual void OnPeerIssuedConnectionIdRetired() = 0;
@@ -54,7 +54,7 @@
const QuicConnectionId& connection_id) = 0;
};
-class QUIC_EXPORT_PRIVATE QuicPeerIssuedConnectionIdManager {
+class QUICHE_EXPORT QuicPeerIssuedConnectionIdManager {
public:
// QuicPeerIssuedConnectionIdManager should be instantiated only when a peer
// issued-non empty connection ID is received.
@@ -121,7 +121,7 @@
uint64_t max_new_connection_id_frame_retire_prior_to_ = 0u;
};
-class QUIC_EXPORT_PRIVATE QuicSelfIssuedConnectionIdManager {
+class QUICHE_EXPORT QuicSelfIssuedConnectionIdManager {
public:
QuicSelfIssuedConnectionIdManager(
size_t active_connection_id_limit,
diff --git a/quiche/quic/core/quic_connection_stats.h b/quiche/quic/core/quic_connection_stats.h
index 1088e81..5551659 100644
--- a/quiche/quic/core/quic_connection_stats.h
+++ b/quiche/quic/core/quic_connection_stats.h
@@ -17,9 +17,9 @@
namespace quic {
// Structure to hold stats for a QuicConnection.
-struct QUIC_EXPORT_PRIVATE QuicConnectionStats {
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
- std::ostream& os, const QuicConnectionStats& s);
+struct QUICHE_EXPORT QuicConnectionStats {
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicConnectionStats& s);
QuicByteCount bytes_sent = 0; // Includes retransmissions.
QuicPacketCount packets_sent = 0;
@@ -236,7 +236,7 @@
// address while the validation is pending.
size_t num_duplicated_packets_sent_to_server_preferred_address = 0;
- struct QUIC_NO_EXPORT TlsServerOperationStats {
+ struct QUICHE_EXPORT TlsServerOperationStats {
bool success = false;
// If the operation is performed asynchronously, how long did it take.
// Zero() for synchronous operations.
diff --git a/quiche/quic/core/quic_constants.h b/quiche/quic/core/quic_constants.h
index dfd908e..aa73535 100644
--- a/quiche/quic/core/quic_constants.h
+++ b/quiche/quic/core/quic_constants.h
@@ -129,7 +129,7 @@
// Header key used to identify final offset on data stream when sending HTTP/2
// trailing headers over QUIC.
-QUIC_EXPORT_PRIVATE extern const char* const kFinalOffsetHeaderKey;
+QUICHE_EXPORT extern const char* const kFinalOffsetHeaderKey;
// Default maximum delayed ack time, in ms.
// Uses a 25ms delayed ack timer. Helps with better signaling
@@ -247,7 +247,7 @@
// For When using Random Initial Packet Numbers, they can start
// anyplace in the range 1...((2^31)-1) or 0x7fffffff
-QUIC_EXPORT_PRIVATE QuicPacketNumber MaxRandomInitialPacketNumber();
+QUICHE_EXPORT QuicPacketNumber MaxRandomInitialPacketNumber();
// Used to represent an invalid or no control frame id.
inline constexpr QuicControlFrameId kInvalidControlFrameId = 0;
@@ -313,11 +313,11 @@
// Packet number of first sending packet of a connection. Please note, this
// cannot be used as first received packet because peer can choose its starting
// packet number.
-QUIC_EXPORT_PRIVATE QuicPacketNumber FirstSendingPacketNumber();
+QUICHE_EXPORT QuicPacketNumber FirstSendingPacketNumber();
// Used by clients to tell if a public reset is sent from a Google frontend.
-QUIC_EXPORT_PRIVATE extern const char* const kEPIDGoogleFrontEnd;
-QUIC_EXPORT_PRIVATE extern const char* const kEPIDGoogleFrontEnd0;
+QUICHE_EXPORT extern const char* const kEPIDGoogleFrontEnd;
+QUICHE_EXPORT extern const char* const kEPIDGoogleFrontEnd0;
inline constexpr uint64_t kHttpDatagramStreamIdDivisor = 4;
diff --git a/quiche/quic/core/quic_control_frame_manager.h b/quiche/quic/core/quic_control_frame_manager.h
index 46a0f47..0a40b20 100644
--- a/quiche/quic/core/quic_control_frame_manager.h
+++ b/quiche/quic/core/quic_control_frame_manager.h
@@ -33,9 +33,9 @@
// the generator. Control frames are removed from the head of the list when they
// get acked. Control frame manager also keeps track of lost control frames
// which need to be retransmitted.
-class QUIC_EXPORT_PRIVATE QuicControlFrameManager {
+class QUICHE_EXPORT QuicControlFrameManager {
public:
- class QUIC_EXPORT_PRIVATE DelegateInterface {
+ class QUICHE_EXPORT DelegateInterface {
public:
virtual ~DelegateInterface() = default;
diff --git a/quiche/quic/core/quic_crypto_client_handshaker.h b/quiche/quic/core/quic_crypto_client_handshaker.h
index b046405..8e9ef05 100644
--- a/quiche/quic/core/quic_crypto_client_handshaker.h
+++ b/quiche/quic/core/quic_crypto_client_handshaker.h
@@ -19,7 +19,7 @@
// An implementation of QuicCryptoClientStream::HandshakerInterface which uses
// QUIC crypto as the crypto handshake protocol.
-class QUIC_EXPORT_PRIVATE QuicCryptoClientHandshaker
+class QUICHE_EXPORT QuicCryptoClientHandshaker
: public QuicCryptoClientStream::HandshakerInterface,
public QuicCryptoHandshaker {
public:
@@ -90,8 +90,7 @@
// ProofVerifierCallbackImpl is passed as the callback method to VerifyProof.
// The ProofVerifier calls this class with the result of proof verification
// when verification is performed asynchronously.
- class QUIC_EXPORT_PRIVATE ProofVerifierCallbackImpl
- : public ProofVerifierCallback {
+ class QUICHE_EXPORT ProofVerifierCallbackImpl : public ProofVerifierCallback {
public:
explicit ProofVerifierCallbackImpl(QuicCryptoClientHandshaker* parent);
~ProofVerifierCallbackImpl() override;
diff --git a/quiche/quic/core/quic_crypto_client_stream.h b/quiche/quic/core/quic_crypto_client_stream.h
index ab62b35..1805289 100644
--- a/quiche/quic/core/quic_crypto_client_stream.h
+++ b/quiche/quic/core/quic_crypto_client_stream.h
@@ -29,7 +29,7 @@
class TlsClientHandshaker;
-class QUIC_EXPORT_PRIVATE QuicCryptoClientStreamBase : public QuicCryptoStream {
+class QUICHE_EXPORT QuicCryptoClientStreamBase : public QuicCryptoStream {
public:
explicit QuicCryptoClientStreamBase(QuicSession* session);
@@ -101,8 +101,7 @@
}
};
-class QUIC_EXPORT_PRIVATE QuicCryptoClientStream
- : public QuicCryptoClientStreamBase {
+class QUICHE_EXPORT QuicCryptoClientStream : public QuicCryptoClientStreamBase {
public:
// kMaxClientHellos is the maximum number of times that we'll send a client
// hello. The value 4 accounts for:
@@ -126,7 +125,7 @@
// This setup of the crypto stream delegating its implementation to the
// handshaker results in the handshaker reading and writing bytes on the
// crypto stream, instead of the handshaker passing the stream bytes to send.
- class QUIC_EXPORT_PRIVATE HandshakerInterface {
+ class QUICHE_EXPORT HandshakerInterface {
public:
virtual ~HandshakerInterface() {}
@@ -240,7 +239,7 @@
// ProofHandler is an interface that handles callbacks from the crypto
// stream when the client has proof verification details of the server.
- class QUIC_EXPORT_PRIVATE ProofHandler {
+ class QUICHE_EXPORT ProofHandler {
public:
virtual ~ProofHandler() {}
diff --git a/quiche/quic/core/quic_crypto_handshaker.h b/quiche/quic/core/quic_crypto_handshaker.h
index 526dbd5..f13c574 100644
--- a/quiche/quic/core/quic_crypto_handshaker.h
+++ b/quiche/quic/core/quic_crypto_handshaker.h
@@ -10,8 +10,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicCryptoHandshaker
- : public CryptoFramerVisitorInterface {
+class QUICHE_EXPORT QuicCryptoHandshaker : public CryptoFramerVisitorInterface {
public:
QuicCryptoHandshaker(QuicCryptoStream* stream, QuicSession* session);
QuicCryptoHandshaker(const QuicCryptoHandshaker&) = delete;
diff --git a/quiche/quic/core/quic_crypto_server_stream.h b/quiche/quic/core/quic_crypto_server_stream.h
index 665d071..49c9cc2 100644
--- a/quiche/quic/core/quic_crypto_server_stream.h
+++ b/quiche/quic/core/quic_crypto_server_stream.h
@@ -21,9 +21,8 @@
class QuicCryptoServerStreamPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE QuicCryptoServerStream
- : public QuicCryptoServerStreamBase,
- public QuicCryptoHandshaker {
+class QUICHE_EXPORT QuicCryptoServerStream : public QuicCryptoServerStreamBase,
+ public QuicCryptoHandshaker {
public:
QuicCryptoServerStream(const QuicCryptoServerStream&) = delete;
QuicCryptoServerStream& operator=(const QuicCryptoServerStream&) = delete;
@@ -82,7 +81,7 @@
void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
protected:
- QUIC_EXPORT_PRIVATE friend std::unique_ptr<QuicCryptoServerStreamBase>
+ QUICHE_EXPORT friend std::unique_ptr<QuicCryptoServerStreamBase>
CreateCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicSession* session,
@@ -124,7 +123,7 @@
private:
friend class test::QuicCryptoServerStreamPeer;
- class QUIC_EXPORT_PRIVATE ValidateCallback
+ class QUICHE_EXPORT ValidateCallback
: public ValidateClientHelloResultCallback {
public:
explicit ValidateCallback(QuicCryptoServerStream* parent);
diff --git a/quiche/quic/core/quic_crypto_server_stream_base.h b/quiche/quic/core/quic_crypto_server_stream_base.h
index 84d6190..a388f38 100644
--- a/quiche/quic/core/quic_crypto_server_stream_base.h
+++ b/quiche/quic/core/quic_crypto_server_stream_base.h
@@ -27,11 +27,11 @@
// TODO(alyssar) see what can be moved out of QuicCryptoServerStream with
// various code and test refactoring.
-class QUIC_EXPORT_PRIVATE QuicCryptoServerStreamBase : public QuicCryptoStream {
+class QUICHE_EXPORT QuicCryptoServerStreamBase : public QuicCryptoStream {
public:
explicit QuicCryptoServerStreamBase(QuicSession* session);
- class QUIC_EXPORT_PRIVATE Helper {
+ class QUICHE_EXPORT Helper {
public:
virtual ~Helper() {}
@@ -111,7 +111,7 @@
// including the version used by |session|. |crypto_config|, |session|, and
// |helper| must all outlive the stream. The caller takes ownership of the
// returned object.
-QUIC_EXPORT_PRIVATE std::unique_ptr<QuicCryptoServerStreamBase>
+QUICHE_EXPORT std::unique_ptr<QuicCryptoServerStreamBase>
CreateCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicSession* session,
diff --git a/quiche/quic/core/quic_crypto_stream.h b/quiche/quic/core/quic_crypto_stream.h
index 0be3185..191aa57 100644
--- a/quiche/quic/core/quic_crypto_stream.h
+++ b/quiche/quic/core/quic_crypto_stream.h
@@ -35,7 +35,7 @@
//
// For more details:
// https://docs.google.com/document/d/1g5nIXAIkN_Y-7XJW5K45IblHd_L2f5LTaDUDwvZ5L6g/edit?usp=sharing
-class QUIC_EXPORT_PRIVATE QuicCryptoStream : public QuicStream {
+class QUICHE_EXPORT QuicCryptoStream : public QuicStream {
public:
explicit QuicCryptoStream(QuicSession* session);
QuicCryptoStream(const QuicCryptoStream&) = delete;
@@ -259,7 +259,7 @@
// spaces. Some of the state for the single logical crypto stream is split
// across packet number spaces, and a CryptoSubstream is used to manage that
// state for a particular packet number space.
- struct QUIC_EXPORT_PRIVATE CryptoSubstream {
+ struct QUICHE_EXPORT CryptoSubstream {
CryptoSubstream(QuicCryptoStream* crypto_stream);
QuicStreamSequencer sequencer;
diff --git a/quiche/quic/core/quic_data_reader.h b/quiche/quic/core/quic_data_reader.h
index 0a907e0..8a20681 100644
--- a/quiche/quic/core/quic_data_reader.h
+++ b/quiche/quic/core/quic_data_reader.h
@@ -30,7 +30,7 @@
// trusted and it is up to the caller to throw away the failed instance and
// handle the error as appropriate. None of the Read*() methods should ever be
// called after failure, as they will also fail immediately.
-class QUIC_EXPORT_PRIVATE QuicDataReader : public quiche::QuicheDataReader {
+class QUICHE_EXPORT QuicDataReader : public quiche::QuicheDataReader {
public:
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
diff --git a/quiche/quic/core/quic_data_writer.h b/quiche/quic/core/quic_data_writer.h
index cd2486a..555ba98 100644
--- a/quiche/quic/core/quic_data_writer.h
+++ b/quiche/quic/core/quic_data_writer.h
@@ -22,7 +22,7 @@
// The QuicDataWriter supports appending primitive values (int, string, etc)
// to a frame instance. The internal memory buffer is exposed as the "data"
// of the QuicDataWriter.
-class QUIC_EXPORT_PRIVATE QuicDataWriter : public quiche::QuicheDataWriter {
+class QUICHE_EXPORT QuicDataWriter : public quiche::QuicheDataWriter {
public:
// Creates a QuicDataWriter where |buffer| is not owned
// using NETWORK_BYTE_ORDER endianness.
diff --git a/quiche/quic/core/quic_datagram_queue.h b/quiche/quic/core/quic_datagram_queue.h
index 851cd0a..834ae54 100644
--- a/quiche/quic/core/quic_datagram_queue.h
+++ b/quiche/quic/core/quic_datagram_queue.h
@@ -20,10 +20,10 @@
// Provides a way to buffer QUIC datagrams (messages) in case they cannot
// be sent due to congestion control. Datagrams are buffered for a limited
// amount of time, and deleted after that time passes.
-class QUIC_EXPORT_PRIVATE QuicDatagramQueue {
+class QUICHE_EXPORT QuicDatagramQueue {
public:
// An interface used to monitor events on the associated `QuicDatagramQueue`.
- class QUIC_EXPORT_PRIVATE Observer {
+ class QUICHE_EXPORT Observer {
public:
virtual ~Observer() = default;
@@ -73,7 +73,7 @@
bool empty() { return queue_.empty(); }
private:
- struct QUIC_EXPORT_PRIVATE Datagram {
+ struct QUICHE_EXPORT Datagram {
quiche::QuicheMemSlice datagram;
QuicTime expiry;
};
diff --git a/quiche/quic/core/quic_default_clock.h b/quiche/quic/core/quic_default_clock.h
index 64b89dd..967ef8e 100644
--- a/quiche/quic/core/quic_default_clock.h
+++ b/quiche/quic/core/quic_default_clock.h
@@ -12,7 +12,7 @@
namespace quic {
// A QuicClock based on Abseil time API. Thread-safe.
-class QUIC_EXPORT_PRIVATE QuicDefaultClock : public QuicClock {
+class QUICHE_EXPORT QuicDefaultClock : public QuicClock {
public:
// Provides a single default stateless instance of QuicDefaultClock.
static QuicDefaultClock* Get();
diff --git a/quiche/quic/core/quic_default_connection_helper.h b/quiche/quic/core/quic_default_connection_helper.h
index 3a10b43..c8ce689 100644
--- a/quiche/quic/core/quic_default_connection_helper.h
+++ b/quiche/quic/core/quic_default_connection_helper.h
@@ -13,7 +13,7 @@
namespace quic {
// A default implementation of QuicConnectionHelperInterface. Thread-safe.
-class QUIC_EXPORT_PRIVATE QuicDefaultConnectionHelper
+class QUICHE_EXPORT QuicDefaultConnectionHelper
: public QuicConnectionHelperInterface {
public:
static QuicDefaultConnectionHelper* Get() {
diff --git a/quiche/quic/core/quic_default_packet_writer.h b/quiche/quic/core/quic_default_packet_writer.h
index 1235e49..ab41c91 100644
--- a/quiche/quic/core/quic_default_packet_writer.h
+++ b/quiche/quic/core/quic_default_packet_writer.h
@@ -17,7 +17,7 @@
struct WriteResult;
// Default packet writer which wraps QuicSocketUtils WritePacket.
-class QUIC_EXPORT_PRIVATE QuicDefaultPacketWriter : public QuicPacketWriter {
+class QUICHE_EXPORT QuicDefaultPacketWriter : public QuicPacketWriter {
public:
explicit QuicDefaultPacketWriter(SocketFd fd);
QuicDefaultPacketWriter(const QuicDefaultPacketWriter&) = delete;
diff --git a/quiche/quic/core/quic_dispatcher.h b/quiche/quic/core/quic_dispatcher.h
index 0c0fa9d..7f06b78 100644
--- a/quiche/quic/core/quic_dispatcher.h
+++ b/quiche/quic/core/quic_dispatcher.h
@@ -52,7 +52,7 @@
class QuicConfig;
class QuicCryptoServerConfig;
-class QUIC_NO_EXPORT QuicDispatcher
+class QUICHE_EXPORT QuicDispatcher
: public QuicTimeWaitListManager::Visitor,
public ProcessPacketInterface,
public QuicBufferedPacketStore::VisitorInterface {
diff --git a/quiche/quic/core/quic_error_codes.h b/quiche/quic/core/quic_error_codes.h
index 2db245e..6f94da5 100644
--- a/quiche/quic/core/quic_error_codes.h
+++ b/quiche/quic/core/quic_error_codes.h
@@ -665,7 +665,7 @@
// Represents a reason for resetting a stream in both gQUIC and IETF error code
// space. Both error codes have to be present.
-class QUIC_EXPORT_PRIVATE QuicResetStreamError {
+class QUICHE_EXPORT QuicResetStreamError {
public:
// Constructs a QuicResetStreamError from QuicRstStreamErrorCode; the IETF
// error code is inferred.
@@ -705,14 +705,14 @@
};
// Convert TLS alert code to QuicErrorCode.
-QUIC_EXPORT_PRIVATE QuicErrorCode TlsAlertToQuicErrorCode(uint8_t desc);
+QUICHE_EXPORT QuicErrorCode TlsAlertToQuicErrorCode(uint8_t desc);
// Returns the name of the QuicRstStreamErrorCode as a char*
-QUIC_EXPORT_PRIVATE const char* QuicRstStreamErrorCodeToString(
+QUICHE_EXPORT const char* QuicRstStreamErrorCodeToString(
QuicRstStreamErrorCode error);
// Returns the name of the QuicErrorCode as a char*
-QUIC_EXPORT_PRIVATE const char* QuicErrorCodeToString(QuicErrorCode error);
+QUICHE_EXPORT const char* QuicErrorCodeToString(QuicErrorCode error);
// Wire values for QUIC transport errors.
// https://quicwg.org/base-drafts/draft-ietf-quic-transport.html#name-transport-error-codes
@@ -736,40 +736,39 @@
CRYPTO_ERROR_LAST = 0x1FF,
};
-QUIC_EXPORT_PRIVATE std::string QuicIetfTransportErrorCodeString(
+QUICHE_EXPORT std::string QuicIetfTransportErrorCodeString(
QuicIetfTransportErrorCodes c);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicIetfTransportErrorCodes& c);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicIetfTransportErrorCodes& c);
// A transport error code (if is_transport_close is true) or application error
// code (if is_transport_close is false) to be used in CONNECTION_CLOSE frames.
-struct QUIC_EXPORT_PRIVATE QuicErrorCodeToIetfMapping {
+struct QUICHE_EXPORT QuicErrorCodeToIetfMapping {
bool is_transport_close;
uint64_t error_code;
};
// Convert QuicErrorCode to transport or application IETF error code
// to be used in CONNECTION_CLOSE frames.
-QUIC_EXPORT_PRIVATE QuicErrorCodeToIetfMapping
+QUICHE_EXPORT QuicErrorCodeToIetfMapping
QuicErrorCodeToTransportErrorCode(QuicErrorCode error);
// Convert a QuicRstStreamErrorCode to an application error code to be used in
// an IETF QUIC RESET_STREAM frame
-QUIC_EXPORT_PRIVATE uint64_t RstStreamErrorCodeToIetfResetStreamErrorCode(
+QUICHE_EXPORT uint64_t RstStreamErrorCodeToIetfResetStreamErrorCode(
QuicRstStreamErrorCode rst_stream_error_code);
// Convert the application error code of an IETF QUIC RESET_STREAM frame
// to QuicRstStreamErrorCode.
-QUIC_EXPORT_PRIVATE QuicRstStreamErrorCode
+QUICHE_EXPORT QuicRstStreamErrorCode
IetfResetStreamErrorCodeToRstStreamErrorCode(uint64_t ietf_error_code);
-QUIC_EXPORT_PRIVATE inline std::string HistogramEnumString(
- QuicErrorCode enum_value) {
+QUICHE_EXPORT inline std::string HistogramEnumString(QuicErrorCode enum_value) {
return QuicErrorCodeToString(enum_value);
}
-QUIC_EXPORT_PRIVATE inline std::string HistogramEnumDescription(
+QUICHE_EXPORT inline std::string HistogramEnumDescription(
QuicErrorCode /*dummy*/) {
return "cause";
}
diff --git a/quiche/quic/core/quic_flow_controller.h b/quiche/quic/core/quic_flow_controller.h
index eaf660a..8bd43c2 100644
--- a/quiche/quic/core/quic_flow_controller.h
+++ b/quiche/quic/core/quic_flow_controller.h
@@ -21,7 +21,7 @@
// stream's flow control window.
const float kSessionFlowControlMultiplier = 1.5;
-class QUIC_EXPORT_PRIVATE QuicFlowControllerInterface {
+class QUICHE_EXPORT QuicFlowControllerInterface {
public:
virtual ~QuicFlowControllerInterface() {}
@@ -34,8 +34,7 @@
// control. The stream/connection owns a QuicFlowController which keeps track of
// bytes sent/received, can tell the owner if it is flow control blocked, and
// can send WINDOW_UPDATE or BLOCKED frames when needed.
-class QUIC_EXPORT_PRIVATE QuicFlowController
- : public QuicFlowControllerInterface {
+class QUICHE_EXPORT QuicFlowController : public QuicFlowControllerInterface {
public:
QuicFlowController(QuicSession* session, QuicStreamId id,
bool is_connection_flow_controller,
diff --git a/quiche/quic/core/quic_framer.h b/quiche/quic/core/quic_framer.h
index bf73ac8..c173925 100644
--- a/quiche/quic/core/quic_framer.h
+++ b/quiche/quic/core/quic_framer.h
@@ -66,7 +66,7 @@
// This class receives callbacks from the framer when packets
// are processed.
-class QUIC_EXPORT_PRIVATE QuicFramerVisitorInterface {
+class QUICHE_EXPORT QuicFramerVisitorInterface {
public:
virtual ~QuicFramerVisitorInterface() {}
@@ -261,7 +261,7 @@
// Class for parsing and constructing QUIC packets. It has a
// QuicFramerVisitorInterface that is called when packets are parsed.
-class QUIC_EXPORT_PRIVATE QuicFramer {
+class QUICHE_EXPORT QuicFramer {
public:
// Constructs a new framer that installs a kNULL QuicEncrypter and
// QuicDecrypter for level ENCRYPTION_INITIAL. |supported_versions| specifies
@@ -731,7 +731,7 @@
// AckTimestampRange is a data structure derived from a QuicAckFrame. It is
// used to serialize timestamps in a IETF_ACK_RECEIVE_TIMESTAMPS frame.
- struct QUIC_EXPORT_PRIVATE AckTimestampRange {
+ struct QUICHE_EXPORT AckTimestampRange {
QuicPacketCount gap;
// |range_begin| and |range_end| are index(es) in
// QuicAckFrame.received_packet_times, representing a continuous range of
@@ -746,7 +746,7 @@
const absl::InlinedVector<AckTimestampRange, 2>& timestamp_ranges,
QuicDataWriter* writer) const;
- struct QUIC_EXPORT_PRIVATE AckFrameInfo {
+ struct QUICHE_EXPORT AckFrameInfo {
AckFrameInfo();
AckFrameInfo(const AckFrameInfo& other);
~AckFrameInfo();
@@ -1198,8 +1198,7 @@
// frame->quic_error_code is set to
// QuicErrorCode::QUIC_IETF_GQUIC_ERROR_MISSING. If there is an error code in
// the string then it is removed from the string.
-QUIC_EXPORT_PRIVATE void MaybeExtractQuicErrorCode(
- QuicConnectionCloseFrame* frame);
+QUICHE_EXPORT void MaybeExtractQuicErrorCode(QuicConnectionCloseFrame* frame);
} // namespace quic
diff --git a/quiche/quic/core/quic_generic_session.cc b/quiche/quic/core/quic_generic_session.cc
index 5b603c3..64e469c 100644
--- a/quiche/quic/core/quic_generic_session.cc
+++ b/quiche/quic/core/quic_generic_session.cc
@@ -50,7 +50,7 @@
// QuicGenericStream is a stream that provides a general-purpose implementation
// of a webtransport::Stream interface.
-class QUIC_EXPORT_PRIVATE QuicGenericStream : public QuicStream {
+class QUICHE_EXPORT QuicGenericStream : public QuicStream {
public:
QuicGenericStream(QuicStreamId id, QuicSession* session)
: QuicStream(id, session, /*is_static=*/false,
diff --git a/quiche/quic/core/quic_idle_network_detector.h b/quiche/quic/core/quic_idle_network_detector.h
index ca43148..bf13d62 100644
--- a/quiche/quic/core/quic_idle_network_detector.h
+++ b/quiche/quic/core/quic_idle_network_detector.h
@@ -23,9 +23,9 @@
// Handshake timeout detection is disabled after handshake completes. Idle
// network deadline is extended by network activity (e.g., sending or receiving
// packets).
-class QUIC_EXPORT_PRIVATE QuicIdleNetworkDetector {
+class QUICHE_EXPORT QuicIdleNetworkDetector {
public:
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/quic_interval.h b/quiche/quic/core/quic_interval.h
index e291c53..3ce58a9 100644
--- a/quiche/quic/core/quic_interval.h
+++ b/quiche/quic/core/quic_interval.h
@@ -69,14 +69,14 @@
namespace quic {
template <typename T>
-class QUIC_NO_EXPORT QuicInterval {
+class QUICHE_EXPORT QuicInterval {
private:
// Type trait for deriving the return type for QuicInterval::Length. If
// operator-() is not defined for T, then the return type is void. This makes
// the signature for Length compile so that the class can be used for such T,
// but code that calls Length would still generate a compilation error.
template <typename U>
- class QUIC_NO_EXPORT DiffTypeOrVoid {
+ class QUICHE_EXPORT DiffTypeOrVoid {
private:
template <typename V>
static auto f(const V* v) -> decltype(*v - *v);
diff --git a/quiche/quic/core/quic_interval_deque.h b/quiche/quic/core/quic_interval_deque.h
index ed13e7a..45b3bcb 100644
--- a/quiche/quic/core/quic_interval_deque.h
+++ b/quiche/quic/core/quic_interval_deque.h
@@ -138,9 +138,9 @@
// // container -> {{2, [25, 30)}, {3, [35, 50)}}
template <class T, class C = quiche::QuicheCircularDeque<T>>
-class QUIC_NO_EXPORT QuicIntervalDeque {
+class QUICHE_EXPORT QuicIntervalDeque {
public:
- class QUIC_NO_EXPORT Iterator {
+ class QUICHE_EXPORT Iterator {
public:
// Used by |std::lower_bound|
using iterator_category = std::forward_iterator_tag;
@@ -243,7 +243,7 @@
bool Empty() const;
private:
- struct QUIC_NO_EXPORT IntervalCompare {
+ struct QUICHE_EXPORT IntervalCompare {
bool operator()(const T& item, std::size_t interval_begin) const {
return item.interval().max() <= interval_begin;
}
diff --git a/quiche/quic/core/quic_interval_set.h b/quiche/quic/core/quic_interval_set.h
index 11d0270..723d106 100644
--- a/quiche/quic/core/quic_interval_set.h
+++ b/quiche/quic/core/quic_interval_set.h
@@ -68,12 +68,12 @@
namespace quic {
template <typename T>
-class QUIC_NO_EXPORT QuicIntervalSet {
+class QUICHE_EXPORT QuicIntervalSet {
public:
using value_type = QuicInterval<T>;
private:
- struct QUIC_NO_EXPORT IntervalLess {
+ struct QUICHE_EXPORT IntervalLess {
using is_transparent = void;
bool operator()(const value_type& a, const value_type& b) const;
// These transparent overloads are used when we do all of our searches (via
@@ -386,7 +386,7 @@
private:
// Simple member-wise equality, since all intervals are non-empty.
- struct QUIC_NO_EXPORT NonemptyIntervalEq {
+ struct QUICHE_EXPORT NonemptyIntervalEq {
bool operator()(const value_type& a, const value_type& b) const {
return a.min() == b.min() && a.max() == b.max();
}
diff --git a/quiche/quic/core/quic_linux_socket_utils.h b/quiche/quic/core/quic_linux_socket_utils.h
index 36c2dd7..a1e725b 100644
--- a/quiche/quic/core/quic_linux_socket_utils.h
+++ b/quiche/quic/core/quic_linux_socket_utils.h
@@ -75,7 +75,7 @@
// *hdr.GetNextCmsgData<uint16_t>(SOL_UDP, UDP_SEGMENT) = 1200;
//
// QuicLinuxSocketUtils::WritePacket(fd, hdr);
-class QUIC_EXPORT_PRIVATE QuicMsgHdr {
+class QUICHE_EXPORT QuicMsgHdr {
public:
QuicMsgHdr(const char* buffer, size_t buf_len,
const QuicSocketAddress& peer_address, char* cbuf,
@@ -106,7 +106,7 @@
};
// BufferedWrite holds all information needed to send a packet.
-struct QUIC_EXPORT_PRIVATE BufferedWrite {
+struct QUICHE_EXPORT BufferedWrite {
BufferedWrite(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address)
@@ -157,7 +157,7 @@
//
// int num_packets_sent;
// QuicSocketUtils::WriteMultiplePackets(fd, &mhdr, &num_packets_sent);
-class QUIC_EXPORT_PRIVATE QuicMMsgHdr {
+class QUICHE_EXPORT QuicMMsgHdr {
public:
using ControlBufferInitializer = quiche::UnretainedCallback<void(
QuicMMsgHdr* mhdr, int i, const BufferedWrite& buffered_write)>;
@@ -253,7 +253,7 @@
std::unique_ptr<char[]> storage_;
};
-class QUIC_EXPORT_PRIVATE QuicLinuxSocketUtils {
+class QUICHE_EXPORT QuicLinuxSocketUtils {
public:
// Return the UDP segment size of |fd|, 0 means segment size has not been set
// on this socket. If GSO is not supported, return -1.
diff --git a/quiche/quic/core/quic_lru_cache.h b/quiche/quic/core/quic_lru_cache.h
index d1c010e..13616a3 100644
--- a/quiche/quic/core/quic_lru_cache.h
+++ b/quiche/quic/core/quic_lru_cache.h
@@ -21,7 +21,7 @@
// threads.
template <class K, class V, class Hash = std::hash<K>,
class Eq = std::equal_to<K>>
-class QUIC_NO_EXPORT QuicLRUCache {
+class QUICHE_EXPORT QuicLRUCache {
private:
using HashMapType =
typename quiche::QuicheLinkedHashMap<K, std::unique_ptr<V>, Hash, Eq>;
diff --git a/quiche/quic/core/quic_mtu_discovery.h b/quiche/quic/core/quic_mtu_discovery.h
index c44894f..68fbc6d 100644
--- a/quiche/quic/core/quic_mtu_discovery.h
+++ b/quiche/quic/core/quic_mtu_discovery.h
@@ -50,7 +50,7 @@
// Note the discoverer does not actually send or process probing packets.
//
// Unit tests are in QuicConnectionTest.MtuDiscovery*.
-class QUIC_EXPORT_PRIVATE QuicConnectionMtuDiscoverer {
+class QUICHE_EXPORT QuicConnectionMtuDiscoverer {
public:
// Construct a discoverer in the disabled state.
QuicConnectionMtuDiscoverer() = default;
@@ -88,7 +88,7 @@
QuicPacketNumber next_probe_at() const { return next_probe_at_; }
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
+ QUICHE_EXPORT friend std::ostream& operator<<(
std::ostream& os, const QuicConnectionMtuDiscoverer& d);
private:
diff --git a/quiche/quic/core/quic_network_blackhole_detector.h b/quiche/quic/core/quic_network_blackhole_detector.h
index 7defc47..5f7ab87 100644
--- a/quiche/quic/core/quic_network_blackhole_detector.h
+++ b/quiche/quic/core/quic_network_blackhole_detector.h
@@ -24,9 +24,9 @@
// degrading detection mode. After reporting path degrading detected, detector
// switches to blackhole detection mode. So blackhole detection deadline must
// be later than path degrading deadline.
-class QUIC_EXPORT_PRIVATE QuicNetworkBlackholeDetector {
+class QUICHE_EXPORT QuicNetworkBlackholeDetector {
public:
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/quic_one_block_arena.h b/quiche/quic/core/quic_one_block_arena.h
index b416254..4dd9ba3 100644
--- a/quiche/quic/core/quic_one_block_arena.h
+++ b/quiche/quic/core/quic_one_block_arena.h
@@ -21,7 +21,7 @@
namespace quic {
template <uint32_t ArenaSize>
-class QUIC_EXPORT_PRIVATE QuicOneBlockArena {
+class QUICHE_EXPORT QuicOneBlockArena {
static const uint32_t kMaxAlign = 8;
public:
diff --git a/quiche/quic/core/quic_packet_creator.h b/quiche/quic/core/quic_packet_creator.h
index a4af3f6..fcabc9a 100644
--- a/quiche/quic/core/quic_packet_creator.h
+++ b/quiche/quic/core/quic_packet_creator.h
@@ -39,10 +39,10 @@
class QuicPacketCreatorPeer;
}
-class QUIC_EXPORT_PRIVATE QuicPacketCreator {
+class QUICHE_EXPORT QuicPacketCreator {
public:
// A delegate interface for further processing serialized packet.
- class QUIC_EXPORT_PRIVATE DelegateInterface {
+ class QUICHE_EXPORT DelegateInterface {
public:
virtual ~DelegateInterface() {}
// Get a buffer of kMaxOutgoingPacketSize bytes to serialize the next
@@ -74,7 +74,7 @@
// 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 QUIC_EXPORT_PRIVATE DebugDelegate {
+ class QUICHE_EXPORT DebugDelegate {
public:
virtual ~DebugDelegate() {}
@@ -89,7 +89,7 @@
// Set the peer address and connection IDs with which the serialized packet
// will be sent to during the scope of this object. Upon exiting the scope,
// the original peer address and connection IDs are restored.
- class QUIC_EXPORT_PRIVATE ScopedPeerAddressContext {
+ class QUICHE_EXPORT ScopedPeerAddressContext {
public:
ScopedPeerAddressContext(QuicPacketCreator* creator,
QuicSocketAddress address,
@@ -484,7 +484,7 @@
// Used to 1) clear queued_frames_, 2) report unrecoverable error (if
// serialization fails) upon exiting the scope.
- class QUIC_EXPORT_PRIVATE ScopedSerializationFailureHandler {
+ class QUICHE_EXPORT ScopedSerializationFailureHandler {
public:
explicit ScopedSerializationFailureHandler(QuicPacketCreator* creator);
~ScopedSerializationFailureHandler();
diff --git a/quiche/quic/core/quic_packet_number.h b/quiche/quic/core/quic_packet_number.h
index 8d6b1b6..04e7804 100644
--- a/quiche/quic/core/quic_packet_number.h
+++ b/quiche/quic/core/quic_packet_number.h
@@ -17,7 +17,7 @@
// QuicPacketNumber can either initialized or uninitialized. An initialized
// packet number is simply an ordinal number. A sentinel value is used to
// represent an uninitialized packet number.
-class QUIC_EXPORT_PRIVATE QuicPacketNumber {
+class QUICHE_EXPORT QuicPacketNumber {
public:
// Construct an uninitialized packet number.
constexpr QuicPacketNumber() : packet_number_(UninitializedPacketNumber()) {}
@@ -69,8 +69,8 @@
// Human-readable representation suitable for logging.
std::string ToString() const;
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
- std::ostream& os, const QuicPacketNumber& p);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicPacketNumber& p);
private:
// All following operators REQUIRE operands.Initialized() == true.
@@ -93,7 +93,7 @@
uint64_t packet_number_;
};
-class QUIC_EXPORT_PRIVATE QuicPacketNumberHash {
+class QUICHE_EXPORT QuicPacketNumberHash {
public:
uint64_t operator()(QuicPacketNumber packet_number) const noexcept {
return packet_number.Hash();
diff --git a/quiche/quic/core/quic_packet_reader.h b/quiche/quic/core/quic_packet_reader.h
index 6ec2682..c994557 100644
--- a/quiche/quic/core/quic_packet_reader.h
+++ b/quiche/quic/core/quic_packet_reader.h
@@ -20,7 +20,7 @@
// Read in larger batches to minimize recvmmsg overhead.
const int kNumPacketsPerReadMmsgCall = 16;
-class QUIC_EXPORT_PRIVATE QuicPacketReader {
+class QUICHE_EXPORT QuicPacketReader {
public:
QuicPacketReader();
QuicPacketReader(const QuicPacketReader&) = delete;
@@ -47,7 +47,7 @@
static QuicIpAddress GetSelfIpFromPacketInfo(
const QuicUdpPacketInfo& packet_info, bool prefer_v6_ip);
- struct QUIC_EXPORT_PRIVATE ReadBuffer {
+ struct QUICHE_EXPORT ReadBuffer {
ABSL_CACHELINE_ALIGNED char
control_buffer[kDefaultUdpPacketControlBufferSize]; // For ancillary
// data.
diff --git a/quiche/quic/core/quic_packet_writer.h b/quiche/quic/core/quic_packet_writer.h
index c684656..dfca5a8 100644
--- a/quiche/quic/core/quic_packet_writer.h
+++ b/quiche/quic/core/quic_packet_writer.h
@@ -21,7 +21,7 @@
// This class allows a platform to pass instructions to an associated child of
// QuicWriter without intervening QUIC code understanding anything about its
// contents.
-class QUIC_EXPORT_PRIVATE PerPacketOptions {
+class QUICHE_EXPORT PerPacketOptions {
public:
virtual ~PerPacketOptions() {}
@@ -36,7 +36,7 @@
};
// The owner of QuicPacketWriter can pass control information via this struct.
-struct QUIC_EXPORT_PRIVATE QuicPacketWriterParams {
+struct QUICHE_EXPORT QuicPacketWriterParams {
// Specifies ideal release time delay for this packet.
QuicTime::Delta release_time_delay = QuicTime::Delta::Zero();
// Whether it is allowed to send this packet without |release_time_delay|.
@@ -67,7 +67,7 @@
// 1. Call GetNextWriteLocation to get a pointer P into the internal buffer.
// 2. Serialize the packet directly to P.
// 3. Call WritePacket with P as the |buffer|.
-class QUIC_EXPORT_PRIVATE QuicPacketWriter {
+class QUICHE_EXPORT QuicPacketWriter {
public:
virtual ~QuicPacketWriter() {}
diff --git a/quiche/quic/core/quic_packet_writer_wrapper.h b/quiche/quic/core/quic_packet_writer_wrapper.h
index 6bbf7fe..901aa6c 100644
--- a/quiche/quic/core/quic_packet_writer_wrapper.h
+++ b/quiche/quic/core/quic_packet_writer_wrapper.h
@@ -15,7 +15,7 @@
// Wraps a writer object to allow dynamically extending functionality. Use
// cases: replace writer while dispatcher and connections hold on to the
// wrapper; mix in monitoring; mix in mocks in unit tests.
-class QUIC_NO_EXPORT QuicPacketWriterWrapper : public QuicPacketWriter {
+class QUICHE_EXPORT QuicPacketWriterWrapper : public QuicPacketWriter {
public:
QuicPacketWriterWrapper();
QuicPacketWriterWrapper(const QuicPacketWriterWrapper&) = delete;
diff --git a/quiche/quic/core/quic_packets.h b/quiche/quic/core/quic_packets.h
index d1eb52b..9bd17f9 100644
--- a/quiche/quic/core/quic_packets.h
+++ b/quiche/quic/core/quic_packets.h
@@ -33,58 +33,56 @@
// Returns the destination connection ID of |header| when |perspective| is
// server, and the source connection ID when |perspective| is client.
-QUIC_EXPORT_PRIVATE QuicConnectionId GetServerConnectionIdAsRecipient(
+QUICHE_EXPORT QuicConnectionId GetServerConnectionIdAsRecipient(
const QuicPacketHeader& header, Perspective perspective);
// Returns the destination connection ID of |header| when |perspective| is
// client, and the source connection ID when |perspective| is server.
-QUIC_EXPORT_PRIVATE QuicConnectionId GetClientConnectionIdAsRecipient(
+QUICHE_EXPORT QuicConnectionId GetClientConnectionIdAsRecipient(
const QuicPacketHeader& header, Perspective perspective);
// Returns the destination connection ID of |header| when |perspective| is
// client, and the source connection ID when |perspective| is server.
-QUIC_EXPORT_PRIVATE QuicConnectionId GetServerConnectionIdAsSender(
+QUICHE_EXPORT QuicConnectionId GetServerConnectionIdAsSender(
const QuicPacketHeader& header, Perspective perspective);
// Returns the destination connection ID included of |header| when |perspective|
// is client, and the source connection ID included when |perspective| is
// server.
-QUIC_EXPORT_PRIVATE QuicConnectionIdIncluded
-GetServerConnectionIdIncludedAsSender(const QuicPacketHeader& header,
- Perspective perspective);
+QUICHE_EXPORT QuicConnectionIdIncluded GetServerConnectionIdIncludedAsSender(
+ const QuicPacketHeader& header, Perspective perspective);
// Returns the destination connection ID of |header| when |perspective| is
// server, and the source connection ID when |perspective| is client.
-QUIC_EXPORT_PRIVATE QuicConnectionId GetClientConnectionIdAsSender(
+QUICHE_EXPORT QuicConnectionId GetClientConnectionIdAsSender(
const QuicPacketHeader& header, Perspective perspective);
// Returns the destination connection ID included of |header| when |perspective|
// is server, and the source connection ID included when |perspective| is
// client.
-QUIC_EXPORT_PRIVATE QuicConnectionIdIncluded
-GetClientConnectionIdIncludedAsSender(const QuicPacketHeader& header,
- Perspective perspective);
+QUICHE_EXPORT QuicConnectionIdIncluded GetClientConnectionIdIncludedAsSender(
+ const QuicPacketHeader& header, Perspective perspective);
// Number of connection ID bytes that are actually included over the wire.
-QUIC_EXPORT_PRIVATE uint8_t
+QUICHE_EXPORT uint8_t
GetIncludedConnectionIdLength(QuicConnectionId connection_id,
QuicConnectionIdIncluded connection_id_included);
// Number of destination connection ID bytes that are actually included over the
// wire for this particular header.
-QUIC_EXPORT_PRIVATE uint8_t
+QUICHE_EXPORT uint8_t
GetIncludedDestinationConnectionIdLength(const QuicPacketHeader& header);
// Number of source connection ID bytes that are actually included over the
// wire for this particular header.
-QUIC_EXPORT_PRIVATE uint8_t
+QUICHE_EXPORT uint8_t
GetIncludedSourceConnectionIdLength(const QuicPacketHeader& header);
// Size in bytes of the data packet header.
-QUIC_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicTransportVersion version,
- const QuicPacketHeader& header);
+QUICHE_EXPORT size_t GetPacketHeaderSize(QuicTransportVersion version,
+ const QuicPacketHeader& header);
-QUIC_EXPORT_PRIVATE size_t GetPacketHeaderSize(
+QUICHE_EXPORT size_t GetPacketHeaderSize(
QuicTransportVersion version, uint8_t destination_connection_id_length,
uint8_t source_connection_id_length, bool include_version,
bool include_diversification_nonce,
@@ -94,10 +92,10 @@
quiche::QuicheVariableLengthIntegerLength length_length);
// Index of the first byte in a QUIC packet of encrypted data.
-QUIC_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
- QuicTransportVersion version, const QuicPacketHeader& header);
+QUICHE_EXPORT size_t GetStartOfEncryptedData(QuicTransportVersion version,
+ const QuicPacketHeader& header);
-QUIC_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
+QUICHE_EXPORT size_t GetStartOfEncryptedData(
QuicTransportVersion version, uint8_t destination_connection_id_length,
uint8_t source_connection_id_length, bool include_version,
bool include_diversification_nonce,
@@ -106,15 +104,15 @@
QuicByteCount retry_token_length,
quiche::QuicheVariableLengthIntegerLength length_length);
-struct QUIC_EXPORT_PRIVATE QuicPacketHeader {
+struct QUICHE_EXPORT QuicPacketHeader {
QuicPacketHeader();
QuicPacketHeader(const QuicPacketHeader& other);
~QuicPacketHeader();
QuicPacketHeader& operator=(const QuicPacketHeader& other);
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
- std::ostream& os, const QuicPacketHeader& header);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicPacketHeader& header);
// Universal header. All QuicPacket headers will have a connection_id and
// public flags.
@@ -162,7 +160,7 @@
bool operator!=(const QuicPacketHeader& other) const;
};
-struct QUIC_EXPORT_PRIVATE QuicPublicResetPacket {
+struct QUICHE_EXPORT QuicPublicResetPacket {
QuicPublicResetPacket();
explicit QuicPublicResetPacket(QuicConnectionId connection_id);
@@ -175,7 +173,7 @@
std::string endpoint_id;
};
-struct QUIC_EXPORT_PRIVATE QuicVersionNegotiationPacket {
+struct QUICHE_EXPORT QuicVersionNegotiationPacket {
QuicVersionNegotiationPacket();
explicit QuicVersionNegotiationPacket(QuicConnectionId connection_id);
QuicVersionNegotiationPacket(const QuicVersionNegotiationPacket& other);
@@ -185,7 +183,7 @@
ParsedQuicVersionVector versions;
};
-struct QUIC_EXPORT_PRIVATE QuicIetfStatelessResetPacket {
+struct QUICHE_EXPORT QuicIetfStatelessResetPacket {
QuicIetfStatelessResetPacket();
QuicIetfStatelessResetPacket(const QuicPacketHeader& header,
StatelessResetToken token);
@@ -196,7 +194,7 @@
StatelessResetToken stateless_reset_token;
};
-class QUIC_EXPORT_PRIVATE QuicData {
+class QUICHE_EXPORT QuicData {
public:
// Creates a QuicData from a buffer and length. Does not own the buffer.
QuicData(const char* buffer, size_t length);
@@ -223,7 +221,7 @@
bool owns_buffer_;
};
-class QUIC_EXPORT_PRIVATE QuicPacket : public QuicData {
+class QUICHE_EXPORT QuicPacket : public QuicData {
public:
QuicPacket(
char* buffer, size_t length, bool owns_buffer,
@@ -256,7 +254,7 @@
const quiche::QuicheVariableLengthIntegerLength length_length_;
};
-class QUIC_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
+class QUICHE_EXPORT QuicEncryptedPacket : public QuicData {
public:
// Creates a QuicEncryptedPacket from a buffer and length.
// Does not own the buffer.
@@ -278,12 +276,12 @@
// 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.
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
- std::ostream& os, const QuicEncryptedPacket& s);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicEncryptedPacket& s);
};
// A received encrypted QUIC packet, with a recorded time of receipt.
-class QUIC_EXPORT_PRIVATE QuicReceivedPacket : public QuicEncryptedPacket {
+class QUICHE_EXPORT QuicReceivedPacket : public QuicEncryptedPacket {
public:
QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time);
QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time,
@@ -321,8 +319,8 @@
// 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.
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
- std::ostream& os, const QuicReceivedPacket& s);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicReceivedPacket& s);
QuicEcnCodepoint ecn_codepoint() const { return ecn_codepoint_; }
@@ -345,7 +343,7 @@
// If you add a member field to this class, please make sure it is properly
// copied in |CopySerializedPacket|.
//
-struct QUIC_EXPORT_PRIVATE SerializedPacket {
+struct QUICHE_EXPORT SerializedPacket {
SerializedPacket(QuicPacketNumber packet_number,
QuicPacketNumberLength packet_number_length,
const char* encrypted_buffer,
@@ -399,26 +397,26 @@
// Make a copy of |serialized| (including the underlying frames). |copy_buffer|
// indicates whether the encrypted buffer should be copied.
-QUIC_EXPORT_PRIVATE SerializedPacket* CopySerializedPacket(
+QUICHE_EXPORT SerializedPacket* CopySerializedPacket(
const SerializedPacket& serialized,
quiche::QuicheBufferAllocator* allocator, bool copy_buffer);
// Allocates a new char[] of size |packet.encrypted_length| and copies in
// |packet.encrypted_buffer|.
-QUIC_EXPORT_PRIVATE char* CopyBuffer(const SerializedPacket& packet);
+QUICHE_EXPORT char* CopyBuffer(const SerializedPacket& packet);
// Allocates a new char[] of size |encrypted_length| and copies in
// |encrypted_buffer|.
-QUIC_EXPORT_PRIVATE char* CopyBuffer(const char* encrypted_buffer,
- QuicPacketLength encrypted_length);
+QUICHE_EXPORT char* CopyBuffer(const char* encrypted_buffer,
+ QuicPacketLength encrypted_length);
// Context for an incoming packet.
-struct QUIC_EXPORT_PRIVATE QuicPerPacketContext {
+struct QUICHE_EXPORT QuicPerPacketContext {
virtual ~QuicPerPacketContext() {}
};
// ReceivedPacketInfo comprises information obtained by parsing the unencrypted
// bytes of a received packet.
-struct QUIC_EXPORT_PRIVATE ReceivedPacketInfo {
+struct QUICHE_EXPORT ReceivedPacketInfo {
ReceivedPacketInfo(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
const QuicReceivedPacket& packet);
@@ -428,7 +426,7 @@
std::string ToString() const;
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
+ QUICHE_EXPORT friend std::ostream& operator<<(
std::ostream& os, const ReceivedPacketInfo& packet_info);
const QuicSocketAddress& self_address;
diff --git a/quiche/quic/core/quic_path_validator.h b/quiche/quic/core/quic_path_validator.h
index 1079f21..37faca3 100644
--- a/quiche/quic/core/quic_path_validator.h
+++ b/quiche/quic/core/quic_path_validator.h
@@ -41,7 +41,7 @@
};
// Interface to provide the information of the path to be validated.
-class QUIC_EXPORT_PRIVATE QuicPathValidationContext {
+class QUICHE_EXPORT QuicPathValidationContext {
public:
QuicPathValidationContext(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address)
@@ -67,7 +67,7 @@
}
private:
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
+ QUICHE_EXPORT friend std::ostream& operator<<(
std::ostream& os, const QuicPathValidationContext& context);
QuicSocketAddress self_address_;
@@ -80,13 +80,13 @@
// Used to validate a path by sending up to 3 PATH_CHALLENGE frames before
// declaring a path validation failure.
-class QUIC_EXPORT_PRIVATE QuicPathValidator {
+class QUICHE_EXPORT QuicPathValidator {
public:
static const uint16_t kMaxRetryTimes = 2;
// Used to write PATH_CHALLENGE on the path to be validated and to get retry
// timeout.
- class QUIC_EXPORT_PRIVATE SendDelegate {
+ class QUICHE_EXPORT SendDelegate {
public:
virtual ~SendDelegate() = default;
@@ -108,7 +108,7 @@
// Handles the validation result.
// TODO(danzh) consider to simplify this interface and its life time to
// outlive a validation.
- class QUIC_EXPORT_PRIVATE ResultDelegate {
+ class QUICHE_EXPORT ResultDelegate {
public:
virtual ~ResultDelegate() = default;
@@ -171,7 +171,7 @@
void ResetPathValidation();
- struct QUIC_NO_EXPORT ProbingData {
+ struct QUICHE_EXPORT ProbingData {
explicit ProbingData(QuicTime send_time) : send_time(send_time) {}
QuicPathFrameBuffer frame_buffer;
QuicTime send_time;
diff --git a/quiche/quic/core/quic_ping_manager.h b/quiche/quic/core/quic_ping_manager.h
index d88dac2..4b9b536 100644
--- a/quiche/quic/core/quic_ping_manager.h
+++ b/quiche/quic/core/quic_ping_manager.h
@@ -24,10 +24,10 @@
// connection alive.
// 2) retransmittable-on-wire. When alarm fires, send packets to detect path
// degrading (used in IP/port migrations).
-class QUIC_EXPORT_PRIVATE QuicPingManager {
+class QUICHE_EXPORT QuicPingManager {
public:
// Interface that get notified when |alarm_| fires.
- class QUIC_EXPORT_PRIVATE Delegate {
+ class QUICHE_EXPORT Delegate {
public:
virtual ~Delegate() {}
diff --git a/quiche/quic/core/quic_process_packet_interface.h b/quiche/quic/core/quic_process_packet_interface.h
index 30bd071..e2c4136 100644
--- a/quiche/quic/core/quic_process_packet_interface.h
+++ b/quiche/quic/core/quic_process_packet_interface.h
@@ -11,7 +11,7 @@
namespace quic {
// A class to process each incoming packet.
-class QUIC_NO_EXPORT ProcessPacketInterface {
+class QUICHE_EXPORT ProcessPacketInterface {
public:
virtual ~ProcessPacketInterface() {}
virtual void ProcessPacket(const QuicSocketAddress& self_address,
diff --git a/quiche/quic/core/quic_received_packet_manager.h b/quiche/quic/core/quic_received_packet_manager.h
index d16d37d..1d24651 100644
--- a/quiche/quic/core/quic_received_packet_manager.h
+++ b/quiche/quic/core/quic_received_packet_manager.h
@@ -27,7 +27,7 @@
struct QuicConnectionStats;
// Records all received packets by a connection.
-class QUIC_EXPORT_PRIVATE QuicReceivedPacketManager {
+class QUICHE_EXPORT QuicReceivedPacketManager {
public:
QuicReceivedPacketManager();
explicit QuicReceivedPacketManager(QuicConnectionStats* stats);
diff --git a/quiche/quic/core/quic_sent_packet_manager.h b/quiche/quic/core/quic_sent_packet_manager.h
index c96d260..133b7ae 100644
--- a/quiche/quic/core/quic_sent_packet_manager.h
+++ b/quiche/quic/core/quic_sent_packet_manager.h
@@ -45,14 +45,14 @@
// retransmittable data associated with each packet. If a packet is
// retransmitted, it will keep track of each version of a packet so that if a
// previous transmission is acked, the data will not be retransmitted.
-class QUIC_EXPORT_PRIVATE QuicSentPacketManager {
+class QUICHE_EXPORT QuicSentPacketManager {
public:
// Interface which gets callbacks from the QuicSentPacketManager at
// interesting points. Implementations must not mutate the state of
// the packet manager or connection as a result of these callbacks.
- class QUIC_EXPORT_PRIVATE DebugDelegate {
+ class QUICHE_EXPORT DebugDelegate {
public:
- struct QUIC_EXPORT_PRIVATE SendParameters {
+ struct QUICHE_EXPORT SendParameters {
CongestionControlType congestion_control_type;
bool use_pacing;
QuicPacketCount initial_congestion_window;
@@ -98,7 +98,7 @@
// Interface which gets callbacks from the QuicSentPacketManager when
// network-related state changes. Implementations must not mutate the
// state of the packet manager as a result of these callbacks.
- class QUIC_EXPORT_PRIVATE NetworkChangeVisitor {
+ class QUICHE_EXPORT NetworkChangeVisitor {
public:
virtual ~NetworkChangeVisitor() {}
diff --git a/quiche/quic/core/quic_server_id.h b/quiche/quic/core/quic_server_id.h
index 51d055b..ecbf3aa 100644
--- a/quiche/quic/core/quic_server_id.h
+++ b/quiche/quic/core/quic_server_id.h
@@ -17,7 +17,7 @@
// The id used to identify sessions. Includes the hostname, port, scheme and
// privacy_mode.
-class QUIC_EXPORT_PRIVATE QuicServerId {
+class QUICHE_EXPORT QuicServerId {
public:
// Attempts to parse a QuicServerId from a "host:port" string. Returns nullopt
// if input could not be parsed. Requires input to contain both host and port
diff --git a/quiche/quic/core/quic_session.h b/quiche/quic/core/quic_session.h
index a518091..79b7396 100644
--- a/quiche/quic/core/quic_session.h
+++ b/quiche/quic/core/quic_session.h
@@ -59,7 +59,7 @@
class QuicSessionPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE QuicSession
+class QUICHE_EXPORT QuicSession
: public QuicConnectionVisitorInterface,
public SessionNotifierInterface,
public QuicStreamFrameDataProducer,
@@ -74,7 +74,7 @@
// TODO(danzh): split this visitor to separate visitors for client and server
// respectively as not all methods in this class are interesting to both
// perspectives.
- class QUIC_EXPORT_PRIVATE Visitor {
+ class QUICHE_EXPORT Visitor {
public:
virtual ~Visitor() {}
@@ -417,7 +417,7 @@
// and ResultDelegate to react upon the validation result.
// Example implementations of these for path validation for connection
// migration could be:
- // class QUIC_EXPORT_PRIVATE PathMigrationContext
+ // class QUICHE_EXPORT PathMigrationContext
// : public QuicPathValidationContext {
// public:
// PathMigrationContext(std::unique_ptr<QuicPacketWriter> writer,
diff --git a/quiche/quic/core/quic_socket_address_coder.h b/quiche/quic/core/quic_socket_address_coder.h
index b56ee6a..aaec5f4 100644
--- a/quiche/quic/core/quic_socket_address_coder.h
+++ b/quiche/quic/core/quic_socket_address_coder.h
@@ -17,7 +17,7 @@
// Serializes and parses a socket address (IP address and port), to be used in
// the kCADR tag in the ServerHello handshake message and the Public Reset
// packet.
-class QUIC_EXPORT_PRIVATE QuicSocketAddressCoder {
+class QUICHE_EXPORT QuicSocketAddressCoder {
public:
QuicSocketAddressCoder();
explicit QuicSocketAddressCoder(const QuicSocketAddress& address);
diff --git a/quiche/quic/core/quic_stream.h b/quiche/quic/core/quic_stream.h
index e4d1463..69abe7d 100644
--- a/quiche/quic/core/quic_stream.h
+++ b/quiche/quic/core/quic_stream.h
@@ -50,7 +50,7 @@
class QuicStream;
// Buffers frames for a stream until the first byte of that frame arrives.
-class QUIC_EXPORT_PRIVATE PendingStream
+class QUICHE_EXPORT PendingStream
: public QuicStreamSequencer::StreamInterface {
public:
PendingStream(QuicStreamId id, QuicSession* session);
@@ -135,8 +135,7 @@
absl::optional<QuicResetStreamError> stop_sending_error_code_;
};
-class QUIC_EXPORT_PRIVATE QuicStream
- : public QuicStreamSequencer::StreamInterface {
+class QUICHE_EXPORT QuicStream : public QuicStreamSequencer::StreamInterface {
public:
// Creates a new stream with stream_id |id| associated with |session|. If
// |is_static| is true, then the stream will be given precedence
diff --git a/quiche/quic/core/quic_stream_frame_data_producer.h b/quiche/quic/core/quic_stream_frame_data_producer.h
index 5dc12b7..56ae622 100644
--- a/quiche/quic/core/quic_stream_frame_data_producer.h
+++ b/quiche/quic/core/quic_stream_frame_data_producer.h
@@ -12,7 +12,7 @@
class QuicDataWriter;
// Pure virtual class to retrieve stream data.
-class QUIC_EXPORT_PRIVATE QuicStreamFrameDataProducer {
+class QUICHE_EXPORT QuicStreamFrameDataProducer {
public:
virtual ~QuicStreamFrameDataProducer() {}
diff --git a/quiche/quic/core/quic_stream_id_manager.h b/quiche/quic/core/quic_stream_id_manager.h
index eaad296..45c7666 100644
--- a/quiche/quic/core/quic_stream_id_manager.h
+++ b/quiche/quic/core/quic_stream_id_manager.h
@@ -19,9 +19,9 @@
} // namespace test
// This class manages the stream ids for IETF QUIC.
-class QUIC_EXPORT_PRIVATE QuicStreamIdManager {
+class QUICHE_EXPORT QuicStreamIdManager {
public:
- class QUIC_EXPORT_PRIVATE DelegateInterface {
+ class QUICHE_EXPORT DelegateInterface {
public:
virtual ~DelegateInterface() = default;
diff --git a/quiche/quic/core/quic_stream_send_buffer.h b/quiche/quic/core/quic_stream_send_buffer.h
index b74968a..b892cdf 100644
--- a/quiche/quic/core/quic_stream_send_buffer.h
+++ b/quiche/quic/core/quic_stream_send_buffer.h
@@ -26,7 +26,7 @@
// contiguous memory space. Please note, BufferedSlice is constructed when
// stream data is saved in send buffer and is removed when stream data is fully
// acked. It is move-only.
-struct QUIC_EXPORT_PRIVATE BufferedSlice {
+struct QUICHE_EXPORT BufferedSlice {
BufferedSlice(quiche::QuicheMemSlice mem_slice, QuicStreamOffset offset);
BufferedSlice(BufferedSlice&& other);
BufferedSlice& operator=(BufferedSlice&& other);
@@ -44,7 +44,7 @@
QuicStreamOffset offset;
};
-struct QUIC_EXPORT_PRIVATE StreamPendingRetransmission {
+struct QUICHE_EXPORT StreamPendingRetransmission {
constexpr StreamPendingRetransmission(QuicStreamOffset offset,
QuicByteCount length)
: offset(offset), length(length) {}
@@ -61,7 +61,7 @@
// are added to the tail of the list. Data slices are removed from the head of
// the list when they get fully acked. Stream data can be retrieved and acked
// across slice boundaries.
-class QUIC_EXPORT_PRIVATE QuicStreamSendBuffer {
+class QUICHE_EXPORT QuicStreamSendBuffer {
public:
explicit QuicStreamSendBuffer(quiche::QuicheBufferAllocator* allocator);
QuicStreamSendBuffer(const QuicStreamSendBuffer& other) = delete;
diff --git a/quiche/quic/core/quic_stream_sequencer.h b/quiche/quic/core/quic_stream_sequencer.h
index f0e3ab3..2d5bfcf 100644
--- a/quiche/quic/core/quic_stream_sequencer.h
+++ b/quiche/quic/core/quic_stream_sequencer.h
@@ -22,10 +22,10 @@
// Buffers frames until we have something which can be passed
// up to the next layer.
-class QUIC_EXPORT_PRIVATE QuicStreamSequencer final {
+class QUICHE_EXPORT QuicStreamSequencer final {
public:
// Interface that thie Sequencer uses to communicate with the Stream.
- class QUIC_EXPORT_PRIVATE StreamInterface {
+ class QUICHE_EXPORT StreamInterface {
public:
virtual ~StreamInterface() = default;
diff --git a/quiche/quic/core/quic_stream_sequencer_buffer.h b/quiche/quic/core/quic_stream_sequencer_buffer.h
index 9b36ee1..2db24bc 100644
--- a/quiche/quic/core/quic_stream_sequencer_buffer.h
+++ b/quiche/quic/core/quic_stream_sequencer_buffer.h
@@ -77,7 +77,7 @@
class QuicStreamSequencerBufferPeer;
} // namespace test
-class QUIC_EXPORT_PRIVATE QuicStreamSequencerBuffer {
+class QUICHE_EXPORT QuicStreamSequencerBuffer {
public:
// Size of blocks used by this buffer.
// Choose 8K to make block large enough to hold multiple frames, each of
@@ -85,7 +85,7 @@
static const size_t kBlockSizeBytes = 8 * 1024; // 8KB
// The basic storage block used by this buffer.
- struct QUIC_EXPORT_PRIVATE BufferBlock {
+ struct QUICHE_EXPORT BufferBlock {
char buffer[kBlockSizeBytes];
};
diff --git a/quiche/quic/core/quic_sustained_bandwidth_recorder.h b/quiche/quic/core/quic_sustained_bandwidth_recorder.h
index 63ed6cb..e0231e6 100644
--- a/quiche/quic/core/quic_sustained_bandwidth_recorder.h
+++ b/quiche/quic/core/quic_sustained_bandwidth_recorder.h
@@ -22,7 +22,7 @@
// to the client in a server config update message. A sustained bandwidth
// estimate is only marked as valid if the QuicSustainedBandwidthRecorder has
// been given uninterrupted reliable estimates over a certain period of time.
-class QUIC_EXPORT_PRIVATE QuicSustainedBandwidthRecorder {
+class QUICHE_EXPORT QuicSustainedBandwidthRecorder {
public:
QuicSustainedBandwidthRecorder();
QuicSustainedBandwidthRecorder(const QuicSustainedBandwidthRecorder&) =
diff --git a/quiche/quic/core/quic_syscall_wrapper.h b/quiche/quic/core/quic_syscall_wrapper.h
index 4f4ffb0..ea90cc3 100644
--- a/quiche/quic/core/quic_syscall_wrapper.h
+++ b/quiche/quic/core/quic_syscall_wrapper.h
@@ -14,7 +14,7 @@
namespace quic {
// QuicSyscallWrapper is a pass-through proxy to the real syscalls.
-class QUIC_EXPORT_PRIVATE QuicSyscallWrapper {
+class QUICHE_EXPORT QuicSyscallWrapper {
public:
virtual ~QuicSyscallWrapper() = default;
@@ -32,7 +32,7 @@
// ScopedGlobalSyscallWrapperOverride changes the global QuicSyscallWrapper
// during its lifetime, for testing.
-class QUIC_EXPORT_PRIVATE ScopedGlobalSyscallWrapperOverride {
+class QUICHE_EXPORT ScopedGlobalSyscallWrapperOverride {
public:
explicit ScopedGlobalSyscallWrapperOverride(
QuicSyscallWrapper* wrapper_in_scope);
diff --git a/quiche/quic/core/quic_tag.h b/quiche/quic/core/quic_tag.h
index 17c5968..f130a57 100644
--- a/quiche/quic/core/quic_tag.h
+++ b/quiche/quic/core/quic_tag.h
@@ -29,38 +29,35 @@
// MakeQuicTag returns a value given the four bytes. For example:
// MakeQuicTag('C', 'H', 'L', 'O');
-QUIC_EXPORT_PRIVATE QuicTag MakeQuicTag(uint8_t a, uint8_t b, uint8_t c,
- uint8_t d);
+QUICHE_EXPORT QuicTag MakeQuicTag(uint8_t a, uint8_t b, uint8_t c, uint8_t d);
// Returns true if |tag_vector| contains |tag|.
-QUIC_EXPORT_PRIVATE bool ContainsQuicTag(const QuicTagVector& tag_vector,
- QuicTag tag);
+QUICHE_EXPORT bool ContainsQuicTag(const QuicTagVector& tag_vector,
+ QuicTag tag);
// Sets |out_result| to the first tag in |our_tags| that is also in |their_tags|
// and returns true. If there is no intersection it returns false.
//
// If |out_index| is non-nullptr and a match is found then the index of that
// match in |their_tags| is written to |out_index|.
-QUIC_EXPORT_PRIVATE bool FindMutualQuicTag(const QuicTagVector& our_tags,
- const QuicTagVector& their_tags,
- QuicTag* out_result,
- size_t* out_index);
+QUICHE_EXPORT bool FindMutualQuicTag(const QuicTagVector& our_tags,
+ const QuicTagVector& their_tags,
+ QuicTag* out_result, size_t* out_index);
// A utility function that converts a tag to a string. It will try to maintain
// the human friendly name if possible (i.e. kABCD -> "ABCD"), or will just
// treat it as a number if not.
-QUIC_EXPORT_PRIVATE std::string QuicTagToString(QuicTag tag);
+QUICHE_EXPORT std::string QuicTagToString(QuicTag tag);
// Utility function that converts a string of the form "ABCD" to its
// corresponding QuicTag. Note that tags that are less than four characters
// long are right-padded with zeroes. Tags that contain non-ASCII characters
// are represented as 8-character-long hexadecimal strings.
-QUIC_EXPORT_PRIVATE QuicTag ParseQuicTag(absl::string_view tag_string);
+QUICHE_EXPORT QuicTag ParseQuicTag(absl::string_view tag_string);
// Utility function that converts a string of the form "ABCD,EFGH" to a vector
// of the form {kABCD,kEFGH}. Note the caveats on ParseQuicTag.
-QUIC_EXPORT_PRIVATE QuicTagVector
-ParseQuicTagVector(absl::string_view tags_string);
+QUICHE_EXPORT QuicTagVector ParseQuicTagVector(absl::string_view tags_string);
} // namespace quic
diff --git a/quiche/quic/core/quic_time.h b/quiche/quic/core/quic_time.h
index ddf0307..46ee1a1 100644
--- a/quiche/quic/core/quic_time.h
+++ b/quiche/quic/core/quic_time.h
@@ -23,7 +23,7 @@
// a number of microseconds. QUIC does not use absl::Duration, since the Abseil
// type is 128-bit, which would adversely affect certain performance-sensitive
// QUIC data structures.
-class QUIC_EXPORT_PRIVATE QuicTimeDelta {
+class QUICHE_EXPORT QuicTimeDelta {
public:
// Creates a QuicTimeDelta from an absl::Duration. Note that this inherently
// loses precision, since absl::Duration is nanoseconds, and QuicTimeDelta is
@@ -111,7 +111,7 @@
// usually either a Unix timestamp or a timestamp returned by the
// platform-specific monotonic clock. QuicClock has a method to convert QuicTime
// to the wall time.
-class QUIC_EXPORT_PRIVATE QuicTime {
+class QUICHE_EXPORT QuicTime {
public:
using Delta = QuicTimeDelta;
@@ -156,7 +156,7 @@
// A UNIX timestamp.
//
// TODO(vasilvv): evaluate whether this can be replaced with absl::Time.
-class QUIC_EXPORT_PRIVATE QuicWallTime {
+class QUICHE_EXPORT QuicWallTime {
public:
// FromUNIXSeconds constructs a QuicWallTime from a count of the seconds
// since the UNIX epoch.
diff --git a/quiche/quic/core/quic_time_accumulator.h b/quiche/quic/core/quic_time_accumulator.h
index 480e797..51910b7 100644
--- a/quiche/quic/core/quic_time_accumulator.h
+++ b/quiche/quic/core/quic_time_accumulator.h
@@ -12,7 +12,7 @@
namespace quic {
// QuicTimeAccumulator accumulates elapsed times between Start(s) and Stop(s).
-class QUIC_EXPORT_PRIVATE QuicTimeAccumulator {
+class QUICHE_EXPORT QuicTimeAccumulator {
// TODO(wub): Switch to a data member called kNotRunningSentinel after c++17.
static constexpr QuicTime NotRunningSentinel() {
return QuicTime::Infinite();
diff --git a/quiche/quic/core/quic_time_wait_list_manager.h b/quiche/quic/core/quic_time_wait_list_manager.h
index 676e15e..3fee798 100644
--- a/quiche/quic/core/quic_time_wait_list_manager.h
+++ b/quiche/quic/core/quic_time_wait_list_manager.h
@@ -31,7 +31,7 @@
// TimeWaitConnectionInfo comprises information of a connection which is in the
// time wait list.
-struct QUIC_NO_EXPORT TimeWaitConnectionInfo {
+struct QUICHE_EXPORT TimeWaitConnectionInfo {
TimeWaitConnectionInfo(
bool ietf_quic,
std::vector<std::unique_ptr<QuicEncryptedPacket>>* termination_packets,
@@ -62,7 +62,7 @@
// wait state. After the connection_id expires its time wait period, a new
// connection/session will be created if a packet is received for this
// connection_id.
-class QUIC_NO_EXPORT QuicTimeWaitListManager
+class QUICHE_EXPORT QuicTimeWaitListManager
: public QuicBlockedWriterInterface {
public:
// Specifies what the time wait list manager should do when processing packets
@@ -80,7 +80,7 @@
DO_NOTHING,
};
- class QUIC_NO_EXPORT Visitor : public QuicSession::Visitor {
+ class QUICHE_EXPORT Visitor : public QuicSession::Visitor {
public:
// Called after the given connection is added to the time-wait list.
virtual void OnConnectionAddedToTimeWaitList(
@@ -183,7 +183,7 @@
QuicConnectionId connection_id) const;
// Internal structure to store pending termination packets.
- class QUIC_NO_EXPORT QueuedPacket {
+ class QUICHE_EXPORT QueuedPacket {
public:
QueuedPacket(const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
@@ -258,7 +258,7 @@
// A map from a recently closed connection_id to the number of packets
// received after the termination of the connection bound to the
// connection_id.
- struct QUIC_NO_EXPORT ConnectionIdData {
+ struct QUICHE_EXPORT ConnectionIdData {
ConnectionIdData(int num_packets, QuicTime time_added,
TimeWaitAction action, TimeWaitConnectionInfo info);
diff --git a/quiche/quic/core/quic_trace_visitor.h b/quiche/quic/core/quic_trace_visitor.h
index 28e4d68..fd1bb47 100644
--- a/quiche/quic/core/quic_trace_visitor.h
+++ b/quiche/quic/core/quic_trace_visitor.h
@@ -14,7 +14,7 @@
// Records a QUIC trace protocol buffer for a QuicConnection. It's the
// responsibility of the user of this visitor to process or store the resulting
// trace, which can be accessed via trace().
-class QUIC_NO_EXPORT QuicTraceVisitor : public QuicConnectionDebugVisitor {
+class QUICHE_EXPORT QuicTraceVisitor : public QuicConnectionDebugVisitor {
public:
explicit QuicTraceVisitor(const QuicConnection* connection);
diff --git a/quiche/quic/core/quic_transmission_info.h b/quiche/quic/core/quic_transmission_info.h
index 2b81078..bc6d49b 100644
--- a/quiche/quic/core/quic_transmission_info.h
+++ b/quiche/quic/core/quic_transmission_info.h
@@ -15,7 +15,7 @@
namespace quic {
// Stores details of a single sent packet.
-struct QUIC_EXPORT_PRIVATE QuicTransmissionInfo {
+struct QUICHE_EXPORT QuicTransmissionInfo {
// Used by STL when assigning into a map.
QuicTransmissionInfo();
diff --git a/quiche/quic/core/quic_types.cc b/quiche/quic/core/quic_types.cc
index 3981256..168d699 100644
--- a/quiche/quic/core/quic_types.cc
+++ b/quiche/quic/core/quic_types.cc
@@ -440,8 +440,8 @@
}
return "(unknown)";
}
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- QuicPriorityType type) {
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ QuicPriorityType type) {
os << QuicPriorityTypeToString(type);
return os;
}
diff --git a/quiche/quic/core/quic_types.h b/quiche/quic/core/quic_types.h
index 55183bb..e58d0d6 100644
--- a/quiche/quic/core/quic_types.h
+++ b/quiche/quic/core/quic_types.h
@@ -71,7 +71,7 @@
using ApplicationState = std::vector<uint8_t>;
// A struct for functions which consume data payloads and fins.
-struct QUIC_EXPORT_PRIVATE QuicConsumedData {
+struct QUICHE_EXPORT QuicConsumedData {
constexpr QuicConsumedData(size_t bytes_consumed, bool fin_consumed)
: bytes_consumed(bytes_consumed), fin_consumed(fin_consumed) {}
@@ -79,8 +79,8 @@
// member 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.
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
- std::ostream& os, const QuicConsumedData& s);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const QuicConsumedData& s);
// How many bytes were consumed.
size_t bytes_consumed;
@@ -116,8 +116,8 @@
};
std::string HistogramEnumString(WriteStatus enum_value);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const WriteStatus& status);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const WriteStatus& status);
inline std::string HistogramEnumDescription(WriteStatus /*dummy*/) {
return "status";
@@ -134,7 +134,7 @@
// A struct used to return the result of write calls including either the number
// of bytes written or the error code, depending upon the status.
-struct QUIC_EXPORT_PRIVATE WriteResult {
+struct QUICHE_EXPORT WriteResult {
constexpr WriteResult(WriteStatus status, int bytes_written_or_error_code)
: status(status), bytes_written(bytes_written_or_error_code) {}
@@ -155,8 +155,8 @@
}
}
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
- const WriteResult& s);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const WriteResult& s);
WriteResult& set_batch_id(uint32_t new_batch_id) {
batch_id = new_batch_id;
@@ -200,11 +200,11 @@
LAST_TRANSMISSION_TYPE = ALL_INITIAL_RETRANSMISSION,
};
-QUIC_EXPORT_PRIVATE std::string TransmissionTypeToString(
+QUICHE_EXPORT std::string TransmissionTypeToString(
TransmissionType transmission_type);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, TransmissionType transmission_type);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ TransmissionType transmission_type);
enum HasRetransmittableData : uint8_t {
NO_RETRANSMITTABLE_DATA,
@@ -215,16 +215,16 @@
enum class Perspective : uint8_t { IS_SERVER, IS_CLIENT };
-QUIC_EXPORT_PRIVATE std::string PerspectiveToString(Perspective perspective);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const Perspective& perspective);
+QUICHE_EXPORT std::string PerspectiveToString(Perspective perspective);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const Perspective& perspective);
// Describes whether a ConnectionClose was originated by the peer.
enum class ConnectionCloseSource { FROM_PEER, FROM_SELF };
-QUIC_EXPORT_PRIVATE std::string ConnectionCloseSourceToString(
+QUICHE_EXPORT std::string ConnectionCloseSourceToString(
ConnectionCloseSource connection_close_source);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const ConnectionCloseSource& connection_close_source);
// Should a connection be closed silently or not.
@@ -234,9 +234,9 @@
SEND_CONNECTION_CLOSE_PACKET
};
-QUIC_EXPORT_PRIVATE std::string ConnectionCloseBehaviorToString(
+QUICHE_EXPORT std::string ConnectionCloseBehaviorToString(
ConnectionCloseBehavior connection_close_behavior);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const ConnectionCloseBehavior& connection_close_behavior);
enum QuicFrameType : uint8_t {
@@ -280,9 +280,9 @@
};
// Human-readable string suitable for logging.
-QUIC_EXPORT_PRIVATE std::string QuicFrameTypeToString(QuicFrameType t);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const QuicFrameType& t);
+QUICHE_EXPORT std::string QuicFrameTypeToString(QuicFrameType t);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicFrameType& t);
// Ietf frame types. These are defined in the IETF QUIC Specification.
// Explicit values are given in the enum so that we can be sure that
@@ -348,9 +348,9 @@
// TODO(ianswett): Determine a proper value to replace this temporary value.
IETF_ACK_RECEIVE_TIMESTAMPS = 0x22,
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const QuicIetfFrameType& c);
-QUIC_EXPORT_PRIVATE std::string QuicIetfFrameTypeString(QuicIetfFrameType t);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicIetfFrameType& c);
+QUICHE_EXPORT std::string QuicIetfFrameTypeString(QuicIetfFrameType t);
// Masks for the bits that indicate the frame is a Stream frame vs the
// bits used as flags.
@@ -450,7 +450,7 @@
kBBRv2,
};
-QUIC_EXPORT_PRIVATE std::string CongestionControlTypeToString(
+QUICHE_EXPORT std::string CongestionControlTypeToString(
CongestionControlType cc_type);
// EncryptionLevel enumerates the stages of encryption that a QUIC connection
@@ -470,10 +470,9 @@
return ENCRYPTION_INITIAL <= level && level < NUM_ENCRYPTION_LEVELS;
}
-QUIC_EXPORT_PRIVATE std::string EncryptionLevelToString(EncryptionLevel level);
+QUICHE_EXPORT std::string EncryptionLevelToString(EncryptionLevel level);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- EncryptionLevel level);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os, EncryptionLevel level);
// Enumeration of whether a server endpoint will request a client certificate,
// and whether that endpoint requires a valid client certificate to establish a
@@ -484,11 +483,9 @@
kRequire, // Require clients to provide a valid certificate.
};
-QUIC_EXPORT_PRIVATE absl::string_view ClientCertModeToString(
- ClientCertMode mode);
+QUICHE_EXPORT absl::string_view ClientCertModeToString(ClientCertMode mode);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- ClientCertMode mode);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os, ClientCertMode mode);
enum AddressChangeType : uint8_t {
// IP address and port remain unchanged.
@@ -507,11 +504,10 @@
IPV6_TO_IPV6_CHANGE,
};
-QUIC_EXPORT_PRIVATE std::string AddressChangeTypeToString(
- AddressChangeType type);
+QUICHE_EXPORT std::string AddressChangeTypeToString(AddressChangeType type);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- AddressChangeType type);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ AddressChangeType type);
enum StreamSendingState {
// Sender has more data to send on this stream.
@@ -558,11 +554,10 @@
GOOGLE_QUIC_PACKET,
};
-QUIC_EXPORT_PRIVATE std::string PacketHeaderFormatToString(
- PacketHeaderFormat format);
+QUICHE_EXPORT std::string PacketHeaderFormatToString(PacketHeaderFormat format);
// Information about a newly acknowledged packet.
-struct QUIC_EXPORT_PRIVATE AckedPacket {
+struct QUICHE_EXPORT AckedPacket {
constexpr AckedPacket(QuicPacketNumber packet_number,
QuicPacketLength bytes_acked,
QuicTime receive_timestamp)
@@ -570,7 +565,7 @@
bytes_acked(bytes_acked),
receive_timestamp(receive_timestamp) {}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ friend QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const AckedPacket& acked_packet);
QuicPacketNumber packet_number;
@@ -586,12 +581,12 @@
using AckedPacketVector = absl::InlinedVector<AckedPacket, 2>;
// Information about a newly lost packet.
-struct QUIC_EXPORT_PRIVATE LostPacket {
+struct QUICHE_EXPORT LostPacket {
LostPacket(QuicPacketNumber packet_number, QuicPacketLength bytes_lost)
: packet_number(packet_number), bytes_lost(bytes_lost) {}
- friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const LostPacket& lost_packet);
+ friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const LostPacket& lost_packet);
QuicPacketNumber packet_number;
// Number of bytes sent in the packet that was lost.
@@ -612,8 +607,7 @@
INVALID_PACKET_TYPE,
};
-QUIC_EXPORT_PRIVATE std::string QuicLongHeaderTypeToString(
- QuicLongHeaderType type);
+QUICHE_EXPORT std::string QuicLongHeaderTypeToString(QuicLongHeaderType type);
enum QuicPacketHeaderTypeFlags : uint8_t {
// Bit 2: Key phase bit for IETF QUIC short header packets.
@@ -647,27 +641,25 @@
// reaches an invalid state.
};
-QUIC_EXPORT_PRIVATE std::string MessageStatusToString(
- MessageStatus message_status);
+QUICHE_EXPORT std::string MessageStatusToString(MessageStatus message_status);
// Used to return the result of SendMessage calls
-struct QUIC_EXPORT_PRIVATE MessageResult {
+struct QUICHE_EXPORT MessageResult {
MessageResult(MessageStatus status, QuicMessageId message_id);
bool operator==(const MessageResult& other) const {
return status == other.status && message_id == other.message_id;
}
- QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
- const MessageResult& mr);
+ QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& os,
+ const MessageResult& mr);
MessageStatus status;
// Only valid when status is MESSAGE_STATUS_SUCCESS.
QuicMessageId message_id;
};
-QUIC_EXPORT_PRIVATE std::string MessageResultToString(
- MessageResult message_result);
+QUICHE_EXPORT std::string MessageResultToString(MessageResult message_result);
enum WriteStreamDataResult {
WRITE_SUCCESS,
@@ -698,7 +690,7 @@
NUM_PACKET_NUMBER_SPACES,
};
-QUIC_EXPORT_PRIVATE std::string PacketNumberSpaceToString(
+QUICHE_EXPORT std::string PacketNumberSpaceToString(
PacketNumberSpace packet_number_space);
// Used to return the result of processing a received ACK frame.
@@ -730,11 +722,11 @@
SEND_TO_WRITER, // Send packet to writer.
};
-QUIC_EXPORT_PRIVATE std::string SerializedPacketFateToString(
+QUICHE_EXPORT std::string SerializedPacketFateToString(
SerializedPacketFate fate);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const SerializedPacketFate fate);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const SerializedPacketFate fate);
// There are three different forms of CONNECTION_CLOSE.
enum QuicConnectionCloseType {
@@ -743,10 +735,10 @@
IETF_QUIC_APPLICATION_CONNECTION_CLOSE = 2
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const QuicConnectionCloseType type);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const QuicConnectionCloseType type);
-QUIC_EXPORT_PRIVATE std::string QuicConnectionCloseTypeString(
+QUICHE_EXPORT std::string QuicConnectionCloseTypeString(
QuicConnectionCloseType type);
// Indicate handshake state of a connection.
@@ -770,7 +762,7 @@
HANDSHAKE_CONFIRMED,
};
-struct QUIC_NO_EXPORT NextReleaseTimeResult {
+struct QUICHE_EXPORT NextReleaseTimeResult {
// The ideal release time of the packet being sent.
QuicTime release_time;
// Whether it is allowed to send the packet before release_time.
@@ -780,7 +772,7 @@
// QuicPacketBuffer bundles a buffer and a function that releases it. Note
// it does not assume ownership of buffer, i.e. it doesn't release the buffer on
// destruction.
-struct QUIC_NO_EXPORT QuicPacketBuffer {
+struct QUICHE_EXPORT QuicPacketBuffer {
QuicPacketBuffer() = default;
QuicPacketBuffer(char* buffer,
@@ -792,7 +784,7 @@
};
// QuicOwnedPacketBuffer is a QuicPacketBuffer that assumes buffer ownership.
-struct QUIC_NO_EXPORT QuicOwnedPacketBuffer : public QuicPacketBuffer {
+struct QUICHE_EXPORT QuicOwnedPacketBuffer : public QuicPacketBuffer {
QuicOwnedPacketBuffer(const QuicOwnedPacketBuffer&) = delete;
QuicOwnedPacketBuffer& operator=(const QuicOwnedPacketBuffer&) = delete;
@@ -827,16 +819,16 @@
kMaxValue = kLocalKeyUpdateLimitOverride,
};
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const KeyUpdateReason reason);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const KeyUpdateReason reason);
-QUIC_EXPORT_PRIVATE std::string KeyUpdateReasonString(KeyUpdateReason reason);
+QUICHE_EXPORT std::string KeyUpdateReasonString(KeyUpdateReason reason);
using QuicSignatureAlgorithmVector = absl::InlinedVector<uint16_t, 8>;
// QuicSSLConfig contains configurations to be applied on a SSL object, which
// overrides the configurations in SSL_CTX.
-struct QUIC_NO_EXPORT QuicSSLConfig {
+struct QUICHE_EXPORT QuicSSLConfig {
// Whether TLS early data should be enabled. If not set, default to enabled.
absl::optional<bool> early_data_enabled;
// Whether TLS session tickets are supported. If not set, default to
@@ -858,7 +850,7 @@
// QuicDelayedSSLConfig contains a subset of SSL config that can be applied
// after BoringSSL's early select certificate callback. This overwrites all SSL
// configs applied before cert selection.
-struct QUIC_NO_EXPORT QuicDelayedSSLConfig {
+struct QUICHE_EXPORT QuicDelayedSSLConfig {
// Client certificate mode for mTLS support. Only used at server side.
// absl::nullopt means do not change client certificate mode.
absl::optional<ClientCertMode> client_cert_mode;
@@ -868,7 +860,7 @@
// ParsedClientHello contains client hello information extracted from a fully
// received client hello.
-struct QUIC_NO_EXPORT ParsedClientHello {
+struct QUICHE_EXPORT ParsedClientHello {
std::string sni; // QUIC crypto and TLS.
std::string uaid; // QUIC crypto only.
std::vector<std::string> alpns; // QUIC crypto and TLS.
@@ -879,11 +871,11 @@
bool early_data_attempted = false; // TLS only.
};
-QUIC_EXPORT_PRIVATE bool operator==(const ParsedClientHello& a,
- const ParsedClientHello& b);
+QUICHE_EXPORT bool operator==(const ParsedClientHello& a,
+ const ParsedClientHello& b);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const ParsedClientHello& parsed_chlo);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const ParsedClientHello& parsed_chlo);
// The two bits in the IP header for Explicit Congestion Notification can take
// one of four values.
@@ -907,7 +899,7 @@
// This struct reports the Explicit Congestion Notification (ECN) contents of
// the ACK_ECN frame. They are the cumulative number of QUIC packets received
// for that codepoint in a given Packet Number Space.
-struct QUIC_EXPORT_PRIVATE QuicEcnCounts {
+struct QUICHE_EXPORT QuicEcnCounts {
QuicEcnCounts() = default;
QuicEcnCounts(QuicPacketCount ect0, QuicPacketCount ect1, QuicPacketCount ce)
: ect0(ect0), ect1(ect1), ce(ce) {}
@@ -937,8 +929,7 @@
};
QUICHE_EXPORT std::string QuicPriorityTypeToString(QuicPriorityType type);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- QuicPriorityType type);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os, QuicPriorityType type);
} // namespace quic
diff --git a/quiche/quic/core/quic_udp_socket.h b/quiche/quic/core/quic_udp_socket.h
index 2541fb0..404563f 100644
--- a/quiche/quic/core/quic_udp_socket.h
+++ b/quiche/quic/core/quic_udp_socket.h
@@ -47,7 +47,7 @@
// BufferSpan points to an unowned buffer, copying this structure only copies
// the pointer and length, not the buffer itself.
-struct QUIC_EXPORT_PRIVATE BufferSpan {
+struct QUICHE_EXPORT BufferSpan {
BufferSpan(char* buffer, size_t buffer_len)
: buffer(buffer), buffer_len(buffer_len) {}
@@ -61,7 +61,7 @@
// QuicUdpPacketInfo contains per-packet information used for sending and
// receiving.
-class QUIC_EXPORT_PRIVATE QuicUdpPacketInfo {
+class QUICHE_EXPORT QuicUdpPacketInfo {
public:
QuicUdpPacketInfoBitMask bitmask() const { return bitmask_; }
@@ -179,7 +179,7 @@
// versions, the goal of QuicUdpSocketApi is to hide such differences.
// We use non-static functions because it is easier to be mocked in tests when
// needed.
-class QUIC_EXPORT_PRIVATE QuicUdpSocketApi {
+class QUICHE_EXPORT QuicUdpSocketApi {
public:
// Creates a non-blocking udp socket, sets the receive/send buffer and enable
// receiving of self ip addresses on read.
@@ -215,7 +215,7 @@
// Return true if |fd| is readable upon return.
bool WaitUntilReadable(QuicUdpSocketFd fd, QuicTime::Delta timeout);
- struct QUIC_EXPORT_PRIVATE ReadPacketResult {
+ struct QUICHE_EXPORT ReadPacketResult {
bool ok = false;
QuicUdpPacketInfo packet_info;
BufferSpan packet_buffer;
diff --git a/quiche/quic/core/quic_unacked_packet_map.h b/quiche/quic/core/quic_unacked_packet_map.h
index 143fa5f..67ed28d 100644
--- a/quiche/quic/core/quic_unacked_packet_map.h
+++ b/quiche/quic/core/quic_unacked_packet_map.h
@@ -27,7 +27,7 @@
// 1) Track retransmittable data, including multiple transmissions of frames.
// 2) Track packets and bytes in flight for congestion control.
// 3) Track sent time of packets to provide RTT measurements from acks.
-class QUIC_EXPORT_PRIVATE QuicUnackedPacketMap {
+class QUICHE_EXPORT QuicUnackedPacketMap {
public:
QuicUnackedPacketMap(Perspective perspective);
QuicUnackedPacketMap(const QuicUnackedPacketMap&) = delete;
diff --git a/quiche/quic/core/quic_utils.h b/quiche/quic/core/quic_utils.h
index 4c3fdc9..761914e 100644
--- a/quiche/quic/core/quic_utils.h
+++ b/quiche/quic/core/quic_utils.h
@@ -29,7 +29,7 @@
namespace quic {
-class QUIC_EXPORT_PRIVATE QuicUtils {
+class QUICHE_EXPORT QuicUtils {
public:
QuicUtils() = delete;
@@ -227,13 +227,13 @@
QuicByteCount MemSliceSpanTotalSize(absl::Span<quiche::QuicheMemSlice> span);
// Computes a SHA-256 hash and returns the raw bytes of the hash.
-QUIC_EXPORT_PRIVATE std::string RawSha256(absl::string_view input);
+QUICHE_EXPORT std::string RawSha256(absl::string_view input);
// BitMask<Index, Mask> is a set of elements of type `Index` represented as a
// bitmask of an underlying integer type `Mask` (uint64_t by default). The
// underlying type has to be large enough to fit all possible values of `Index`.
template <typename Index, typename Mask = uint64_t>
-class QUIC_EXPORT_PRIVATE BitMask {
+class QUICHE_EXPORT BitMask {
public:
explicit constexpr BitMask(std::initializer_list<Index> bits) {
for (Index bit : bits) {
diff --git a/quiche/quic/core/quic_version_manager.h b/quiche/quic/core/quic_version_manager.h
index 5beee79..c6c983b 100644
--- a/quiche/quic/core/quic_version_manager.h
+++ b/quiche/quic/core/quic_version_manager.h
@@ -11,7 +11,7 @@
namespace quic {
// Used to generate filtered supported versions based on flags.
-class QUIC_EXPORT_PRIVATE QuicVersionManager {
+class QUICHE_EXPORT QuicVersionManager {
public:
// |supported_versions| should be sorted in the order of preference (typically
// highest supported version to the lowest supported version).
diff --git a/quiche/quic/core/quic_versions.h b/quiche/quic/core/quic_versions.h
index 7cd31be..8958e33 100644
--- a/quiche/quic/core/quic_versions.h
+++ b/quiche/quic/core/quic_versions.h
@@ -140,7 +140,7 @@
// Helper function which translates from a QuicTransportVersion to a string.
// Returns strings corresponding to enum names (e.g. QUIC_VERSION_6).
-QUIC_EXPORT_PRIVATE std::string QuicVersionToString(
+QUICHE_EXPORT std::string QuicVersionToString(
QuicTransportVersion transport_version);
// The crypto handshake protocols that can be used with QUIC.
@@ -153,12 +153,12 @@
};
// Helper function which translates from a HandshakeProtocol to a string.
-QUIC_EXPORT_PRIVATE std::string HandshakeProtocolToString(
+QUICHE_EXPORT std::string HandshakeProtocolToString(
HandshakeProtocol handshake_protocol);
// Returns whether |transport_version| uses CRYPTO frames for the handshake
// instead of stream 1.
-QUIC_EXPORT_PRIVATE constexpr bool QuicVersionUsesCryptoFrames(
+QUICHE_EXPORT constexpr bool QuicVersionUsesCryptoFrames(
QuicTransportVersion transport_version) {
// CRYPTO frames were added in version 48.
return transport_version > QUIC_VERSION_46;
@@ -168,7 +168,7 @@
// version is allowed. For example, {PROTOCOL_TLS1_3, QUIC_VERSION_46} is NOT
// allowed as TLS requires crypto frames which v46 does not support. Note that
// UnsupportedQuicVersion is a valid version.
-QUIC_EXPORT_PRIVATE constexpr bool ParsedQuicVersionIsValid(
+QUICHE_EXPORT constexpr bool ParsedQuicVersionIsValid(
HandshakeProtocol handshake_protocol,
QuicTransportVersion transport_version) {
bool transport_version_is_valid = false;
@@ -209,7 +209,7 @@
// A parsed QUIC version label which determines that handshake protocol
// and the transport version.
-struct QUIC_EXPORT_PRIVATE ParsedQuicVersion {
+struct QUICHE_EXPORT ParsedQuicVersion {
HandshakeProtocol handshake_protocol;
QuicTransportVersion transport_version;
@@ -368,17 +368,17 @@
bool AlpnDeferToRFCv1() const;
};
-QUIC_EXPORT_PRIVATE ParsedQuicVersion UnsupportedQuicVersion();
+QUICHE_EXPORT ParsedQuicVersion UnsupportedQuicVersion();
-QUIC_EXPORT_PRIVATE ParsedQuicVersion QuicVersionReservedForNegotiation();
+QUICHE_EXPORT ParsedQuicVersion QuicVersionReservedForNegotiation();
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
- const ParsedQuicVersion& version);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const ParsedQuicVersion& version);
using ParsedQuicVersionVector = std::vector<ParsedQuicVersion>;
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os, const ParsedQuicVersionVector& versions);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const ParsedQuicVersionVector& versions);
// Representation of the on-the-wire QUIC version number. Will be written/read
// to the wire in network-byte-order.
@@ -387,10 +387,10 @@
// Constructs a version label from the 4 bytes such that the on-the-wire
// order will be: d, c, b, a.
-QUIC_EXPORT_PRIVATE QuicVersionLabel MakeVersionLabel(uint8_t a, uint8_t b,
- uint8_t c, uint8_t d);
+QUICHE_EXPORT QuicVersionLabel MakeVersionLabel(uint8_t a, uint8_t b, uint8_t c,
+ uint8_t d);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicVersionLabelVector& version_labels);
// This vector contains all crypto handshake protocols that are supported.
@@ -408,72 +408,70 @@
using QuicTransportVersionVector = std::vector<QuicTransportVersion>;
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(
std::ostream& os, const QuicTransportVersionVector& transport_versions);
// Returns a vector of supported QUIC versions.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector AllSupportedVersions();
+QUICHE_EXPORT ParsedQuicVersionVector AllSupportedVersions();
// Returns a vector of supported QUIC versions, with any versions disabled by
// flags excluded.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector CurrentSupportedVersions();
+QUICHE_EXPORT ParsedQuicVersionVector CurrentSupportedVersions();
// Returns a vector of QUIC versions from |versions| which exclude any versions
// which are disabled by flags.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
+QUICHE_EXPORT ParsedQuicVersionVector
FilterSupportedVersions(ParsedQuicVersionVector versions);
// Returns a subset of AllSupportedVersions() with
// handshake_protocol == PROTOCOL_QUIC_CRYPTO, in the same order.
// Deprecated; only to be used in components that do not yet support
// PROTOCOL_TLS1_3.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
-AllSupportedVersionsWithQuicCrypto();
+QUICHE_EXPORT ParsedQuicVersionVector AllSupportedVersionsWithQuicCrypto();
// Returns a subset of CurrentSupportedVersions() with
// handshake_protocol == PROTOCOL_QUIC_CRYPTO, in the same order.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
-CurrentSupportedVersionsWithQuicCrypto();
+QUICHE_EXPORT ParsedQuicVersionVector CurrentSupportedVersionsWithQuicCrypto();
// Returns a subset of AllSupportedVersions() with
// handshake_protocol == PROTOCOL_TLS1_3, in the same order.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector AllSupportedVersionsWithTls();
+QUICHE_EXPORT ParsedQuicVersionVector AllSupportedVersionsWithTls();
// Returns a subset of CurrentSupportedVersions() with handshake_protocol ==
// PROTOCOL_TLS1_3.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector CurrentSupportedVersionsWithTls();
+QUICHE_EXPORT ParsedQuicVersionVector CurrentSupportedVersionsWithTls();
// Returns a subset of CurrentSupportedVersions() using HTTP/3 at the HTTP
// layer.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector CurrentSupportedHttp3Versions();
+QUICHE_EXPORT ParsedQuicVersionVector CurrentSupportedHttp3Versions();
// Returns QUIC version of |index| in result of |versions|. Returns
// UnsupportedQuicVersion() if |index| is out of bounds.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
+QUICHE_EXPORT ParsedQuicVersionVector
ParsedVersionOfIndex(const ParsedQuicVersionVector& versions, int index);
// QuicVersionLabel is written to and read from the wire, but we prefer to use
// the more readable ParsedQuicVersion at other levels.
// Helper function which translates from a QuicVersionLabel to a
// ParsedQuicVersion.
-QUIC_EXPORT_PRIVATE ParsedQuicVersion
+QUICHE_EXPORT ParsedQuicVersion
ParseQuicVersionLabel(QuicVersionLabel version_label);
// Helper function that translates from a QuicVersionLabelVector to a
// ParsedQuicVersionVector.
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
+QUICHE_EXPORT ParsedQuicVersionVector
ParseQuicVersionLabelVector(const QuicVersionLabelVector& version_labels);
// Parses a QUIC version string such as "Q043" or "T051". Also supports parsing
// ALPN such as "h3-29" or "h3-Q050". For PROTOCOL_QUIC_CRYPTO versions, also
// supports parsing numbers such as "46".
-QUIC_EXPORT_PRIVATE ParsedQuicVersion
+QUICHE_EXPORT ParsedQuicVersion
ParseQuicVersionString(absl::string_view version_string);
// Parses a comma-separated list of QUIC version strings. Supports parsing by
// label, ALPN and numbers for PROTOCOL_QUIC_CRYPTO. Skips unknown versions.
// For example: "h3-29,Q050,46".
-QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
+QUICHE_EXPORT ParsedQuicVersionVector
ParseQuicVersionVectorString(absl::string_view versions_string);
// Constructs a QuicVersionLabel from the provided ParsedQuicVersion.
@@ -481,16 +479,16 @@
// the more readable ParsedQuicVersion at other levels.
// Helper function which translates from a ParsedQuicVersion to a
// QuicVersionLabel. Returns 0 if |parsed_version| is unsupported.
-QUIC_EXPORT_PRIVATE QuicVersionLabel
+QUICHE_EXPORT QuicVersionLabel
CreateQuicVersionLabel(ParsedQuicVersion parsed_version);
// Constructs a QuicVersionLabelVector from the provided
// ParsedQuicVersionVector.
-QUIC_EXPORT_PRIVATE QuicVersionLabelVector
+QUICHE_EXPORT QuicVersionLabelVector
CreateQuicVersionLabelVector(const ParsedQuicVersionVector& versions);
// Helper function which translates from a QuicVersionLabel to a string.
-QUIC_EXPORT_PRIVATE std::string QuicVersionLabelToString(
+QUICHE_EXPORT std::string QuicVersionLabelToString(
QuicVersionLabel version_label);
// Helper function which translates from a QuicVersionLabel string to a
@@ -499,19 +497,19 @@
// "51303433" (the hex encoding of the Q064 version label). Returns
// the ParsedQuicVersion which matches the label or UnsupportedQuicVersion()
// otherwise.
-QUIC_EXPORT_PRIVATE ParsedQuicVersion
+QUICHE_EXPORT ParsedQuicVersion
ParseQuicVersionLabelString(absl::string_view version_label_string);
// Returns |separator|-separated list of string representations of
// QuicVersionLabel values in the supplied |version_labels| vector. The values
// after the (0-based) |skip_after_nth_version|'th are skipped.
-QUIC_EXPORT_PRIVATE std::string QuicVersionLabelVectorToString(
+QUICHE_EXPORT std::string QuicVersionLabelVectorToString(
const QuicVersionLabelVector& version_labels, const std::string& separator,
size_t skip_after_nth_version);
// Returns comma separated list of string representations of QuicVersionLabel
// values in the supplied |version_labels| vector.
-QUIC_EXPORT_PRIVATE inline std::string QuicVersionLabelVectorToString(
+QUICHE_EXPORT inline std::string QuicVersionLabelVectorToString(
const QuicVersionLabelVector& version_labels) {
return QuicVersionLabelVectorToString(version_labels, ",",
std::numeric_limits<size_t>::max());
@@ -519,33 +517,32 @@
// Helper function which translates from a ParsedQuicVersion to a string.
// Returns strings corresponding to the on-the-wire tag.
-QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionToString(
- ParsedQuicVersion version);
+QUICHE_EXPORT std::string ParsedQuicVersionToString(ParsedQuicVersion version);
// Returns a vector of supported QUIC transport versions. DEPRECATED, use
// AllSupportedVersions instead.
-QUIC_EXPORT_PRIVATE QuicTransportVersionVector AllSupportedTransportVersions();
+QUICHE_EXPORT QuicTransportVersionVector AllSupportedTransportVersions();
// Returns comma separated list of string representations of
// QuicTransportVersion enum values in the supplied |versions| vector.
-QUIC_EXPORT_PRIVATE std::string QuicTransportVersionVectorToString(
+QUICHE_EXPORT std::string QuicTransportVersionVectorToString(
const QuicTransportVersionVector& versions);
// Returns comma separated list of string representations of ParsedQuicVersion
// values in the supplied |versions| vector.
-QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionVectorToString(
+QUICHE_EXPORT std::string ParsedQuicVersionVectorToString(
const ParsedQuicVersionVector& versions);
// Returns |separator|-separated list of string representations of
// ParsedQuicVersion values in the supplied |versions| vector. The values after
// the (0-based) |skip_after_nth_version|'th are skipped.
-QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionVectorToString(
+QUICHE_EXPORT std::string ParsedQuicVersionVectorToString(
const ParsedQuicVersionVector& versions, const std::string& separator,
size_t skip_after_nth_version);
// Returns comma separated list of string representations of ParsedQuicVersion
// values in the supplied |versions| vector.
-QUIC_EXPORT_PRIVATE inline std::string ParsedQuicVersionVectorToString(
+QUICHE_EXPORT inline std::string ParsedQuicVersionVectorToString(
const ParsedQuicVersionVector& versions) {
return ParsedQuicVersionVectorToString(versions, ",",
std::numeric_limits<size_t>::max());
@@ -560,14 +557,14 @@
// * HEADERS frames are compressed using QPACK.
// * DATA frame has frame headers.
// * GOAWAY is moved to HTTP layer.
-QUIC_EXPORT_PRIVATE constexpr bool VersionUsesHttp3(
+QUICHE_EXPORT constexpr bool VersionUsesHttp3(
QuicTransportVersion transport_version) {
return transport_version >= QUIC_VERSION_IETF_DRAFT_29;
}
// Returns whether the transport_version supports the variable length integer
// length field as defined by IETF QUIC draft-13 and later.
-QUIC_EXPORT_PRIVATE constexpr bool QuicVersionHasLongHeaderLengths(
+QUICHE_EXPORT constexpr bool QuicVersionHasLongHeaderLengths(
QuicTransportVersion transport_version) {
// Long header lengths were added in version 49.
return transport_version > QUIC_VERSION_46;
@@ -575,7 +572,7 @@
// Returns whether |transport_version| makes use of IETF QUIC
// frames or not.
-QUIC_EXPORT_PRIVATE constexpr bool VersionHasIetfQuicFrames(
+QUICHE_EXPORT constexpr bool VersionHasIetfQuicFrames(
QuicTransportVersion transport_version) {
return VersionUsesHttp3(transport_version);
}
@@ -583,41 +580,40 @@
// Returns whether this version supports long header 8-bit encoded
// connection ID lengths as described in draft-ietf-quic-invariants-06 and
// draft-ietf-quic-transport-22.
-QUIC_EXPORT_PRIVATE bool VersionHasLengthPrefixedConnectionIds(
+QUICHE_EXPORT bool VersionHasLengthPrefixedConnectionIds(
QuicTransportVersion transport_version);
// Returns true if this version supports the old Google-style Alt-Svc
// advertisement format.
-QUIC_EXPORT_PRIVATE bool VersionSupportsGoogleAltSvcFormat(
+QUICHE_EXPORT bool VersionSupportsGoogleAltSvcFormat(
QuicTransportVersion transport_version);
// Returns whether this version allows server connection ID lengths that are
// not 64 bits.
-QUIC_EXPORT_PRIVATE bool VersionAllowsVariableLengthConnectionIds(
+QUICHE_EXPORT bool VersionAllowsVariableLengthConnectionIds(
QuicTransportVersion transport_version);
// Returns whether this version label supports long header 4-bit encoded
// connection ID lengths as described in draft-ietf-quic-invariants-05 and
// draft-ietf-quic-transport-21.
-QUIC_EXPORT_PRIVATE bool QuicVersionLabelUses4BitConnectionIdLength(
+QUICHE_EXPORT bool QuicVersionLabelUses4BitConnectionIdLength(
QuicVersionLabel version_label);
// Returns the ALPN string to use in TLS for this version of QUIC.
-QUIC_EXPORT_PRIVATE std::string AlpnForVersion(
- ParsedQuicVersion parsed_version);
+QUICHE_EXPORT std::string AlpnForVersion(ParsedQuicVersion parsed_version);
// Initializes support for the provided IETF draft version by setting the
// correct flags.
-QUIC_EXPORT_PRIVATE void QuicVersionInitializeSupportForIetfDraft();
+QUICHE_EXPORT void QuicVersionInitializeSupportForIetfDraft();
// Configures the flags required to enable support for this version of QUIC.
-QUIC_EXPORT_PRIVATE void QuicEnableVersion(const ParsedQuicVersion& version);
+QUICHE_EXPORT void QuicEnableVersion(const ParsedQuicVersion& version);
// Configures the flags required to disable support for this version of QUIC.
-QUIC_EXPORT_PRIVATE void QuicDisableVersion(const ParsedQuicVersion& version);
+QUICHE_EXPORT void QuicDisableVersion(const ParsedQuicVersion& version);
// Returns whether support for this version of QUIC is currently enabled.
-QUIC_EXPORT_PRIVATE bool QuicVersionIsEnabled(const ParsedQuicVersion& version);
+QUICHE_EXPORT bool QuicVersionIsEnabled(const ParsedQuicVersion& version);
} // namespace quic
diff --git a/quiche/quic/core/quic_write_blocked_list.h b/quiche/quic/core/quic_write_blocked_list.h
index 1c7f25a..3c3645f 100644
--- a/quiche/quic/core/quic_write_blocked_list.h
+++ b/quiche/quic/core/quic_write_blocked_list.h
@@ -75,7 +75,7 @@
};
// Default implementation of QuicWriteBlockedListInterface.
-class QUIC_EXPORT_PRIVATE QuicWriteBlockedList
+class QUICHE_EXPORT QuicWriteBlockedList
: public QuicWriteBlockedListInterface {
public:
explicit QuicWriteBlockedList();
@@ -166,9 +166,9 @@
// A StaticStreamCollection is a vector of <QuicStreamId, bool> pairs plus a
// eagerly-computed number of blocked static streams.
- class QUIC_EXPORT_PRIVATE StaticStreamCollection {
+ class QUICHE_EXPORT StaticStreamCollection {
public:
- struct QUIC_EXPORT_PRIVATE StreamIdBlockedPair {
+ struct QUICHE_EXPORT StreamIdBlockedPair {
QuicStreamId id;
bool is_blocked;
};
diff --git a/quiche/quic/core/session_notifier_interface.h b/quiche/quic/core/session_notifier_interface.h
index ee4453a..fcf7937 100644
--- a/quiche/quic/core/session_notifier_interface.h
+++ b/quiche/quic/core/session_notifier_interface.h
@@ -12,7 +12,7 @@
// Pure virtual class to be notified when a packet containing a frame is acked
// or lost.
-class QUIC_EXPORT_PRIVATE SessionNotifierInterface {
+class QUICHE_EXPORT SessionNotifierInterface {
public:
virtual ~SessionNotifierInterface() {}
diff --git a/quiche/quic/core/stream_delegate_interface.h b/quiche/quic/core/stream_delegate_interface.h
index a5f03f0..5a89f82 100644
--- a/quiche/quic/core/stream_delegate_interface.h
+++ b/quiche/quic/core/stream_delegate_interface.h
@@ -17,7 +17,7 @@
// Pure virtual class to get notified when particular QuicStream events
// occurred.
-class QUIC_EXPORT_PRIVATE StreamDelegateInterface {
+class QUICHE_EXPORT StreamDelegateInterface {
public:
virtual ~StreamDelegateInterface() {}
diff --git a/quiche/quic/core/tls_chlo_extractor.h b/quiche/quic/core/tls_chlo_extractor.h
index f24023b..55b0142 100644
--- a/quiche/quic/core/tls_chlo_extractor.h
+++ b/quiche/quic/core/tls_chlo_extractor.h
@@ -26,7 +26,7 @@
// then uses a QuicStreamSequencer to reassemble the contents of the crypto
// stream, and implements QuicStreamSequencer::StreamInterface to access the
// reassembled data.
-class QUIC_NO_EXPORT TlsChloExtractor
+class QUICHE_EXPORT TlsChloExtractor
: public QuicFramerVisitorInterface,
public QuicStreamSequencer::StreamInterface {
public:
@@ -271,8 +271,8 @@
};
// Convenience method to facilitate logging TlsChloExtractor::State.
-QUIC_NO_EXPORT std::ostream& operator<<(std::ostream& os,
- const TlsChloExtractor::State& state);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+ const TlsChloExtractor::State& state);
} // namespace quic
diff --git a/quiche/quic/core/tls_client_handshaker.h b/quiche/quic/core/tls_client_handshaker.h
index dd7e393..eaea623 100644
--- a/quiche/quic/core/tls_client_handshaker.h
+++ b/quiche/quic/core/tls_client_handshaker.h
@@ -23,7 +23,7 @@
// An implementation of QuicCryptoClientStream::HandshakerInterface which uses
// TLS 1.3 for the crypto handshake protocol.
-class QUIC_EXPORT_PRIVATE TlsClientHandshaker
+class QUICHE_EXPORT TlsClientHandshaker
: public TlsHandshaker,
public QuicCryptoClientStream::HandshakerInterface,
public TlsClientConnection::Delegate {
diff --git a/quiche/quic/core/tls_handshaker.h b/quiche/quic/core/tls_handshaker.h
index 0c7aa5d..71bede1 100644
--- a/quiche/quic/core/tls_handshaker.h
+++ b/quiche/quic/core/tls_handshaker.h
@@ -26,8 +26,8 @@
// provides functionality common to both the client and server, such as moving
// messages between the TLS stack and the QUIC crypto stream, and handling
// derivation of secrets.
-class QUIC_EXPORT_PRIVATE TlsHandshaker : public TlsConnection::Delegate,
- public CryptoMessageParser {
+class QUICHE_EXPORT TlsHandshaker : public TlsConnection::Delegate,
+ public CryptoMessageParser {
public:
// TlsHandshaker does not take ownership of any of its arguments; they must
// outlive the TlsHandshaker.
@@ -175,8 +175,7 @@
private:
// ProofVerifierCallbackImpl handles the result of an asynchronous certificate
// verification operation.
- class QUIC_EXPORT_PRIVATE ProofVerifierCallbackImpl
- : public ProofVerifierCallback {
+ class QUICHE_EXPORT ProofVerifierCallbackImpl : public ProofVerifierCallback {
public:
explicit ProofVerifierCallbackImpl(TlsHandshaker* parent);
~ProofVerifierCallbackImpl() override;
diff --git a/quiche/quic/core/tls_server_handshaker.h b/quiche/quic/core/tls_server_handshaker.h
index 9863ea7..4506369 100644
--- a/quiche/quic/core/tls_server_handshaker.h
+++ b/quiche/quic/core/tls_server_handshaker.h
@@ -27,11 +27,10 @@
// An implementation of QuicCryptoServerStreamBase which uses
// TLS 1.3 for the crypto handshake protocol.
-class QUIC_EXPORT_PRIVATE TlsServerHandshaker
- : public TlsHandshaker,
- public TlsServerConnection::Delegate,
- public ProofSourceHandleCallback,
- public QuicCryptoServerStreamBase {
+class QUICHE_EXPORT TlsServerHandshaker : public TlsHandshaker,
+ public TlsServerConnection::Delegate,
+ public ProofSourceHandleCallback,
+ public QuicCryptoServerStreamBase {
public:
// |crypto_config| must outlive TlsServerHandshaker.
TlsServerHandshaker(QuicSession* session,
@@ -194,8 +193,7 @@
void SetIgnoreTicketOpen(bool value) { ignore_ticket_open_ = value; }
private:
- class QUIC_EXPORT_PRIVATE DecryptCallback
- : public ProofSource::DecryptCallback {
+ class QUICHE_EXPORT DecryptCallback : public ProofSource::DecryptCallback {
public:
explicit DecryptCallback(TlsServerHandshaker* handshaker);
void Run(std::vector<uint8_t> plaintext) override;
@@ -214,8 +212,7 @@
// DefaultProofSourceHandle delegates all operations to the shared proof
// source.
- class QUIC_EXPORT_PRIVATE DefaultProofSourceHandle
- : public ProofSourceHandle {
+ class QUICHE_EXPORT DefaultProofSourceHandle : public ProofSourceHandle {
public:
DefaultProofSourceHandle(TlsServerHandshaker* handshaker,
ProofSource* proof_source);
@@ -251,7 +248,7 @@
ProofSourceHandleCallback* callback() override { return handshaker_; }
private:
- class QUIC_EXPORT_PRIVATE DefaultSignatureCallback
+ class QUICHE_EXPORT DefaultSignatureCallback
: public ProofSource::SignatureCallback {
public:
explicit DefaultSignatureCallback(DefaultProofSourceHandle* handle)
@@ -291,7 +288,7 @@
DefaultSignatureCallback* signature_callback_ = nullptr;
};
- struct QUIC_NO_EXPORT SetTransportParametersResult {
+ struct QUICHE_EXPORT SetTransportParametersResult {
bool success = false;
// Empty vector if QUIC transport params are not set successfully.
std::vector<uint8_t> quic_transport_params;
@@ -308,7 +305,7 @@
bool TransportParametersMatch(
absl::Span<const uint8_t> serialized_params) const;
- struct QUIC_NO_EXPORT SetApplicationSettingsResult {
+ struct QUICHE_EXPORT SetApplicationSettingsResult {
bool success = false;
// TODO(b/239676439): Change type to absl::optional<std::string> and make
// sure SetApplicationSettings() returns nullopt if no ALPS data.
diff --git a/quiche/quic/core/uber_quic_stream_id_manager.h b/quiche/quic/core/uber_quic_stream_id_manager.h
index e6b73d0..7b836d4 100644
--- a/quiche/quic/core/uber_quic_stream_id_manager.h
+++ b/quiche/quic/core/uber_quic_stream_id_manager.h
@@ -19,7 +19,7 @@
// This class comprises two QuicStreamIdManagers, which manage bidirectional and
// unidirectional stream IDs, respectively.
-class QUIC_EXPORT_PRIVATE UberQuicStreamIdManager {
+class QUICHE_EXPORT UberQuicStreamIdManager {
public:
UberQuicStreamIdManager(
Perspective perspective, ParsedQuicVersion version,
diff --git a/quiche/quic/core/uber_received_packet_manager.h b/quiche/quic/core/uber_received_packet_manager.h
index d4d35bc..7f4c7cc 100644
--- a/quiche/quic/core/uber_received_packet_manager.h
+++ b/quiche/quic/core/uber_received_packet_manager.h
@@ -13,7 +13,7 @@
// This class comprises multiple received packet managers, one per packet number
// space. Please note, if multiple packet number spaces is not supported, only
// one received packet manager will be used.
-class QUIC_EXPORT_PRIVATE UberReceivedPacketManager {
+class QUICHE_EXPORT UberReceivedPacketManager {
public:
explicit UberReceivedPacketManager(QuicConnectionStats* stats);
UberReceivedPacketManager(const UberReceivedPacketManager&) = delete;
