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;