diff --git a/quiche/balsa/balsa_enums.h b/quiche/balsa/balsa_enums.h
index 34bfd4d..07a46bf 100644
--- a/quiche/balsa/balsa_enums.h
+++ b/quiche/balsa/balsa_enums.h
@@ -9,7 +9,7 @@
 
 namespace quiche {
 
-struct QUICHE_EXPORT_PRIVATE BalsaFrameEnums {
+struct QUICHE_EXPORT BalsaFrameEnums {
   enum ParseState : int {
     ERROR,
     READING_HEADER_AND_FIRSTLINE,
@@ -112,7 +112,7 @@
   static const char* ErrorCodeToString(ErrorCode error_code);
 };
 
-struct QUICHE_EXPORT_PRIVATE BalsaHeadersEnums {
+struct QUICHE_EXPORT BalsaHeadersEnums {
   enum ContentLengthStatus : int {
     INVALID_CONTENT_LENGTH,
     CONTENT_LENGTH_OVERFLOW,
diff --git a/quiche/balsa/balsa_frame.h b/quiche/balsa/balsa_frame.h
index 70d3aaf..a698298 100644
--- a/quiche/balsa/balsa_frame.h
+++ b/quiche/balsa/balsa_frame.h
@@ -28,7 +28,7 @@
 }  // namespace test
 
 // BalsaFrame is a lightweight HTTP framer.
-class QUICHE_EXPORT_PRIVATE BalsaFrame : public FramerInterface {
+class QUICHE_EXPORT BalsaFrame : public FramerInterface {
  public:
   typedef std::vector<std::pair<size_t, size_t> > Lines;
 
diff --git a/quiche/balsa/balsa_headers.h b/quiche/balsa/balsa_headers.h
index 3287cc0..106b3d7 100644
--- a/quiche/balsa/balsa_headers.h
+++ b/quiche/balsa/balsa_headers.h
@@ -75,7 +75,7 @@
 //    - at this point, perhaps just use a vector of strings, and let
 //      the allocator do the right thing.
 //
-class QUICHE_EXPORT_PRIVATE BalsaBuffer {
+class QUICHE_EXPORT BalsaBuffer {
  public:
   static constexpr size_t kDefaultBlocksize = 4096;
 
@@ -85,7 +85,7 @@
   // sizes and bytes free. It *may* be possible to replace this
   // with a vector<char>, but it's unclear whether moving a vector
   // can invalidate pointers into it. LWG issue 2321 proposes to fix this.
-  struct QUICHE_EXPORT_PRIVATE BufferBlock {
+  struct QUICHE_EXPORT BufferBlock {
    public:
     std::unique_ptr<char[]> buffer;
     size_t buffer_size = 0;
@@ -362,13 +362,13 @@
 //
 //  Key comparisons are case-insensitive.
 
-class QUICHE_EXPORT_PRIVATE BalsaHeaders : public HeaderApi {
+class QUICHE_EXPORT BalsaHeaders : public HeaderApi {
  public:
   // Each header line is parsed into a HeaderLineDescription, which maintains
   // pointers into the BalsaBuffer.
   //
   // Succinctly describes one header line as indices into a buffer.
-  struct QUICHE_EXPORT_PRIVATE HeaderLineDescription {
+  struct QUICHE_EXPORT HeaderLineDescription {
     HeaderLineDescription(size_t first_character_index, size_t key_end_index,
                           size_t value_begin_index, size_t last_character_index,
                           size_t buffer_base_index)
@@ -418,7 +418,7 @@
 
   // A simple class that can be used in a range-based for loop.
   template <typename IteratorType>
-  class QUICHE_EXPORT_PRIVATE iterator_range {
+  class QUICHE_EXPORT iterator_range {
    public:
     using iterator = IteratorType;
     using const_iterator = IteratorType;
@@ -1180,7 +1180,7 @@
 
 // Base class for iterating the headers in a BalsaHeaders object, returning a
 // pair of string_view's for each header.
-class QUICHE_EXPORT_PRIVATE BalsaHeaders::iterator_base
+class QUICHE_EXPORT BalsaHeaders::iterator_base
     : public std::iterator<std::forward_iterator_tag,
                            std::pair<absl::string_view, absl::string_view>> {
  public:
@@ -1223,8 +1223,8 @@
   // operator<< work for the classes it sees.  It would be better if there
   // was an additional traits-like system for the gUnit output... but oh
   // well.
-  friend QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
-      std::ostream& os, const iterator_base& it) {
+  friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+                                                const iterator_base& it) {
     os << "[" << it.headers_ << ", " << it.idx_ << "]";
     return os;
   }
@@ -1276,7 +1276,7 @@
 };
 
 // A const iterator for all the header lines.
-class QUICHE_EXPORT_PRIVATE BalsaHeaders::const_header_lines_iterator
+class QUICHE_EXPORT BalsaHeaders::const_header_lines_iterator
     : public BalsaHeaders::iterator_base {
  public:
   const_header_lines_iterator() : iterator_base() {}
@@ -1295,7 +1295,7 @@
 };
 
 // A const iterator that stops only on header lines for a particular key.
-class QUICHE_EXPORT_PRIVATE BalsaHeaders::const_header_lines_key_iterator
+class QUICHE_EXPORT BalsaHeaders::const_header_lines_key_iterator
     : public BalsaHeaders::iterator_base {
  public:
   const_header_lines_key_iterator& operator++() {
diff --git a/quiche/balsa/balsa_visitor_interface.h b/quiche/balsa/balsa_visitor_interface.h
index 7dc9de7..74aed5c 100644
--- a/quiche/balsa/balsa_visitor_interface.h
+++ b/quiche/balsa/balsa_visitor_interface.h
@@ -21,7 +21,7 @@
 // BalsaFrame, then you should subclass it, and set an instantiation of your
 // subclass as the current visitor for the BalsaFrame class using
 // BalsaFrame::set_visitor().
-class QUICHE_EXPORT_PRIVATE BalsaVisitorInterface {
+class QUICHE_EXPORT BalsaVisitorInterface {
  public:
   virtual ~BalsaVisitorInterface() {}
 
diff --git a/quiche/balsa/framer_interface.h b/quiche/balsa/framer_interface.h
index eaa143b..fdb0f7d 100644
--- a/quiche/balsa/framer_interface.h
+++ b/quiche/balsa/framer_interface.h
@@ -13,7 +13,7 @@
 
 // A minimal interface supported by BalsaFrame and other framer types. For use
 // in HttpReader.
-class QUICHE_EXPORT_PRIVATE FramerInterface {
+class QUICHE_EXPORT FramerInterface {
  public:
   virtual ~FramerInterface() {}
   virtual size_t ProcessInput(const char* input, size_t length) = 0;
diff --git a/quiche/balsa/header_api.h b/quiche/balsa/header_api.h
index 09789f5..889c984 100644
--- a/quiche/balsa/header_api.h
+++ b/quiche/balsa/header_api.h
@@ -36,7 +36,7 @@
 // already lowercaseified. It's faster to avoid converting them to and from
 // lowercase. Additionally, some implementations of ConstHeaderApi might take
 // advantage of a constant-time lookup for inlined headers.
-class QUICHE_EXPORT_PRIVATE ConstHeaderApi {
+class QUICHE_EXPORT ConstHeaderApi {
  public:
   virtual ~ConstHeaderApi() {}
 
@@ -186,7 +186,7 @@
 //
 // Operations on header keys are case-insensitive while operations on header
 // values are case-sensitive.
-class QUICHE_EXPORT_PRIVATE HeaderApi : public virtual ConstHeaderApi {
+class QUICHE_EXPORT HeaderApi : public virtual ConstHeaderApi {
  public:
   // Replaces header entries with key |key| if they exist, or appends
   // a new header if none exist.
diff --git a/quiche/balsa/header_properties.h b/quiche/balsa/header_properties.h
index f94eaa2..cbd5c59 100644
--- a/quiche/balsa/header_properties.h
+++ b/quiche/balsa/header_properties.h
@@ -16,7 +16,7 @@
 // practices) indicates that header can have multiple values. Note that nothing
 // stops clients from sending multiple values of other headers, so this may not
 // be perfectly reliable in practice.
-QUICHE_EXPORT_PRIVATE bool IsMultivaluedHeader(absl::string_view header);
+QUICHE_EXPORT bool IsMultivaluedHeader(absl::string_view header);
 
 // An array of characters that are invalid in HTTP header field names.
 // These are control characters, including \t, \n, \r, as well as space and
@@ -39,11 +39,11 @@
     0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x7F};
 
 // Returns true if the given `c` is invalid in a header field name.
-QUICHE_EXPORT_PRIVATE bool IsInvalidHeaderKeyChar(uint8_t c);
+QUICHE_EXPORT bool IsInvalidHeaderKeyChar(uint8_t c);
 // Returns true if the given `c` is invalid in a header field or the `value` has
 // invalid characters.
-QUICHE_EXPORT_PRIVATE bool IsInvalidHeaderChar(uint8_t c);
-QUICHE_EXPORT_PRIVATE bool HasInvalidHeaderChars(absl::string_view value);
+QUICHE_EXPORT bool IsInvalidHeaderChar(uint8_t c);
+QUICHE_EXPORT bool HasInvalidHeaderChars(absl::string_view value);
 
 }  // namespace quiche::header_properties
 
diff --git a/quiche/balsa/http_validation_policy.h b/quiche/balsa/http_validation_policy.h
index b51b1d5..89926c6 100644
--- a/quiche/balsa/http_validation_policy.h
+++ b/quiche/balsa/http_validation_policy.h
@@ -14,7 +14,7 @@
 // An HttpValidationPolicy captures policy choices affecting parsing of HTTP
 // requests.  It offers individual Boolean member functions to be consulted
 // during the parsing of an HTTP request.
-class QUICHE_EXPORT_PRIVATE HttpValidationPolicy {
+class QUICHE_EXPORT HttpValidationPolicy {
  public:
   HttpValidationPolicy(bool enforce_all);
 
@@ -39,7 +39,7 @@
 
   bool operator==(const HttpValidationPolicy& other) const;
 
-  friend QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
+  friend QUICHE_EXPORT std::ostream& operator<<(
       std::ostream& os, const HttpValidationPolicy& policy) {
     os << "HttpValidationPolicy(enforce_all_=" << policy.enforce_all_ << ")";
     return os;
diff --git a/quiche/balsa/noop_balsa_visitor.h b/quiche/balsa/noop_balsa_visitor.h
index 4045cf8..9555b52 100644
--- a/quiche/balsa/noop_balsa_visitor.h
+++ b/quiche/balsa/noop_balsa_visitor.h
@@ -18,7 +18,7 @@
 // Provides empty BalsaVisitorInterface overrides for convenience.
 // Intended to be used as a base class for BalsaVisitorInterface subclasses that
 // only need to override a small number of methods.
-class QUICHE_EXPORT_PRIVATE NoOpBalsaVisitor : public BalsaVisitorInterface {
+class QUICHE_EXPORT NoOpBalsaVisitor : public BalsaVisitorInterface {
  public:
   NoOpBalsaVisitor() = default;
 
diff --git a/quiche/balsa/simple_buffer.h b/quiche/balsa/simple_buffer.h
index fe81e33..96fd25f 100644
--- a/quiche/balsa/simple_buffer.h
+++ b/quiche/balsa/simple_buffer.h
@@ -18,7 +18,7 @@
 // SimpleBuffer stores data in a contiguous region.  It can grow on demand,
 // which involves moving its data.  It keeps track of a read and a write
 // position.  Reading consumes data.
-class QUICHE_EXPORT_PRIVATE SimpleBuffer {
+class QUICHE_EXPORT SimpleBuffer {
  public:
   SimpleBuffer() = default;
   // Create SimpleBuffer with at least `size` reserved capacity.
diff --git a/quiche/binary_http/binary_http_message.h b/quiche/binary_http/binary_http_message.h
index 70e1dff..250e109 100644
--- a/quiche/binary_http/binary_http_message.h
+++ b/quiche/binary_http/binary_http_message.h
@@ -20,7 +20,7 @@
 // Supports encoding and decoding Binary Http messages.
 // Currently limited to known-length messages.
 // https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html
-class QUICHE_EXPORT_PRIVATE BinaryHttpMessage {
+class QUICHE_EXPORT BinaryHttpMessage {
  public:
   // Name value pair of either a header or trailer field.
   struct Field {
@@ -108,7 +108,7 @@
   bool has_host_ = false;
 };
 
-class QUICHE_EXPORT_PRIVATE BinaryHttpRequest : public BinaryHttpMessage {
+class QUICHE_EXPORT BinaryHttpRequest : public BinaryHttpMessage {
  public:
   // HTTP request must have all of the following fields.
   // Some examples are:
@@ -161,10 +161,9 @@
   const ControlData control_data_;
 };
 
-void QUICHE_EXPORT_PRIVATE PrintTo(const BinaryHttpRequest& msg,
-                                   std::ostream* os);
+void QUICHE_EXPORT PrintTo(const BinaryHttpRequest& msg, std::ostream* os);
 
-class QUICHE_EXPORT_PRIVATE BinaryHttpResponse : public BinaryHttpMessage {
+class QUICHE_EXPORT BinaryHttpResponse : public BinaryHttpMessage {
  public:
   // https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html#name-response-control-data
   // A response can contain 0 to N informational responses.  Each informational
@@ -259,8 +258,7 @@
   const uint16_t status_code_;
 };
 
-void QUICHE_EXPORT_PRIVATE PrintTo(const BinaryHttpResponse& msg,
-                                   std::ostream* os);
+void QUICHE_EXPORT PrintTo(const BinaryHttpResponse& msg, std::ostream* os);
 }  // namespace quiche
 
 #endif  // QUICHE_BINARY_HTTP_BINARY_HTTP_MESSAGE_H_
diff --git a/quiche/common/masque/connect_udp_datagram_payload.h b/quiche/common/masque/connect_udp_datagram_payload.h
index 8091670..adc0fea 100644
--- a/quiche/common/masque/connect_udp_datagram_payload.h
+++ b/quiche/common/masque/connect_udp_datagram_payload.h
@@ -17,7 +17,7 @@
 
 // UDP-proxying HTTP Datagram payload for use with CONNECT-UDP. See RFC 9298,
 // Section 5.
-class QUICHE_EXPORT_PRIVATE ConnectUdpDatagramPayload {
+class QUICHE_EXPORT ConnectUdpDatagramPayload {
  public:
   using ContextId = uint64_t;
   enum class Type { kUdpPacket, kUnknown };
@@ -54,7 +54,7 @@
 };
 
 // UDP-proxying HTTP Datagram payload that encodes a UDP packet.
-class QUICHE_EXPORT_PRIVATE ConnectUdpDatagramUdpPacketPayload final
+class QUICHE_EXPORT ConnectUdpDatagramUdpPacketPayload final
     : public ConnectUdpDatagramPayload {
  public:
   static constexpr ContextId kContextId = 0;
@@ -75,7 +75,7 @@
   absl::string_view udp_packet_;
 };
 
-class QUICHE_EXPORT_PRIVATE ConnectUdpDatagramUnknownPayload final
+class QUICHE_EXPORT ConnectUdpDatagramUnknownPayload final
     : public ConnectUdpDatagramPayload {
  public:
   // `udp_proxying_payload` represents the inner payload contained by the UDP-
diff --git a/quiche/common/platform/api/quiche_export.h b/quiche/common/platform/api/quiche_export.h
index 4f64819..3f11ccc 100644
--- a/quiche/common/platform/api/quiche_export.h
+++ b/quiche/common/platform/api/quiche_export.h
@@ -7,13 +7,11 @@
 
 #include "quiche_platform_impl/quiche_export_impl.h"
 
-// QUICHE_EXPORT is not meant to be used.
+// QUICHE_EXPORT is meant for QUICHE functionality that is built in
+// Chromium as part of //net/third_party/quiche component, and not fully
+// contained in headers.  It is required for Windows DLL builds to work.
 #define QUICHE_EXPORT QUICHE_EXPORT_IMPL
 
-// QUICHE_EXPORT_PRIVATE is meant for QUICHE functionality that is built in
-// Chromium as part of //net, and not fully contained in headers.
-#define QUICHE_EXPORT_PRIVATE QUICHE_EXPORT_PRIVATE_IMPL
-
 // QUICHE_NO_EXPORT is meant for QUICHE functionality that is either fully
 // defined in a header, or is built in Chromium as part of tests or tools.
 #define QUICHE_NO_EXPORT QUICHE_NO_EXPORT_IMPL
diff --git a/quiche/common/platform/api/quiche_hostname_utils.h b/quiche/common/platform/api/quiche_hostname_utils.h
index 00c611f..10aa399 100644
--- a/quiche/common/platform/api/quiche_hostname_utils.h
+++ b/quiche/common/platform/api/quiche_hostname_utils.h
@@ -12,7 +12,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE QuicheHostnameUtils {
+class QUICHE_EXPORT QuicheHostnameUtils {
  public:
   QuicheHostnameUtils() = delete;
 
diff --git a/quiche/common/platform/api/quiche_mem_slice.h b/quiche/common/platform/api/quiche_mem_slice.h
index 42c3e58..18319f8 100644
--- a/quiche/common/platform/api/quiche_mem_slice.h
+++ b/quiche/common/platform/api/quiche_mem_slice.h
@@ -16,7 +16,7 @@
 
 // QuicheMemSlice is a wrapper around a platform-specific I/O buffer type. It
 // may be reference counted, though QUICHE itself does not rely on that.
-class QUICHE_EXPORT_PRIVATE QuicheMemSlice {
+class QUICHE_EXPORT QuicheMemSlice {
  public:
   // Constructs a empty QuicheMemSlice with no underlying data.
   QuicheMemSlice() = default;
diff --git a/quiche/common/platform/api/quiche_mutex.h b/quiche/common/platform/api/quiche_mutex.h
index ce982bc..11e6287 100644
--- a/quiche/common/platform/api/quiche_mutex.h
+++ b/quiche/common/platform/api/quiche_mutex.h
@@ -21,7 +21,7 @@
 namespace quiche {
 
 // A class representing a non-reentrant mutex in QUIC.
-class QUICHE_LOCKABLE QUICHE_EXPORT_PRIVATE QuicheMutex {
+class QUICHE_LOCKABLE QUICHE_EXPORT QuicheMutex {
  public:
   QuicheMutex() = default;
   QuicheMutex(const QuicheMutex&) = delete;
@@ -50,7 +50,7 @@
 
 // A helper class that acquires the given QuicheMutex shared lock while the
 // QuicheReaderMutexLock is in scope.
-class QUICHE_SCOPED_LOCKABLE QUICHE_EXPORT_PRIVATE QuicheReaderMutexLock {
+class QUICHE_SCOPED_LOCKABLE QUICHE_EXPORT QuicheReaderMutexLock {
  public:
   explicit QuicheReaderMutexLock(QuicheMutex* lock)
       QUICHE_SHARED_LOCK_FUNCTION(lock);
@@ -65,7 +65,7 @@
 
 // A helper class that acquires the given QuicheMutex exclusive lock while the
 // QuicheWriterMutexLock is in scope.
-class QUICHE_SCOPED_LOCKABLE QUICHE_EXPORT_PRIVATE QuicheWriterMutexLock {
+class QUICHE_SCOPED_LOCKABLE QUICHE_EXPORT QuicheWriterMutexLock {
  public:
   explicit QuicheWriterMutexLock(QuicheMutex* lock)
       QUICHE_EXCLUSIVE_LOCK_FUNCTION(lock);
@@ -80,7 +80,7 @@
 
 // A Notification allows threads to receive notification of a single occurrence
 // of a single event.
-class QUICHE_EXPORT_PRIVATE QuicheNotification {
+class QUICHE_EXPORT QuicheNotification {
  public:
   QuicheNotification() = default;
   QuicheNotification(const QuicheNotification&) = delete;
diff --git a/quiche/common/platform/api/quiche_reference_counted.h b/quiche/common/platform/api/quiche_reference_counted.h
index 61016da..226a155 100644
--- a/quiche/common/platform/api/quiche_reference_counted.h
+++ b/quiche/common/platform/api/quiche_reference_counted.h
@@ -11,8 +11,7 @@
 namespace quiche {
 
 // Base class for explicitly reference-counted objects in QUIC.
-class QUICHE_EXPORT_PRIVATE QuicheReferenceCounted
-    : public QuicheReferenceCountedImpl {
+class QUICHE_EXPORT QuicheReferenceCounted : public QuicheReferenceCountedImpl {
  public:
   QuicheReferenceCounted() {}
 
diff --git a/quiche/common/platform/api/quiche_thread.h b/quiche/common/platform/api/quiche_thread.h
index 96a596b..0a15e23 100644
--- a/quiche/common/platform/api/quiche_thread.h
+++ b/quiche/common/platform/api/quiche_thread.h
@@ -13,7 +13,7 @@
 namespace quiche {
 
 // A class representing a thread of execution in QUIC.
-class QUICHE_EXPORT_PRIVATE QuicheThread : public QuicheThreadImpl {
+class QUICHE_EXPORT QuicheThread : public QuicheThreadImpl {
  public:
   QuicheThread(const std::string& string) : QuicheThreadImpl(string) {}
   QuicheThread(const QuicheThread&) = delete;
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_export_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_export_impl.h
index 74018b0..64396f7 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_export_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_export_impl.h
@@ -13,7 +13,6 @@
 #define QUICHE_EXPORT_IMPL
 #endif
 
-#define QUICHE_EXPORT_PRIVATE_IMPL QUICHE_EXPORT_IMPL
 #define QUICHE_NO_EXPORT_IMPL QUICHE_EXPORT_IMPL
 
 #endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_EXPORT_IMPL_H_
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
index 9e97b26..4565cd8 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
@@ -13,19 +13,19 @@
 
 #include "quiche/common/platform/api/quiche_export.h"
 
-#define QUIC_FLAG(flag, value) QUICHE_EXPORT_PRIVATE extern bool FLAGS_##flag;
+#define QUIC_FLAG(flag, value) QUICHE_EXPORT extern bool FLAGS_##flag;
 #include "quiche/quic/core/quic_flags_list.h"
 #undef QUIC_FLAG
 
 // Protocol flags.  TODO(bnc): Move to quiche_protocol_flags_list.h.
 #define QUIC_PROTOCOL_FLAG(type, flag, ...) \
-  QUICHE_EXPORT_PRIVATE extern type FLAGS_##flag;
+  QUICHE_EXPORT extern type FLAGS_##flag;
 #include "quiche/quic/core/quic_protocol_flags_list.h"
 #undef QUIC_PROTOCOL_FLAG
 
 // Protocol flags.
 #define QUICHE_PROTOCOL_FLAG(type, flag, ...) \
-  QUICHE_EXPORT_PRIVATE extern type FLAGS_##flag;
+  QUICHE_EXPORT extern type FLAGS_##flag;
 #include "quiche/common/quiche_protocol_flags_list.h"
 #undef QUICHE_PROTOCOL_FLAG
 
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_iovec_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_iovec_impl.h
index 51bebc4..b4ac17f 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_iovec_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_iovec_impl.h
@@ -10,7 +10,7 @@
 #if defined(_WIN32)
 
 // See <https://pubs.opengroup.org/onlinepubs/009604599/basedefs/sys/uio.h.html>
-struct QUICHE_EXPORT_PRIVATE iovec {
+struct QUICHE_EXPORT iovec {
   void* iov_base;
   size_t iov_len;
 };
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h
index c2372ca..7ab2966 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h
@@ -22,7 +22,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE LogStreamVoidHelper {
+class QUICHE_EXPORT LogStreamVoidHelper {
  public:
   // This operator has lower precedence than << but higher than ?:, which is
   // useful for implementing QUICHE_DISREGARD_LOG_STREAM below.
@@ -31,7 +31,7 @@
 
 // NoopLogSink provides a log sink that does not put the data that it logs
 // anywhere.
-class QUICHE_EXPORT_PRIVATE NoopLogSink {
+class QUICHE_EXPORT NoopLogSink {
  public:
   NoopLogSink() {}
 
@@ -52,7 +52,7 @@
 
 // We need to actually implement LOG(FATAL), otherwise some functions will fail
 // to compile due to the "failed to return value from non-void function" error.
-class QUICHE_EXPORT_PRIVATE FatalLogSink : public NoopLogSink {
+class QUICHE_EXPORT FatalLogSink : public NoopLogSink {
  public:
   ABSL_ATTRIBUTE_NORETURN ~FatalLogSink() {
     std::cerr << str() << std::endl;
@@ -61,7 +61,7 @@
   }
 };
 
-class QUICHE_EXPORT_PRIVATE CheckLogSink : public NoopLogSink {
+class QUICHE_EXPORT CheckLogSink : public NoopLogSink {
  public:
   CheckLogSink(bool condition) : condition_(condition) {}
   ~CheckLogSink() {
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h
index 856928a..5761012 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h
@@ -9,7 +9,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE QuicheLowerCaseStringImpl {
+class QUICHE_EXPORT QuicheLowerCaseStringImpl {
  public:
   QuicheLowerCaseStringImpl(absl::string_view str)
       : str_(absl::AsciiStrToLower(str)) {}
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
index a40fa94..b422b5c 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
@@ -7,7 +7,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE QuicheMemSliceImpl {
+class QUICHE_EXPORT QuicheMemSliceImpl {
  public:
   QuicheMemSliceImpl() = default;
 
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h
index e358c2b..c6f6655 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h
@@ -19,7 +19,7 @@
 namespace quiche {
 
 // A class wrapping a non-reentrant mutex.
-class ABSL_LOCKABLE QUICHE_EXPORT_PRIVATE QuicheLockImpl {
+class ABSL_LOCKABLE QUICHE_EXPORT QuicheLockImpl {
  public:
   QuicheLockImpl() = default;
   QuicheLockImpl(const QuicheLockImpl&) = delete;
@@ -47,7 +47,7 @@
 
 // A Notification allows threads to receive notification of a single occurrence
 // of a single event.
-class QUICHE_EXPORT_PRIVATE QuicheNotificationImpl {
+class QUICHE_EXPORT QuicheNotificationImpl {
  public:
   QuicheNotificationImpl() = default;
   QuicheNotificationImpl(const QuicheNotificationImpl&) = delete;
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h
index 8f8a514..b568da6 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h
@@ -14,7 +14,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE QuicheReferenceCountedImpl {
+class QUICHE_EXPORT QuicheReferenceCountedImpl {
  public:
   virtual ~QuicheReferenceCountedImpl() { QUICHE_DCHECK_EQ(ref_count_, 0); }
 
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_system_event_loop_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_system_event_loop_impl.h
index c3305c2..f810fa8 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_system_event_loop_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_system_event_loop_impl.h
@@ -12,7 +12,7 @@
 
 inline void QuicheRunSystemEventLoopIterationImpl() {}
 
-class QUICHE_EXPORT_PRIVATE QuicheSystemEventLoopImpl {
+class QUICHE_EXPORT QuicheSystemEventLoopImpl {
  public:
   QuicheSystemEventLoopImpl(std::string context_name) {
     QUICHE_LOG(INFO) << "Starting event loop for " << context_name;
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.h
index dd042a3..45d87e0 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.h
@@ -19,7 +19,7 @@
 // Parameters are URL-encoded. Collects the names of any expanded variables in
 // |vars_found|. Supports level 1 templates as specified in RFC 6570. Returns
 // true if the template was parseable, false if it was malformed.
-QUICHE_EXPORT_PRIVATE bool ExpandURITemplateImpl(
+QUICHE_EXPORT bool ExpandURITemplateImpl(
     const std::string& uri_template,
     const absl::flat_hash_map<std::string, std::string>& parameters,
     std::string* target,
@@ -27,7 +27,7 @@
 
 // Decodes a URL-encoded string and converts it to ASCII. If the decoded input
 // contains non-ASCII characters, decoding fails and absl::nullopt is returned.
-QUICHE_EXPORT_PRIVATE absl::optional<std::string> AsciiUrlDecodeImpl(
+QUICHE_EXPORT absl::optional<std::string> AsciiUrlDecodeImpl(
     absl::string_view input);
 
 }  // namespace quiche
diff --git a/quiche/common/print_elements.h b/quiche/common/print_elements.h
index 627b4c9..ae69c40 100644
--- a/quiche/common/print_elements.h
+++ b/quiche/common/print_elements.h
@@ -16,7 +16,7 @@
 // Print elements of any iterable container that has cbegin() and cend() methods
 // and the elements have operator<<(ostream) override.
 template <typename T>
-QUICHE_EXPORT_PRIVATE inline std::string PrintElements(const T& container) {
+QUICHE_EXPORT inline std::string PrintElements(const T& container) {
   std::stringstream debug_string;
   debug_string << "{";
   auto it = container.cbegin();
diff --git a/quiche/common/quiche_buffer_allocator.h b/quiche/common/quiche_buffer_allocator.h
index 6bb1af9..0f36842 100644
--- a/quiche/common/quiche_buffer_allocator.h
+++ b/quiche/common/quiche_buffer_allocator.h
@@ -16,7 +16,7 @@
 namespace quiche {
 
 // Abstract base class for classes which allocate and delete buffers.
-class QUICHE_EXPORT_PRIVATE QuicheBufferAllocator {
+class QUICHE_EXPORT QuicheBufferAllocator {
  public:
   virtual ~QuicheBufferAllocator() = default;
 
@@ -38,7 +38,7 @@
 
 // A deleter that can be used to manage ownership of buffers allocated via
 // QuicheBufferAllocator through std::unique_ptr.
-class QUICHE_EXPORT_PRIVATE QuicheBufferDeleter {
+class QUICHE_EXPORT QuicheBufferDeleter {
  public:
   explicit QuicheBufferDeleter(QuicheBufferAllocator* allocator)
       : allocator_(allocator) {}
@@ -62,7 +62,7 @@
 // QuicheMemSlice, except unlike QuicheMemSlice, QuicheBuffer is mutable and is
 // not platform-specific.  Also unlike QuicheMemSlice, QuicheBuffer can be
 // empty.
-class QUICHE_EXPORT_PRIVATE QuicheBuffer {
+class QUICHE_EXPORT QuicheBuffer {
  public:
   QuicheBuffer() : buffer_(nullptr, QuicheBufferDeleter(nullptr)), size_(0) {}
   QuicheBuffer(QuicheBufferAllocator* allocator, size_t size)
diff --git a/quiche/common/quiche_data_reader.h b/quiche/common/quiche_data_reader.h
index ed05b69..9f7dd56 100644
--- a/quiche/common/quiche_data_reader.h
+++ b/quiche/common/quiche_data_reader.h
@@ -26,7 +26,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 QUICHE_EXPORT_PRIVATE QuicheDataReader {
+class QUICHE_EXPORT QuicheDataReader {
  public:
   // Constructs a reader using NETWORK_BYTE_ORDER endianness.
   // Caller must provide an underlying buffer to work on.
diff --git a/quiche/common/quiche_data_writer.h b/quiche/common/quiche_data_writer.h
index 8035bb2..bb691cd 100644
--- a/quiche/common/quiche_data_writer.h
+++ b/quiche/common/quiche_data_writer.h
@@ -40,7 +40,7 @@
 // The QuicheDataWriter supports appending primitive values (int, string, etc)
 // to a frame instance.  The internal memory buffer is exposed as the "data"
 // of the QuicheDataWriter.
-class QUICHE_EXPORT_PRIVATE QuicheDataWriter {
+class QUICHE_EXPORT QuicheDataWriter {
  public:
   // Creates a QuicheDataWriter where |buffer| is not owned
   // using NETWORK_BYTE_ORDER endianness.
diff --git a/quiche/common/quiche_endian.h b/quiche/common/quiche_endian.h
index 5af28af..2aaa478 100644
--- a/quiche/common/quiche_endian.h
+++ b/quiche/common/quiche_endian.h
@@ -20,7 +20,7 @@
 
 // Provide utility functions that convert from/to network order (big endian)
 // to/from host order (little endian).
-class QUICHE_EXPORT_PRIVATE QuicheEndian {
+class QUICHE_EXPORT QuicheEndian {
  public:
   // Convert |x| from host order (little endian) to network order (big endian).
 #if defined(__clang__) || \
diff --git a/quiche/common/quiche_ip_address.h b/quiche/common/quiche_ip_address.h
index 9267922..a6eeffd 100644
--- a/quiche/common/quiche_ip_address.h
+++ b/quiche/common/quiche_ip_address.h
@@ -25,7 +25,7 @@
 namespace quiche {
 
 // Represents an IP address.
-class QUICHE_EXPORT_PRIVATE QuicheIpAddress {
+class QUICHE_EXPORT QuicheIpAddress {
  public:
   // Sizes of IP addresses of different types, in bytes.
   enum : size_t {
@@ -46,10 +46,10 @@
   explicit QuicheIpAddress(const in6_addr& ipv6_address);
   QuicheIpAddress& operator=(const QuicheIpAddress& other) = default;
   QuicheIpAddress& operator=(QuicheIpAddress&& other) = default;
-  QUICHE_EXPORT_PRIVATE friend bool operator==(QuicheIpAddress lhs,
-                                               QuicheIpAddress rhs);
-  QUICHE_EXPORT_PRIVATE friend bool operator!=(QuicheIpAddress lhs,
-                                               QuicheIpAddress rhs);
+  QUICHE_EXPORT friend bool operator==(QuicheIpAddress lhs,
+                                       QuicheIpAddress rhs);
+  QUICHE_EXPORT friend bool operator!=(QuicheIpAddress lhs,
+                                       QuicheIpAddress rhs);
 
   bool IsInitialized() const;
   IpAddressFamily address_family() const;
@@ -95,7 +95,7 @@
 }
 
 // Represents an IP prefix, which is an IP address and a prefix length in bits.
-class QUICHE_EXPORT_PRIVATE QuicheIpPrefix {
+class QUICHE_EXPORT QuicheIpPrefix {
  public:
   QuicheIpPrefix();
   explicit QuicheIpPrefix(const QuicheIpAddress& address);
@@ -110,10 +110,10 @@
   QuicheIpPrefix(const QuicheIpPrefix& other) = default;
   QuicheIpPrefix& operator=(const QuicheIpPrefix& other) = default;
   QuicheIpPrefix& operator=(QuicheIpPrefix&& other) = default;
-  QUICHE_EXPORT_PRIVATE friend bool operator==(const QuicheIpPrefix& lhs,
-                                               const QuicheIpPrefix& rhs);
-  QUICHE_EXPORT_PRIVATE friend bool operator!=(const QuicheIpPrefix& lhs,
-                                               const QuicheIpPrefix& rhs);
+  QUICHE_EXPORT friend bool operator==(const QuicheIpPrefix& lhs,
+                                       const QuicheIpPrefix& rhs);
+  QUICHE_EXPORT friend bool operator!=(const QuicheIpPrefix& lhs,
+                                       const QuicheIpPrefix& rhs);
 
  private:
   QuicheIpAddress address_;
diff --git a/quiche/common/quiche_mem_slice_storage.h b/quiche/common/quiche_mem_slice_storage.h
index 0b6376a..1439d63 100644
--- a/quiche/common/quiche_mem_slice_storage.h
+++ b/quiche/common/quiche_mem_slice_storage.h
@@ -18,7 +18,7 @@
 
 // QuicheMemSliceStorage is a container class that store QuicheMemSlices for
 // further use cases such as turning into QuicheMemSliceSpan.
-class QUICHE_EXPORT_PRIVATE QuicheMemSliceStorage {
+class QUICHE_EXPORT QuicheMemSliceStorage {
  public:
   QuicheMemSliceStorage(const struct iovec* iov, int iov_count,
                         QuicheBufferAllocator* allocator,
diff --git a/quiche/common/quiche_random.h b/quiche/common/quiche_random.h
index 7ee2995..724bcca 100644
--- a/quiche/common/quiche_random.h
+++ b/quiche/common/quiche_random.h
@@ -9,7 +9,7 @@
 namespace quiche {
 
 // The interface for a random number generator.
-class QUICHE_EXPORT_PRIVATE QuicheRandom {
+class QUICHE_EXPORT QuicheRandom {
  public:
   virtual ~QuicheRandom() {}
 
diff --git a/quiche/common/quiche_text_utils.h b/quiche/common/quiche_text_utils.h
index 2398559..b433718 100644
--- a/quiche/common/quiche_text_utils.h
+++ b/quiche/common/quiche_text_utils.h
@@ -17,7 +17,7 @@
 
 namespace quiche {
 
-struct QUICHE_EXPORT_PRIVATE StringPieceCaseHash {
+struct QUICHE_EXPORT StringPieceCaseHash {
   size_t operator()(absl::string_view data) const {
     std::string lower = absl::AsciiStrToLower(data);
     absl::Hash<absl::string_view> hasher;
@@ -25,14 +25,14 @@
   }
 };
 
-struct QUICHE_EXPORT_PRIVATE StringPieceCaseEqual {
+struct QUICHE_EXPORT StringPieceCaseEqual {
   bool operator()(absl::string_view piece1, absl::string_view piece2) const {
     return absl::EqualsIgnoreCase(piece1, piece2);
   }
 };
 
 // Various utilities for manipulating text.
-class QUICHE_EXPORT_PRIVATE QuicheTextUtils {
+class QUICHE_EXPORT QuicheTextUtils {
  public:
   // Returns a new string in which |data| has been converted to lower case.
   static std::string ToLower(absl::string_view data) {
diff --git a/quiche/common/simple_buffer_allocator.h b/quiche/common/simple_buffer_allocator.h
index d5ed06f..babfa55 100644
--- a/quiche/common/simple_buffer_allocator.h
+++ b/quiche/common/simple_buffer_allocator.h
@@ -13,8 +13,7 @@
 // Provides buffer allocation using operators new[] and delete[] on char arrays.
 // Note that some of the QUICHE code relies on this being the case for deleting
 // new[]-allocated arrays from elsewhere.
-class QUICHE_EXPORT_PRIVATE SimpleBufferAllocator
-    : public QuicheBufferAllocator {
+class QUICHE_EXPORT SimpleBufferAllocator : public QuicheBufferAllocator {
  public:
   static SimpleBufferAllocator* Get() {
     static SimpleBufferAllocator* singleton = new SimpleBufferAllocator();
diff --git a/quiche/common/structured_headers.h b/quiche/common/structured_headers.h
index 8e0520b..c9f2795 100644
--- a/quiche/common/structured_headers.h
+++ b/quiche/common/structured_headers.h
@@ -57,7 +57,7 @@
 // present in Structured Header values, and will cause the entire header to fail
 // to parse.)
 
-class QUICHE_EXPORT_PRIVATE Item {
+class QUICHE_EXPORT Item {
  public:
   enum ItemType {
     kNullType,
@@ -77,8 +77,7 @@
   Item(const char* value, Item::ItemType type = kStringType);
   Item(std::string value, Item::ItemType type = kStringType);
 
-  QUICHE_EXPORT_PRIVATE friend bool operator==(const Item& lhs,
-                                               const Item& rhs);
+  QUICHE_EXPORT friend bool operator==(const Item& lhs, const Item& rhs);
   inline friend bool operator!=(const Item& lhs, const Item& rhs) {
     return !(lhs == rhs);
   }
@@ -145,7 +144,7 @@
 // Holds a ParameterizedIdentifier (draft 9 only). The contained Item must be a
 // Token, and there may be any number of parameters. Parameter ordering is not
 // significant.
-struct QUICHE_EXPORT_PRIVATE ParameterisedIdentifier {
+struct QUICHE_EXPORT ParameterisedIdentifier {
   using Parameters = std::map<std::string, Item>;
 
   Item identifier;
@@ -166,7 +165,7 @@
 
 using Parameters = std::vector<std::pair<std::string, Item>>;
 
-struct QUICHE_EXPORT_PRIVATE ParameterizedItem {
+struct QUICHE_EXPORT ParameterizedItem {
   Item item;
   Parameters params;
 
@@ -190,7 +189,7 @@
 // Holds a ParameterizedMember, which may be either an single Item, or an Inner
 // List of ParameterizedItems, along with any number of parameters. Parameter
 // ordering is significant.
-struct QUICHE_EXPORT_PRIVATE ParameterizedMember {
+struct QUICHE_EXPORT ParameterizedMember {
   std::vector<ParameterizedItem> member;
   // If false, then |member| should only hold one Item.
   bool member_is_inner_list = false;
@@ -218,7 +217,7 @@
 using DictionaryMember = std::pair<std::string, ParameterizedMember>;
 
 // Structured Headers RFC8941 Dictionary.
-class QUICHE_EXPORT_PRIVATE Dictionary {
+class QUICHE_EXPORT Dictionary {
  public:
   using iterator = std::vector<DictionaryMember>::iterator;
   using const_iterator = std::vector<DictionaryMember>::const_iterator;
@@ -277,13 +276,13 @@
 // Returns the result of parsing the header value as an Item, if it can be
 // parsed as one, or nullopt if it cannot. Note that this uses the Draft 15
 // parsing rules, and so applies tighter range limits to integers.
-QUICHE_EXPORT_PRIVATE absl::optional<ParameterizedItem> ParseItem(
+QUICHE_EXPORT absl::optional<ParameterizedItem> ParseItem(
     absl::string_view str);
 
 // Returns the result of parsing the header value as an Item with no parameters,
 // or nullopt if it cannot. Note that this uses the Draft 15 parsing rules, and
 // so applies tighter range limits to integers.
-QUICHE_EXPORT_PRIVATE absl::optional<Item> ParseBareItem(absl::string_view str);
+QUICHE_EXPORT absl::optional<Item> ParseBareItem(absl::string_view str);
 
 // Returns the result of parsing the header value as a Parameterised List, if it
 // can be parsed as one, or nullopt if it cannot. Note that parameter keys will
@@ -291,7 +290,7 @@
 // as well as parameter values, will be returned as Items. This method uses the
 // Draft 09 parsing rules for Items, so integers have the 64-bit int range.
 // Structured-Headers Draft 09 only.
-QUICHE_EXPORT_PRIVATE absl::optional<ParameterisedList> ParseParameterisedList(
+QUICHE_EXPORT absl::optional<ParameterisedList> ParseParameterisedList(
     absl::string_view str);
 
 // Returns the result of parsing the header value as a List of Lists, if it can
@@ -299,28 +298,26 @@
 // as Items. This method uses the Draft 09 parsing rules for Items, so integers
 // have the 64-bit int range.
 // Structured-Headers Draft 09 only.
-QUICHE_EXPORT_PRIVATE absl::optional<ListOfLists> ParseListOfLists(
+QUICHE_EXPORT absl::optional<ListOfLists> ParseListOfLists(
     absl::string_view str);
 
 // Returns the result of parsing the header value as a general List, if it can
 // be parsed as one, or nullopt if it cannot.
 // Structured-Headers Draft 15 only.
-QUICHE_EXPORT_PRIVATE absl::optional<List> ParseList(absl::string_view str);
+QUICHE_EXPORT absl::optional<List> ParseList(absl::string_view str);
 
 // Returns the result of parsing the header value as a general Dictionary, if it
 // can be parsed as one, or nullopt if it cannot. Structured-Headers Draft 15
 // only.
-QUICHE_EXPORT_PRIVATE absl::optional<Dictionary> ParseDictionary(
+QUICHE_EXPORT absl::optional<Dictionary> ParseDictionary(
     const absl::string_view& str);
 
 // Serialization is implemented for Structured-Headers Draft 15 only.
-QUICHE_EXPORT_PRIVATE absl::optional<std::string> SerializeItem(
-    const Item& value);
-QUICHE_EXPORT_PRIVATE absl::optional<std::string> SerializeItem(
+QUICHE_EXPORT absl::optional<std::string> SerializeItem(const Item& value);
+QUICHE_EXPORT absl::optional<std::string> SerializeItem(
     const ParameterizedItem& value);
-QUICHE_EXPORT_PRIVATE absl::optional<std::string> SerializeList(
-    const List& value);
-QUICHE_EXPORT_PRIVATE absl::optional<std::string> SerializeDictionary(
+QUICHE_EXPORT absl::optional<std::string> SerializeList(const List& value);
+QUICHE_EXPORT absl::optional<std::string> SerializeDictionary(
     const Dictionary& value);
 
 }  // namespace structured_headers
diff --git a/quiche/http2/adapter/callback_visitor.h b/quiche/http2/adapter/callback_visitor.h
index 217ad62..7c982e8 100644
--- a/quiche/http2/adapter/callback_visitor.h
+++ b/quiche/http2/adapter/callback_visitor.h
@@ -17,7 +17,7 @@
 
 // This visitor implementation accepts a set of nghttp2 callbacks and a "user
 // data" pointer, and invokes the callbacks according to HTTP/2 events received.
-class QUICHE_EXPORT_PRIVATE CallbackVisitor : public Http2VisitorInterface {
+class QUICHE_EXPORT CallbackVisitor : public Http2VisitorInterface {
  public:
   // Called when the visitor receives a close event for `stream_id`.
   using StreamCloseListener = std::function<void(Http2StreamId stream_id)>;
@@ -79,7 +79,7 @@
   }
 
  private:
-  struct QUICHE_EXPORT_PRIVATE StreamInfo {
+  struct QUICHE_EXPORT StreamInfo {
     bool before_sent_headers = false;
     bool sent_headers = false;
     bool received_headers = false;
diff --git a/quiche/http2/adapter/data_source.h b/quiche/http2/adapter/data_source.h
index 0c40095..ffd78a0 100644
--- a/quiche/http2/adapter/data_source.h
+++ b/quiche/http2/adapter/data_source.h
@@ -12,7 +12,7 @@
 namespace adapter {
 
 // Represents a source of DATA frames for transmission to the peer.
-class QUICHE_EXPORT_PRIVATE DataFrameSource {
+class QUICHE_EXPORT DataFrameSource {
  public:
   virtual ~DataFrameSource() {}
 
@@ -34,7 +34,7 @@
 };
 
 // Represents a source of metadata frames for transmission to the peer.
-class QUICHE_EXPORT_PRIVATE MetadataSource {
+class QUICHE_EXPORT MetadataSource {
  public:
   virtual ~MetadataSource() {}
 
diff --git a/quiche/http2/adapter/event_forwarder.h b/quiche/http2/adapter/event_forwarder.h
index efa1031..74140f9 100644
--- a/quiche/http2/adapter/event_forwarder.h
+++ b/quiche/http2/adapter/event_forwarder.h
@@ -13,8 +13,7 @@
 // provided predicate succeeds. Currently, OnHeaderFrameStart() is always
 // forwarded regardless of the predicate.
 // TODO(diannahu): Add a NoOpHeadersHandler if needed.
-class QUICHE_EXPORT_PRIVATE EventForwarder
-    : public spdy::SpdyFramerVisitorInterface {
+class QUICHE_EXPORT EventForwarder : public spdy::SpdyFramerVisitorInterface {
  public:
   // Whether the forwarder can forward events to the receiver.
   using ForwardPredicate = std::function<bool()>;
diff --git a/quiche/http2/adapter/header_validator.h b/quiche/http2/adapter/header_validator.h
index ca82b08..096f76f 100644
--- a/quiche/http2/adapter/header_validator.h
+++ b/quiche/http2/adapter/header_validator.h
@@ -12,7 +12,7 @@
 namespace http2 {
 namespace adapter {
 
-class QUICHE_EXPORT_PRIVATE HeaderValidator : public HeaderValidatorBase {
+class QUICHE_EXPORT HeaderValidator : public HeaderValidatorBase {
  public:
   HeaderValidator() = default;
 
diff --git a/quiche/http2/adapter/header_validator_base.h b/quiche/http2/adapter/header_validator_base.h
index 9a6787a..23be794 100644
--- a/quiche/http2/adapter/header_validator_base.h
+++ b/quiche/http2/adapter/header_validator_base.h
@@ -23,7 +23,7 @@
   kDisallow,
 };
 
-class QUICHE_EXPORT_PRIVATE HeaderValidatorBase {
+class QUICHE_EXPORT HeaderValidatorBase {
  public:
   HeaderValidatorBase() = default;
   virtual ~HeaderValidatorBase() = default;
diff --git a/quiche/http2/adapter/http2_adapter.h b/quiche/http2/adapter/http2_adapter.h
index efdbcb7..fb9df13 100644
--- a/quiche/http2/adapter/http2_adapter.h
+++ b/quiche/http2/adapter/http2_adapter.h
@@ -21,7 +21,7 @@
 // invokes corresponding callbacks on its passed-in Http2VisitorInterface.
 // Http2Adapter is a base class shared between client-side and server-side
 // implementations.
-class QUICHE_EXPORT_PRIVATE Http2Adapter {
+class QUICHE_EXPORT Http2Adapter {
  public:
   Http2Adapter(const Http2Adapter&) = delete;
   Http2Adapter& operator=(const Http2Adapter&) = delete;
diff --git a/quiche/http2/adapter/http2_protocol.h b/quiche/http2/adapter/http2_protocol.h
index 02a423a..0c2c2c1 100644
--- a/quiche/http2/adapter/http2_protocol.h
+++ b/quiche/http2/adapter/http2_protocol.h
@@ -34,13 +34,12 @@
 using Header = std::pair<HeaderRep, HeaderRep>;
 
 // Represents an HTTP/2 SETTINGS key-value parameter.
-struct QUICHE_EXPORT_PRIVATE Http2Setting {
+struct QUICHE_EXPORT Http2Setting {
   Http2SettingsId id;
   uint32_t value;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2Setting& a,
-                                      const Http2Setting& b);
+QUICHE_EXPORT bool operator==(const Http2Setting& a, const Http2Setting& b);
 
 // The maximum possible stream ID.
 const Http2StreamId kMaxStreamId = 0x7FFFFFFF;
@@ -63,21 +62,15 @@
 
 // The pseudo-header fields as specified in RFC 7540 Section 8.1.2.3 (request)
 // and Section 8.1.2.4 (response).
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const char
-    kHttp2MethodPseudoHeader[];
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const char
-    kHttp2SchemePseudoHeader[];
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const char
-    kHttp2AuthorityPseudoHeader[];
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const char
-    kHttp2PathPseudoHeader[];
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const char
-    kHttp2StatusPseudoHeader[];
+ABSL_CONST_INIT QUICHE_EXPORT extern const char kHttp2MethodPseudoHeader[];
+ABSL_CONST_INIT QUICHE_EXPORT extern const char kHttp2SchemePseudoHeader[];
+ABSL_CONST_INIT QUICHE_EXPORT extern const char kHttp2AuthorityPseudoHeader[];
+ABSL_CONST_INIT QUICHE_EXPORT extern const char kHttp2PathPseudoHeader[];
+ABSL_CONST_INIT QUICHE_EXPORT extern const char kHttp2StatusPseudoHeader[];
 
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const uint8_t kMetadataFrameType;
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const uint8_t kMetadataEndFlag;
-ABSL_CONST_INIT QUICHE_EXPORT_PRIVATE extern const uint16_t
-    kMetadataExtensionId;
+ABSL_CONST_INIT QUICHE_EXPORT extern const uint8_t kMetadataFrameType;
+ABSL_CONST_INIT QUICHE_EXPORT extern const uint8_t kMetadataEndFlag;
+ABSL_CONST_INIT QUICHE_EXPORT extern const uint16_t kMetadataExtensionId;
 
 enum class FrameType : uint8_t {
   DATA = 0x0,
diff --git a/quiche/http2/adapter/http2_session.h b/quiche/http2/adapter/http2_session.h
index 0a76726..7b01000 100644
--- a/quiche/http2/adapter/http2_session.h
+++ b/quiche/http2/adapter/http2_session.h
@@ -10,10 +10,10 @@
 namespace http2 {
 namespace adapter {
 
-struct QUICHE_EXPORT_PRIVATE Http2SessionCallbacks {};
+struct QUICHE_EXPORT Http2SessionCallbacks {};
 
 // A class to represent the state of a single HTTP/2 connection.
-class QUICHE_EXPORT_PRIVATE Http2Session {
+class QUICHE_EXPORT Http2Session {
  public:
   Http2Session() = default;
   virtual ~Http2Session() {}
diff --git a/quiche/http2/adapter/http2_util.h b/quiche/http2/adapter/http2_util.h
index 00580a3..12015a3 100644
--- a/quiche/http2/adapter/http2_util.h
+++ b/quiche/http2/adapter/http2_util.h
@@ -11,22 +11,19 @@
 namespace http2 {
 namespace adapter {
 
-QUICHE_EXPORT_PRIVATE spdy::SpdyErrorCode TranslateErrorCode(
-    Http2ErrorCode code);
-QUICHE_EXPORT_PRIVATE Http2ErrorCode
-TranslateErrorCode(spdy::SpdyErrorCode code);
+QUICHE_EXPORT spdy::SpdyErrorCode TranslateErrorCode(Http2ErrorCode code);
+QUICHE_EXPORT Http2ErrorCode TranslateErrorCode(spdy::SpdyErrorCode code);
 
-QUICHE_EXPORT_PRIVATE absl::string_view ConnectionErrorToString(
+QUICHE_EXPORT absl::string_view ConnectionErrorToString(
     Http2VisitorInterface::ConnectionError error);
 
-QUICHE_EXPORT_PRIVATE absl::string_view InvalidFrameErrorToString(
+QUICHE_EXPORT absl::string_view InvalidFrameErrorToString(
     Http2VisitorInterface::InvalidFrameError error);
 
 // A WINDOW_UPDATE sending strategy that returns true if the `delta` to be sent
 // is positive and at least half of the window `limit`.
-QUICHE_EXPORT_PRIVATE bool DeltaAtLeastHalfLimit(int64_t limit,
-                                                 int64_t /*size*/,
-                                                 int64_t delta);
+QUICHE_EXPORT bool DeltaAtLeastHalfLimit(int64_t limit, int64_t /*size*/,
+                                         int64_t delta);
 
 }  // namespace adapter
 }  // namespace http2
diff --git a/quiche/http2/adapter/http2_visitor_interface.h b/quiche/http2/adapter/http2_visitor_interface.h
index 4e6bcb8..77bcd7f 100644
--- a/quiche/http2/adapter/http2_visitor_interface.h
+++ b/quiche/http2/adapter/http2_visitor_interface.h
@@ -46,7 +46,7 @@
 //     - OnCloseStream()
 //
 // More details are at RFC 7540 (go/http2spec).
-class QUICHE_EXPORT_PRIVATE Http2VisitorInterface {
+class QUICHE_EXPORT Http2VisitorInterface {
  public:
   Http2VisitorInterface(const Http2VisitorInterface&) = delete;
   Http2VisitorInterface& operator=(const Http2VisitorInterface&) = delete;
diff --git a/quiche/http2/adapter/nghttp2_adapter.h b/quiche/http2/adapter/nghttp2_adapter.h
index 6e34f74..7ae9645 100644
--- a/quiche/http2/adapter/nghttp2_adapter.h
+++ b/quiche/http2/adapter/nghttp2_adapter.h
@@ -13,7 +13,7 @@
 namespace http2 {
 namespace adapter {
 
-class QUICHE_EXPORT_PRIVATE NgHttp2Adapter : public Http2Adapter {
+class QUICHE_EXPORT NgHttp2Adapter : public Http2Adapter {
  public:
   ~NgHttp2Adapter() override;
 
diff --git a/quiche/http2/adapter/nghttp2_session.h b/quiche/http2/adapter/nghttp2_session.h
index 5837f2f..b07119f 100644
--- a/quiche/http2/adapter/nghttp2_session.h
+++ b/quiche/http2/adapter/nghttp2_session.h
@@ -12,7 +12,7 @@
 namespace adapter {
 
 // A C++ wrapper around common nghttp2_session operations.
-class QUICHE_EXPORT_PRIVATE NgHttp2Session : public Http2Session {
+class QUICHE_EXPORT NgHttp2Session : public Http2Session {
  public:
   // Does not take ownership of |options|.
   NgHttp2Session(Perspective perspective,
diff --git a/quiche/http2/adapter/noop_header_validator.h b/quiche/http2/adapter/noop_header_validator.h
index 52d1791..f6b95e9 100644
--- a/quiche/http2/adapter/noop_header_validator.h
+++ b/quiche/http2/adapter/noop_header_validator.h
@@ -9,7 +9,7 @@
 namespace adapter {
 
 // A validator that does not actually perform any validation.
-class QUICHE_EXPORT_PRIVATE NoopHeaderValidator : public HeaderValidatorBase {
+class QUICHE_EXPORT NoopHeaderValidator : public HeaderValidatorBase {
  public:
   NoopHeaderValidator() = default;
 
diff --git a/quiche/http2/adapter/oghttp2_adapter.h b/quiche/http2/adapter/oghttp2_adapter.h
index be1cd66..76e3b93 100644
--- a/quiche/http2/adapter/oghttp2_adapter.h
+++ b/quiche/http2/adapter/oghttp2_adapter.h
@@ -12,7 +12,7 @@
 namespace http2 {
 namespace adapter {
 
-class QUICHE_EXPORT_PRIVATE OgHttp2Adapter : public Http2Adapter {
+class QUICHE_EXPORT OgHttp2Adapter : public Http2Adapter {
  public:
   using Options = OgHttp2Session::Options;
   static std::unique_ptr<OgHttp2Adapter> Create(Http2VisitorInterface& visitor,
diff --git a/quiche/http2/adapter/oghttp2_session.h b/quiche/http2/adapter/oghttp2_session.h
index e28af7a..342f773 100644
--- a/quiche/http2/adapter/oghttp2_session.h
+++ b/quiche/http2/adapter/oghttp2_session.h
@@ -35,11 +35,10 @@
 namespace adapter {
 
 // This class manages state associated with a single multiplexed HTTP/2 session.
-class QUICHE_EXPORT_PRIVATE OgHttp2Session
-    : public Http2Session,
-      public spdy::SpdyFramerVisitorInterface {
+class QUICHE_EXPORT OgHttp2Session : public Http2Session,
+                                     public spdy::SpdyFramerVisitorInterface {
  public:
-  struct QUICHE_EXPORT_PRIVATE Options {
+  struct QUICHE_EXPORT Options {
     // Returns whether to send a WINDOW_UPDATE based on the window limit, window
     // size, and delta that would be sent in the WINDOW_UPDATE.
     WindowManager::ShouldWindowUpdateFn should_window_update_fn =
@@ -214,7 +213,7 @@
                       Http2VisitorInterface::OnHeaderResult result);
 
  private:
-  struct QUICHE_EXPORT_PRIVATE StreamState {
+  struct QUICHE_EXPORT StreamState {
     StreamState(int32_t stream_receive_window, int32_t stream_send_window,
                 WindowManager::WindowUpdateListener listener,
                 WindowManager::ShouldWindowUpdateFn should_window_update_fn)
@@ -238,13 +237,13 @@
   };
   using StreamStateMap = absl::flat_hash_map<Http2StreamId, StreamState>;
 
-  struct QUICHE_EXPORT_PRIVATE PendingStreamState {
+  struct QUICHE_EXPORT PendingStreamState {
     spdy::Http2HeaderBlock headers;
     std::unique_ptr<DataFrameSource> data_source;
     void* user_data = nullptr;
   };
 
-  class QUICHE_EXPORT_PRIVATE PassthroughHeadersHandler
+  class QUICHE_EXPORT PassthroughHeadersHandler
       : public spdy::SpdyHeadersHandlerInterface {
    public:
     PassthroughHeadersHandler(OgHttp2Session& session,
@@ -293,7 +292,7 @@
     bool frame_contains_fin_ = false;
   };
 
-  struct QUICHE_EXPORT_PRIVATE ProcessBytesResultVisitor;
+  struct QUICHE_EXPORT ProcessBytesResultVisitor;
 
   // Queues the connection preface, if not already done. If not
   // `sending_outbound_settings` and the preface has not yet been queued, this
diff --git a/quiche/http2/adapter/oghttp2_util.h b/quiche/http2/adapter/oghttp2_util.h
index 7d41cbd..0aba100 100644
--- a/quiche/http2/adapter/oghttp2_util.h
+++ b/quiche/http2/adapter/oghttp2_util.h
@@ -9,7 +9,7 @@
 namespace http2 {
 namespace adapter {
 
-QUICHE_EXPORT_PRIVATE spdy::Http2HeaderBlock ToHeaderBlock(
+QUICHE_EXPORT spdy::Http2HeaderBlock ToHeaderBlock(
     absl::Span<const Header> headers);
 
 }  // namespace adapter
diff --git a/quiche/http2/adapter/window_manager.h b/quiche/http2/adapter/window_manager.h
index 272f96c..759a3d3 100644
--- a/quiche/http2/adapter/window_manager.h
+++ b/quiche/http2/adapter/window_manager.h
@@ -16,7 +16,7 @@
 
 // This class keeps track of a HTTP/2 flow control window, notifying a listener
 // when a window update needs to be sent. This class is not thread-safe.
-class QUICHE_EXPORT_PRIVATE WindowManager {
+class QUICHE_EXPORT WindowManager {
  public:
   // A WindowUpdateListener is invoked when it is time to send a window update.
   using WindowUpdateListener = std::function<void(int64_t)>;
diff --git a/quiche/http2/core/http2_trace_logging.h b/quiche/http2/core/http2_trace_logging.h
index 7273770..f7218fe 100644
--- a/quiche/http2/core/http2_trace_logging.h
+++ b/quiche/http2/core/http2_trace_logging.h
@@ -29,8 +29,7 @@
 // Note any new methods in SpdyFramerVisitorInterface MUST be overridden here to
 // properly forward the event. This could be ensured by making every event in
 // SpdyFramerVisitorInterface a pure virtual.
-class QUICHE_EXPORT_PRIVATE Http2TraceLogger
-    : public spdy::SpdyFramerVisitorInterface {
+class QUICHE_EXPORT Http2TraceLogger : public spdy::SpdyFramerVisitorInterface {
  public:
   typedef spdy::SpdyAltSvcWireFormat SpdyAltSvcWireFormat;
   typedef spdy::SpdyErrorCode SpdyErrorCode;
@@ -104,7 +103,7 @@
 };
 
 // Visitor to log control frames that have been written.
-class QUICHE_EXPORT_PRIVATE Http2FrameLogger : public spdy::SpdyFrameVisitor {
+class QUICHE_EXPORT Http2FrameLogger : public spdy::SpdyFrameVisitor {
  public:
   // This class will preface all of its log messages with the value of
   // |connection_id| in hexadecimal.
diff --git a/quiche/http2/core/priority_write_scheduler.h b/quiche/http2/core/priority_write_scheduler.h
index c6d06b2..7335545 100644
--- a/quiche/http2/core/priority_write_scheduler.h
+++ b/quiche/http2/core/priority_write_scheduler.h
@@ -40,7 +40,7 @@
 // I/O event that occurred for a stream of that priority.
 //
 template <typename StreamIdType>
-class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
+class QUICHE_EXPORT PriorityWriteScheduler
     : public WriteScheduler<StreamIdType> {
  public:
   using typename WriteScheduler<StreamIdType>::StreamPrecedenceType;
@@ -290,7 +290,7 @@
 
   // State kept for all registered streams. All ready streams have ready = true
   // and should be present in priority_infos_[priority].ready_list.
-  struct QUICHE_EXPORT_PRIVATE StreamInfo {
+  struct QUICHE_EXPORT StreamInfo {
     spdy::SpdyPriority priority;
     StreamIdType stream_id;
     bool ready;
@@ -300,7 +300,7 @@
   using ReadyList = quiche::QuicheCircularDeque<StreamInfo*>;
 
   // State kept for each priority level.
-  struct QUICHE_EXPORT_PRIVATE PriorityInfo {
+  struct QUICHE_EXPORT PriorityInfo {
     // IDs of streams that are ready to write.
     ReadyList ready_list;
     // Time of latest write event for stream of this priority, in microseconds.
diff --git a/quiche/http2/core/write_scheduler.h b/quiche/http2/core/write_scheduler.h
index 6086672..ce0ddc1 100644
--- a/quiche/http2/core/write_scheduler.h
+++ b/quiche/http2/core/write_scheduler.h
@@ -32,7 +32,7 @@
 // returned by PopNextReadyStream(); when returned by that method, the stream's
 // state changes to not ready.
 template <typename StreamIdType>
-class QUICHE_EXPORT_PRIVATE WriteScheduler {
+class QUICHE_EXPORT WriteScheduler {
  public:
   typedef spdy::StreamPrecedence<StreamIdType> StreamPrecedenceType;
 
diff --git a/quiche/http2/decoder/decode_buffer.h b/quiche/http2/decoder/decode_buffer.h
index 0824b1f..5c9262f 100644
--- a/quiche/http2/decoder/decode_buffer.h
+++ b/quiche/http2/decoder/decode_buffer.h
@@ -24,7 +24,7 @@
 namespace http2 {
 class DecodeBufferSubset;
 
-class QUICHE_EXPORT_PRIVATE DecodeBuffer {
+class QUICHE_EXPORT DecodeBuffer {
  public:
   // We assume the decode buffers will typically be modest in size (i.e. often a
   // few KB, perhaps as high as 100KB). Let's make sure during testing that we
@@ -134,7 +134,7 @@
 // DecodeBuffer, though they can be nested (i.e. a DecodeBufferSubset's
 // base may itself be a DecodeBufferSubset). This avoids the AdvanceCursor
 // being called erroneously.
-class QUICHE_EXPORT_PRIVATE DecodeBufferSubset : public DecodeBuffer {
+class QUICHE_EXPORT DecodeBufferSubset : public DecodeBuffer {
  public:
   DecodeBufferSubset(DecodeBuffer* base, size_t subset_len)
       : DecodeBuffer(base->cursor(), base->MinLengthRemaining(subset_len)),
diff --git a/quiche/http2/decoder/decode_http2_structures.h b/quiche/http2/decoder/decode_http2_structures.h
index eeb69a9..9740497 100644
--- a/quiche/http2/decoder/decode_http2_structures.h
+++ b/quiche/http2/decoder/decode_http2_structures.h
@@ -17,19 +17,16 @@
 // to end, advancing the cursor by STRUCTURE::EncodedSize(). The decode buffer
 // must be large enough (i.e. b->Remaining() >= STRUCTURE::EncodedSize()).
 
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2FrameHeader* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2PriorityFields* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2RstStreamFields* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2SettingFields* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2PushPromiseFields* out,
-                                    DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2PingFields* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2GoAwayFields* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2WindowUpdateFields* out,
-                                    DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2AltSvcFields* out, DecodeBuffer* b);
-QUICHE_EXPORT_PRIVATE void DoDecode(Http2PriorityUpdateFields* out,
-                                    DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2FrameHeader* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2PriorityFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2RstStreamFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2SettingFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2PushPromiseFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2PingFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2GoAwayFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2WindowUpdateFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2AltSvcFields* out, DecodeBuffer* b);
+QUICHE_EXPORT void DoDecode(Http2PriorityUpdateFields* out, DecodeBuffer* b);
 
 }  // namespace http2
 
diff --git a/quiche/http2/decoder/decode_status.h b/quiche/http2/decoder/decode_status.h
index e59d68a..7571938 100644
--- a/quiche/http2/decoder/decode_status.h
+++ b/quiche/http2/decoder/decode_status.h
@@ -25,8 +25,7 @@
   // an HTTP/2 frame has padding declared to be larger than the payload).
   kDecodeError,
 };
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               DecodeStatus v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out, DecodeStatus v);
 
 }  // namespace http2
 
diff --git a/quiche/http2/decoder/frame_decoder_state.h b/quiche/http2/decoder/frame_decoder_state.h
index 3e01155..39757da 100644
--- a/quiche/http2/decoder/frame_decoder_state.h
+++ b/quiche/http2/decoder/frame_decoder_state.h
@@ -30,7 +30,7 @@
 class FrameDecoderStatePeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE FrameDecoderState {
+class QUICHE_EXPORT FrameDecoderState {
  public:
   FrameDecoderState() {}
 
diff --git a/quiche/http2/decoder/http2_frame_decoder.h b/quiche/http2/decoder/http2_frame_decoder.h
index 1df3d76..3d8f1ac 100644
--- a/quiche/http2/decoder/http2_frame_decoder.h
+++ b/quiche/http2/decoder/http2_frame_decoder.h
@@ -47,7 +47,7 @@
 class Http2FrameDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE Http2FrameDecoder {
+class QUICHE_EXPORT Http2FrameDecoder {
  public:
   explicit Http2FrameDecoder(Http2FrameDecoderListener* listener);
 
@@ -126,8 +126,7 @@
   };
 
   friend class test::Http2FrameDecoderPeer;
-  QUICHE_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& out,
-                                                        State v);
+  QUICHE_EXPORT friend std::ostream& operator<<(std::ostream& out, State v);
 
   DecodeStatus StartDecodingPayload(DecodeBuffer* db);
   DecodeStatus ResumeDecodingPayload(DecodeBuffer* db);
diff --git a/quiche/http2/decoder/http2_frame_decoder_listener.h b/quiche/http2/decoder/http2_frame_decoder_listener.h
index a6839ab..0a98b3d 100644
--- a/quiche/http2/decoder/http2_frame_decoder_listener.h
+++ b/quiche/http2/decoder/http2_frame_decoder_listener.h
@@ -39,7 +39,7 @@
 
 // TODO(jamessynge): Consider sorting the methods by frequency of call, if that
 // helps at all.
-class QUICHE_EXPORT_PRIVATE Http2FrameDecoderListener {
+class QUICHE_EXPORT Http2FrameDecoderListener {
  public:
   Http2FrameDecoderListener() {}
   virtual ~Http2FrameDecoderListener() {}
@@ -315,7 +315,7 @@
 };
 
 // Do nothing for each call. Useful for ignoring a frame that is invalid.
-class QUICHE_EXPORT_PRIVATE Http2FrameDecoderNoOpListener
+class QUICHE_EXPORT Http2FrameDecoderNoOpListener
     : public Http2FrameDecoderListener {
  public:
   Http2FrameDecoderNoOpListener() {}
diff --git a/quiche/http2/decoder/http2_structure_decoder.h b/quiche/http2/decoder/http2_structure_decoder.h
index 77d7fd2..1daee07 100644
--- a/quiche/http2/decoder/http2_structure_decoder.h
+++ b/quiche/http2/decoder/http2_structure_decoder.h
@@ -27,7 +27,7 @@
 class Http2StructureDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE Http2StructureDecoder {
+class QUICHE_EXPORT Http2StructureDecoder {
  public:
   // The caller needs to keep track of whether to call Start or Resume.
   //
diff --git a/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder.h b/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder.h
index 64cf703..2829249 100644
--- a/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder.h
@@ -18,7 +18,7 @@
 class AltSvcPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE AltSvcPayloadDecoder {
+class QUICHE_EXPORT AltSvcPayloadDecoder {
  public:
   // States during decoding of a ALTSVC frame.
   enum class PayloadState {
diff --git a/quiche/http2/decoder/payload_decoders/continuation_payload_decoder.h b/quiche/http2/decoder/payload_decoders/continuation_payload_decoder.h
index ba23a56..b599fb5 100644
--- a/quiche/http2/decoder/payload_decoders/continuation_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/continuation_payload_decoder.h
@@ -14,7 +14,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE ContinuationPayloadDecoder {
+class QUICHE_EXPORT ContinuationPayloadDecoder {
  public:
   // Starts the decoding of a CONTINUATION frame's payload, and completes
   // it if the entire payload is in the provided decode buffer.
diff --git a/quiche/http2/decoder/payload_decoders/data_payload_decoder.h b/quiche/http2/decoder/payload_decoders/data_payload_decoder.h
index ffc516f..b0b117d 100644
--- a/quiche/http2/decoder/payload_decoders/data_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/data_payload_decoder.h
@@ -17,7 +17,7 @@
 class DataPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE DataPayloadDecoder {
+class QUICHE_EXPORT DataPayloadDecoder {
  public:
   // States during decoding of a DATA frame.
   enum class PayloadState {
diff --git a/quiche/http2/decoder/payload_decoders/goaway_payload_decoder.h b/quiche/http2/decoder/payload_decoders/goaway_payload_decoder.h
index 2664642..1f3b69c 100644
--- a/quiche/http2/decoder/payload_decoders/goaway_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/goaway_payload_decoder.h
@@ -21,7 +21,7 @@
 class GoAwayPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE GoAwayPayloadDecoder {
+class QUICHE_EXPORT GoAwayPayloadDecoder {
  public:
   // States during decoding of a GOAWAY frame.
   enum class PayloadState {
diff --git a/quiche/http2/decoder/payload_decoders/headers_payload_decoder.h b/quiche/http2/decoder/payload_decoders/headers_payload_decoder.h
index e76908b..05979cd 100644
--- a/quiche/http2/decoder/payload_decoders/headers_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/headers_payload_decoder.h
@@ -18,7 +18,7 @@
 class HeadersPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE HeadersPayloadDecoder {
+class QUICHE_EXPORT HeadersPayloadDecoder {
  public:
   // States during decoding of a HEADERS frame, unless the fast path kicks
   // in, in which case the state machine will be bypassed.
diff --git a/quiche/http2/decoder/payload_decoders/ping_payload_decoder.h b/quiche/http2/decoder/payload_decoders/ping_payload_decoder.h
index 71e4928..0b9e963 100644
--- a/quiche/http2/decoder/payload_decoders/ping_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/ping_payload_decoder.h
@@ -19,7 +19,7 @@
 class PingPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE PingPayloadDecoder {
+class QUICHE_EXPORT PingPayloadDecoder {
  public:
   // Starts the decoding of a PING frame's payload, and completes it if the
   // entire payload is in the provided decode buffer.
diff --git a/quiche/http2/decoder/payload_decoders/priority_payload_decoder.h b/quiche/http2/decoder/payload_decoders/priority_payload_decoder.h
index 5ee3dc9..2056ff9 100644
--- a/quiche/http2/decoder/payload_decoders/priority_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/priority_payload_decoder.h
@@ -18,7 +18,7 @@
 class PriorityPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE PriorityPayloadDecoder {
+class QUICHE_EXPORT PriorityPayloadDecoder {
  public:
   // Starts the decoding of a PRIORITY frame's payload, and completes it if
   // the entire payload is in the provided decode buffer.
diff --git a/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder.h b/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder.h
index 9cfba58..39d0817 100644
--- a/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder.h
@@ -18,7 +18,7 @@
 class PriorityUpdatePayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE PriorityUpdatePayloadDecoder {
+class QUICHE_EXPORT PriorityUpdatePayloadDecoder {
  public:
   // States during decoding of a PRIORITY_UPDATE frame.
   enum class PayloadState {
diff --git a/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder.h b/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder.h
index f5bf53d..c6bf2a2 100644
--- a/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder.h
@@ -18,7 +18,7 @@
 class PushPromisePayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE PushPromisePayloadDecoder {
+class QUICHE_EXPORT PushPromisePayloadDecoder {
  public:
   // States during decoding of a PUSH_PROMISE frame.
   enum class PayloadState {
diff --git a/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder.h b/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder.h
index a263bd2..68e701e 100644
--- a/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder.h
@@ -18,7 +18,7 @@
 class RstStreamPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE RstStreamPayloadDecoder {
+class QUICHE_EXPORT RstStreamPayloadDecoder {
  public:
   // Starts the decoding of a RST_STREAM frame's payload, and completes it if
   // the entire payload is in the provided decode buffer.
diff --git a/quiche/http2/decoder/payload_decoders/settings_payload_decoder.h b/quiche/http2/decoder/payload_decoders/settings_payload_decoder.h
index a9516ee..c7a6266 100644
--- a/quiche/http2/decoder/payload_decoders/settings_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/settings_payload_decoder.h
@@ -19,7 +19,7 @@
 class SettingsPayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE SettingsPayloadDecoder {
+class QUICHE_EXPORT SettingsPayloadDecoder {
  public:
   // Starts the decoding of a SETTINGS frame's payload, and completes it if
   // the entire payload is in the provided decode buffer.
diff --git a/quiche/http2/decoder/payload_decoders/unknown_payload_decoder.h b/quiche/http2/decoder/payload_decoders/unknown_payload_decoder.h
index 4d4f85a..bdc5d81 100644
--- a/quiche/http2/decoder/payload_decoders/unknown_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/unknown_payload_decoder.h
@@ -17,7 +17,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE UnknownPayloadDecoder {
+class QUICHE_EXPORT UnknownPayloadDecoder {
  public:
   // Starts decoding a payload of unknown type; just passes it to the listener.
   DecodeStatus StartDecodingPayload(FrameDecoderState* state, DecodeBuffer* db);
diff --git a/quiche/http2/decoder/payload_decoders/window_update_payload_decoder.h b/quiche/http2/decoder/payload_decoders/window_update_payload_decoder.h
index c12c347..659a715 100644
--- a/quiche/http2/decoder/payload_decoders/window_update_payload_decoder.h
+++ b/quiche/http2/decoder/payload_decoders/window_update_payload_decoder.h
@@ -18,7 +18,7 @@
 class WindowUpdatePayloadDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE WindowUpdatePayloadDecoder {
+class QUICHE_EXPORT WindowUpdatePayloadDecoder {
  public:
   // Starts decoding a WINDOW_UPDATE frame's payload, and completes it if
   // the entire payload is in the provided decode buffer.
diff --git a/quiche/http2/hpack/decoder/hpack_block_decoder.h b/quiche/http2/hpack/decoder/hpack_block_decoder.h
index 0706067..4eeb6d3 100644
--- a/quiche/http2/hpack/decoder/hpack_block_decoder.h
+++ b/quiche/http2/hpack/decoder/hpack_block_decoder.h
@@ -22,7 +22,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackBlockDecoder {
+class QUICHE_EXPORT HpackBlockDecoder {
  public:
   explicit HpackBlockDecoder(HpackEntryDecoderListener* listener)
       : listener_(listener) {
@@ -61,8 +61,8 @@
   bool before_entry_ = true;
 };
 
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const HpackBlockDecoder& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const HpackBlockDecoder& v);
 
 }  // namespace http2
 
diff --git a/quiche/http2/hpack/decoder/hpack_decoder.h b/quiche/http2/hpack/decoder/hpack_decoder.h
index 393a6ca..9e4b68b 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder.h
+++ b/quiche/http2/hpack/decoder/hpack_decoder.h
@@ -37,7 +37,7 @@
 class HpackDecoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE HpackDecoder {
+class QUICHE_EXPORT HpackDecoder {
  public:
   HpackDecoder(HpackDecoderListener* listener, size_t max_string_size);
   virtual ~HpackDecoder();
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_listener.h b/quiche/http2/hpack/decoder/hpack_decoder_listener.h
index bd87c62..37564a4 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_listener.h
+++ b/quiche/http2/hpack/decoder/hpack_decoder_listener.h
@@ -14,7 +14,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackDecoderListener {
+class QUICHE_EXPORT HpackDecoderListener {
  public:
   HpackDecoderListener();
   virtual ~HpackDecoderListener();
@@ -41,8 +41,7 @@
 
 // A no-op implementation of HpackDecoderListener, useful for ignoring
 // callbacks once an error is detected.
-class QUICHE_EXPORT_PRIVATE HpackDecoderNoOpListener
-    : public HpackDecoderListener {
+class QUICHE_EXPORT HpackDecoderNoOpListener : public HpackDecoderListener {
  public:
   HpackDecoderNoOpListener();
   ~HpackDecoderNoOpListener() override;
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_state.h b/quiche/http2/hpack/decoder/hpack_decoder_state.h
index 8b4c0fa..4198ef4 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_state.h
+++ b/quiche/http2/hpack/decoder/hpack_decoder_state.h
@@ -30,7 +30,7 @@
 class HpackDecoderStatePeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE HpackDecoderState : public HpackWholeEntryListener {
+class QUICHE_EXPORT HpackDecoderState : public HpackWholeEntryListener {
  public:
   explicit HpackDecoderState(HpackDecoderListener* listener);
   ~HpackDecoderState() override;
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h
index 3136e8e..a2b8605 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h
+++ b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h
@@ -20,7 +20,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackDecoderStringBuffer {
+class QUICHE_EXPORT HpackDecoderStringBuffer {
  public:
   enum class State : uint8_t { RESET, COLLECTING, COMPLETE };
   enum class Backing : uint8_t { RESET, UNBUFFERED, BUFFERED, STATIC };
@@ -93,8 +93,8 @@
   Backing backing_;
 };
 
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
-    std::ostream& out, const HpackDecoderStringBuffer& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const HpackDecoderStringBuffer& v);
 
 }  // namespace http2
 
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_tables.h b/quiche/http2/hpack/decoder/hpack_decoder_tables.h
index e78b91d..38f665d 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_tables.h
+++ b/quiche/http2/hpack/decoder/hpack_decoder_tables.h
@@ -33,7 +33,7 @@
 class HpackDecoderTablesPeer;
 }  // namespace test
 
-struct QUICHE_EXPORT_PRIVATE HpackStringPair {
+struct QUICHE_EXPORT HpackStringPair {
   HpackStringPair(std::string name, std::string value);
   ~HpackStringPair();
 
@@ -47,13 +47,13 @@
   const std::string value;
 };
 
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
-                                               const HpackStringPair& p);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+                                       const HpackStringPair& p);
 
 // See http://httpwg.org/specs/rfc7541.html#static.table.definition for the
 // contents, and http://httpwg.org/specs/rfc7541.html#index.address.space for
 // info about accessing the static table.
-class QUICHE_EXPORT_PRIVATE HpackDecoderStaticTable {
+class QUICHE_EXPORT HpackDecoderStaticTable {
  public:
   explicit HpackDecoderStaticTable(const std::vector<HpackStringPair>* table);
   // Uses a global table shared by all threads.
@@ -73,7 +73,7 @@
 // in the dynamic table. See these sections of the RFC:
 //   http://httpwg.org/specs/rfc7541.html#dynamic.table
 //   http://httpwg.org/specs/rfc7541.html#dynamic.table.management
-class QUICHE_EXPORT_PRIVATE HpackDecoderDynamicTable {
+class QUICHE_EXPORT HpackDecoderDynamicTable {
  public:
   HpackDecoderDynamicTable();
   ~HpackDecoderDynamicTable();
@@ -120,7 +120,7 @@
   size_t insert_count_;
 };
 
-class QUICHE_EXPORT_PRIVATE HpackDecoderTables {
+class QUICHE_EXPORT HpackDecoderTables {
  public:
   HpackDecoderTables();
   ~HpackDecoderTables();
diff --git a/quiche/http2/hpack/decoder/hpack_decoding_error.h b/quiche/http2/hpack/decoder/hpack_decoding_error.h
index e24eaf1..538237f 100644
--- a/quiche/http2/hpack/decoder/hpack_decoding_error.h
+++ b/quiche/http2/hpack/decoder/hpack_decoding_error.h
@@ -43,7 +43,7 @@
   kCompressedHeaderSizeExceedsLimit,
 };
 
-QUICHE_EXPORT_PRIVATE absl::string_view HpackDecodingErrorToString(
+QUICHE_EXPORT absl::string_view HpackDecodingErrorToString(
     HpackDecodingError error);
 
 }  // namespace http2
diff --git a/quiche/http2/hpack/decoder/hpack_entry_decoder.h b/quiche/http2/hpack/decoder/hpack_entry_decoder.h
index 75ffbac..85b8a78 100644
--- a/quiche/http2/hpack/decoder/hpack_entry_decoder.h
+++ b/quiche/http2/hpack/decoder/hpack_entry_decoder.h
@@ -24,7 +24,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackEntryDecoder {
+class QUICHE_EXPORT HpackEntryDecoder {
  public:
   enum class EntryDecoderState {
     // Have started decoding the type/varint, but didn't finish on the previous
@@ -80,9 +80,9 @@
   HpackDecodingError error_ = HpackDecodingError::kOk;
 };
 
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const HpackEntryDecoder& v);
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const HpackEntryDecoder& v);
+QUICHE_EXPORT std::ostream& operator<<(
     std::ostream& out, HpackEntryDecoder::EntryDecoderState state);
 
 }  // namespace http2
diff --git a/quiche/http2/hpack/decoder/hpack_entry_decoder_listener.h b/quiche/http2/hpack/decoder/hpack_entry_decoder_listener.h
index 1ba9339..86230df 100644
--- a/quiche/http2/hpack/decoder/hpack_entry_decoder_listener.h
+++ b/quiche/http2/hpack/decoder/hpack_entry_decoder_listener.h
@@ -16,7 +16,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackEntryDecoderListener {
+class QUICHE_EXPORT HpackEntryDecoderListener {
  public:
   virtual ~HpackEntryDecoderListener() {}
 
@@ -64,7 +64,7 @@
   virtual void OnDynamicTableSizeUpdate(size_t size) = 0;
 };
 
-class QUICHE_EXPORT_PRIVATE HpackEntryDecoderVLoggingListener
+class QUICHE_EXPORT HpackEntryDecoderVLoggingListener
     : public HpackEntryDecoderListener {
  public:
   HpackEntryDecoderVLoggingListener() : wrapped_(nullptr) {}
@@ -88,7 +88,7 @@
 };
 
 // A no-op implementation of HpackEntryDecoderListener.
-class QUICHE_EXPORT_PRIVATE HpackEntryDecoderNoOpListener
+class QUICHE_EXPORT HpackEntryDecoderNoOpListener
     : public HpackEntryDecoderListener {
  public:
   ~HpackEntryDecoderNoOpListener() override {}
diff --git a/quiche/http2/hpack/decoder/hpack_entry_type_decoder.h b/quiche/http2/hpack/decoder/hpack_entry_type_decoder.h
index bf6a2c9..2548ef5 100644
--- a/quiche/http2/hpack/decoder/hpack_entry_type_decoder.h
+++ b/quiche/http2/hpack/decoder/hpack_entry_type_decoder.h
@@ -22,7 +22,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackEntryTypeDecoder {
+class QUICHE_EXPORT HpackEntryTypeDecoder {
  public:
   // Only call when the decode buffer has data (i.e. HpackEntryDecoder must
   // not call until there is data).
@@ -50,8 +50,8 @@
   HpackEntryType entry_type_ = HpackEntryType::kIndexedHeader;
 };
 
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const HpackEntryTypeDecoder& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const HpackEntryTypeDecoder& v);
 
 }  // namespace http2
 #endif  // QUICHE_HTTP2_HPACK_DECODER_HPACK_ENTRY_TYPE_DECODER_H_
diff --git a/quiche/http2/hpack/decoder/hpack_string_decoder.h b/quiche/http2/hpack/decoder/hpack_string_decoder.h
index c8b88f3..897ce76 100644
--- a/quiche/http2/hpack/decoder/hpack_string_decoder.h
+++ b/quiche/http2/hpack/decoder/hpack_string_decoder.h
@@ -33,7 +33,7 @@
 // Resume() when more input is available, repeating until kDecodeInProgress is
 // not returned. If kDecodeDone or kDecodeError is returned, then Resume() must
 // not be called until Start() has been called to start decoding a new string.
-class QUICHE_EXPORT_PRIVATE HpackStringDecoder {
+class QUICHE_EXPORT HpackStringDecoder {
  public:
   enum StringDecoderState {
     kStartDecodingLength,
@@ -200,8 +200,8 @@
   bool huffman_encoded_ = false;
 };
 
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const HpackStringDecoder& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const HpackStringDecoder& v);
 
 }  // namespace http2
 #endif  // QUICHE_HTTP2_HPACK_DECODER_HPACK_STRING_DECODER_H_
diff --git a/quiche/http2/hpack/decoder/hpack_string_decoder_listener.h b/quiche/http2/hpack/decoder/hpack_string_decoder_listener.h
index c343d40..9420560 100644
--- a/quiche/http2/hpack/decoder/hpack_string_decoder_listener.h
+++ b/quiche/http2/hpack/decoder/hpack_string_decoder_listener.h
@@ -20,7 +20,7 @@
 // HpackStringDecoder methods require a listener that implements the methods
 // below, but it is NOT necessary to extend this class because the methods
 // are templates.
-class QUICHE_EXPORT_PRIVATE HpackStringDecoderListener {
+class QUICHE_EXPORT HpackStringDecoderListener {
  public:
   virtual ~HpackStringDecoderListener() {}
 
@@ -39,7 +39,7 @@
   virtual void OnStringEnd() = 0;
 };
 
-class QUICHE_EXPORT_PRIVATE HpackStringDecoderVLoggingListener
+class QUICHE_EXPORT HpackStringDecoderVLoggingListener
     : public HpackStringDecoderListener {
  public:
   HpackStringDecoderVLoggingListener() : wrapped_(nullptr) {}
diff --git a/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.h b/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.h
index 0cdde65..b7bd108 100644
--- a/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.h
+++ b/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.h
@@ -24,8 +24,7 @@
 
 // TODO(jamessynge): Consider renaming HpackEntryDecoderListener to
 // HpackEntryPartsListener or HpackEntryFragmentsListener.
-class QUICHE_EXPORT_PRIVATE HpackWholeEntryBuffer
-    : public HpackEntryDecoderListener {
+class QUICHE_EXPORT HpackWholeEntryBuffer : public HpackEntryDecoderListener {
  public:
   // max_string_size specifies the maximum size of an on-the-wire string (name
   // or value, plain or Huffman encoded) that will be accepted. See sections
diff --git a/quiche/http2/hpack/decoder/hpack_whole_entry_listener.h b/quiche/http2/hpack/decoder/hpack_whole_entry_listener.h
index a0776a6..54e4506 100644
--- a/quiche/http2/hpack/decoder/hpack_whole_entry_listener.h
+++ b/quiche/http2/hpack/decoder/hpack_whole_entry_listener.h
@@ -19,7 +19,7 @@
 
 namespace http2 {
 
-class QUICHE_EXPORT_PRIVATE HpackWholeEntryListener {
+class QUICHE_EXPORT HpackWholeEntryListener {
  public:
   virtual ~HpackWholeEntryListener();
 
@@ -55,7 +55,7 @@
 
 // A no-op implementation of HpackWholeEntryDecoderListener, useful for ignoring
 // callbacks once an error is detected.
-class QUICHE_EXPORT_PRIVATE HpackWholeEntryNoOpListener
+class QUICHE_EXPORT HpackWholeEntryNoOpListener
     : public HpackWholeEntryListener {
  public:
   ~HpackWholeEntryNoOpListener() override;
diff --git a/quiche/http2/hpack/http2_hpack_constants.h b/quiche/http2/hpack/http2_hpack_constants.h
index a10b140..1deaf05 100644
--- a/quiche/http2/hpack/http2_hpack_constants.h
+++ b/quiche/http2/hpack/http2_hpack_constants.h
@@ -52,11 +52,10 @@
 };
 
 // Returns the name of the enum member.
-QUICHE_EXPORT_PRIVATE std::string HpackEntryTypeToString(HpackEntryType v);
+QUICHE_EXPORT std::string HpackEntryTypeToString(HpackEntryType v);
 
 // Inserts the name of the enum member into |out|.
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               HpackEntryType v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out, HpackEntryType v);
 
 }  // namespace http2
 
diff --git a/quiche/http2/hpack/huffman/hpack_huffman_decoder.h b/quiche/http2/hpack/huffman/hpack_huffman_decoder.h
index 9befd6c..910aba5 100644
--- a/quiche/http2/hpack/huffman/hpack_huffman_decoder.h
+++ b/quiche/http2/hpack/huffman/hpack_huffman_decoder.h
@@ -38,7 +38,7 @@
 
 // HuffmanBitBuffer stores the leading edge of bits to be decoded. The high
 // order bit of accumulator_ is the next bit to be decoded.
-class QUICHE_EXPORT_PRIVATE HuffmanBitBuffer {
+class QUICHE_EXPORT HuffmanBitBuffer {
  public:
   HuffmanBitBuffer();
 
@@ -85,7 +85,7 @@
   return out << v.DebugString();
 }
 
-class QUICHE_EXPORT_PRIVATE HpackHuffmanDecoder {
+class QUICHE_EXPORT HpackHuffmanDecoder {
  public:
   HpackHuffmanDecoder();
   ~HpackHuffmanDecoder();
diff --git a/quiche/http2/hpack/huffman/hpack_huffman_encoder.h b/quiche/http2/hpack/huffman/hpack_huffman_encoder.h
index 7e73187..e6056c1 100644
--- a/quiche/http2/hpack/huffman/hpack_huffman_encoder.h
+++ b/quiche/http2/hpack/huffman/hpack_huffman_encoder.h
@@ -18,22 +18,20 @@
 
 // Returns the size of the Huffman encoding of |plain|, which may be greater
 // than plain.size().
-QUICHE_EXPORT_PRIVATE size_t HuffmanSize(absl::string_view plain);
+QUICHE_EXPORT size_t HuffmanSize(absl::string_view plain);
 
 // Encode the plain text string |plain| with the Huffman encoding defined in the
 // HPACK RFC, 7541.  |encoded_size| is used to pre-allocate storage and it
 // should be the value returned by HuffmanSize().  Appends the result to
 // |*huffman|.
-QUICHE_EXPORT_PRIVATE void HuffmanEncode(absl::string_view plain,
-                                         size_t encoded_size,
-                                         std::string* huffman);
+QUICHE_EXPORT void HuffmanEncode(absl::string_view plain, size_t encoded_size,
+                                 std::string* huffman);
 
 // Encode |input| with the Huffman encoding defined RFC7541, used in HPACK and
 // QPACK.  |encoded_size| must be the value returned by HuffmanSize().
 // Appends the result to the end of |*output|.
-QUICHE_EXPORT_PRIVATE void HuffmanEncodeFast(absl::string_view input,
-                                             size_t encoded_size,
-                                             std::string* output);
+QUICHE_EXPORT void HuffmanEncodeFast(absl::string_view input,
+                                     size_t encoded_size, std::string* output);
 
 }  // namespace http2
 
diff --git a/quiche/http2/hpack/huffman/huffman_spec_tables.h b/quiche/http2/hpack/huffman/huffman_spec_tables.h
index 1c1b500..7e66fef 100644
--- a/quiche/http2/hpack/huffman/huffman_spec_tables.h
+++ b/quiche/http2/hpack/huffman/huffman_spec_tables.h
@@ -13,7 +13,7 @@
 
 namespace http2 {
 
-struct QUICHE_EXPORT_PRIVATE HuffmanSpecTables {
+struct QUICHE_EXPORT HuffmanSpecTables {
   // Number of bits in the encoding of each symbol (byte).
   static const uint8_t kCodeLengths[257];
 
diff --git a/quiche/http2/hpack/varint/hpack_varint_decoder.h b/quiche/http2/hpack/varint/hpack_varint_decoder.h
index 0036752..af998a2 100644
--- a/quiche/http2/hpack/varint/hpack_varint_decoder.h
+++ b/quiche/http2/hpack/varint/hpack_varint_decoder.h
@@ -55,7 +55,7 @@
 // needed. Start and StartExtended handles the initialization of member
 // variables. This is necessary in order for HpackVarintDecoder to be part
 // of a union.
-class QUICHE_EXPORT_PRIVATE HpackVarintDecoder {
+class QUICHE_EXPORT HpackVarintDecoder {
  public:
   // |prefix_value| is the first byte of the encoded varint.
   // |prefix_length| is number of bits in the first byte that are used for
diff --git a/quiche/http2/hpack/varint/hpack_varint_encoder.h b/quiche/http2/hpack/varint/hpack_varint_encoder.h
index 69acc16..0e16009 100644
--- a/quiche/http2/hpack/varint/hpack_varint_encoder.h
+++ b/quiche/http2/hpack/varint/hpack_varint_encoder.h
@@ -16,7 +16,7 @@
 // HPACK integer encoder class with single static method implementing variable
 // length integer representation defined in RFC7541, Section 5.1:
 // https://httpwg.org/specs/rfc7541.html#integer.representation
-class QUICHE_EXPORT_PRIVATE HpackVarintEncoder {
+class QUICHE_EXPORT HpackVarintEncoder {
  public:
   // Encode |varint|, appending encoded data to |*output|.
   // Appends between 1 and 11 bytes in total.
diff --git a/quiche/http2/http2_constants.h b/quiche/http2/http2_constants.h
index 6395cf1..f4034bd 100644
--- a/quiche/http2/http2_constants.h
+++ b/quiche/http2/http2_constants.h
@@ -57,10 +57,10 @@
 // for each unsupported value. Since these are just used for debugging/error
 // messages, that isn't a cost to we need to worry about. The same applies to
 // the functions later in this file.
-QUICHE_EXPORT_PRIVATE std::string Http2FrameTypeToString(Http2FrameType v);
-QUICHE_EXPORT_PRIVATE std::string Http2FrameTypeToString(uint8_t v);
-QUICHE_EXPORT_PRIVATE inline std::ostream& operator<<(std::ostream& out,
-                                                      Http2FrameType v) {
+QUICHE_EXPORT std::string Http2FrameTypeToString(Http2FrameType v);
+QUICHE_EXPORT std::string Http2FrameTypeToString(uint8_t v);
+QUICHE_EXPORT inline std::ostream& operator<<(std::ostream& out,
+                                              Http2FrameType v) {
   return out << Http2FrameTypeToString(v);
 }
 
@@ -76,10 +76,9 @@
 
 // Formats zero or more flags for the specified type of frame. Returns an
 // empty string if flags==0.
-QUICHE_EXPORT_PRIVATE std::string Http2FrameFlagsToString(Http2FrameType type,
-                                                          uint8_t flags);
-QUICHE_EXPORT_PRIVATE std::string Http2FrameFlagsToString(uint8_t type,
-                                                          uint8_t flags);
+QUICHE_EXPORT std::string Http2FrameFlagsToString(Http2FrameType type,
+                                                  uint8_t flags);
+QUICHE_EXPORT std::string Http2FrameFlagsToString(uint8_t type, uint8_t flags);
 
 // Error codes for GOAWAY and RST_STREAM frames.
 enum class Http2ErrorCode : uint32_t {
@@ -143,10 +142,10 @@
 }
 
 // Format the specified error code.
-QUICHE_EXPORT_PRIVATE std::string Http2ErrorCodeToString(uint32_t v);
-QUICHE_EXPORT_PRIVATE std::string Http2ErrorCodeToString(Http2ErrorCode v);
-QUICHE_EXPORT_PRIVATE inline std::ostream& operator<<(std::ostream& out,
-                                                      Http2ErrorCode v) {
+QUICHE_EXPORT std::string Http2ErrorCodeToString(uint32_t v);
+QUICHE_EXPORT std::string Http2ErrorCodeToString(Http2ErrorCode v);
+QUICHE_EXPORT inline std::ostream& operator<<(std::ostream& out,
+                                              Http2ErrorCode v) {
   return out << Http2ErrorCodeToString(v);
 }
 
@@ -223,8 +222,8 @@
 }
 
 // Format the specified settings parameter.
-QUICHE_EXPORT_PRIVATE std::string Http2SettingsParameterToString(uint32_t v);
-QUICHE_EXPORT_PRIVATE std::string Http2SettingsParameterToString(
+QUICHE_EXPORT std::string Http2SettingsParameterToString(uint32_t v);
+QUICHE_EXPORT std::string Http2SettingsParameterToString(
     Http2SettingsParameter v);
 inline std::ostream& operator<<(std::ostream& out, Http2SettingsParameter v) {
   return out << Http2SettingsParameterToString(v);
@@ -232,7 +231,7 @@
 
 // Information about the initial, minimum and maximum value of settings (not
 // applicable to all settings parameters).
-class QUICHE_EXPORT_PRIVATE Http2SettingsInfo {
+class QUICHE_EXPORT Http2SettingsInfo {
  public:
   // Default value for HEADER_TABLE_SIZE.
   static constexpr uint32_t DefaultHeaderTableSize() { return 4096; }
@@ -264,7 +263,7 @@
                         quiche::StringPieceCaseEqual>;
 
 // Returns all disallowed HTTP/2 headers.
-QUICHE_EXPORT_PRIVATE const InvalidHeaderSet& GetInvalidHttp2HeaderSet();
+QUICHE_EXPORT const InvalidHeaderSet& GetInvalidHttp2HeaderSet();
 
 }  // namespace http2
 
diff --git a/quiche/http2/http2_structures.h b/quiche/http2/http2_structures.h
index 496746b..3e1e4dd 100644
--- a/quiche/http2/http2_structures.h
+++ b/quiche/http2/http2_structures.h
@@ -37,7 +37,7 @@
 
 namespace http2 {
 
-struct QUICHE_EXPORT_PRIVATE Http2FrameHeader {
+struct QUICHE_EXPORT Http2FrameHeader {
   Http2FrameHeader() {}
   Http2FrameHeader(uint32_t payload_length, Http2FrameType type, uint8_t flags,
                    uint32_t stream_id)
@@ -127,18 +127,18 @@
   uint8_t flags;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2FrameHeader& a,
-                                      const Http2FrameHeader& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2FrameHeader& a,
-                                             const Http2FrameHeader& b) {
+QUICHE_EXPORT bool operator==(const Http2FrameHeader& a,
+                              const Http2FrameHeader& b);
+QUICHE_EXPORT inline bool operator!=(const Http2FrameHeader& a,
+                                     const Http2FrameHeader& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2FrameHeader& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2FrameHeader& v);
 
 // Http2PriorityFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2PriorityFields {
+struct QUICHE_EXPORT Http2PriorityFields {
   Http2PriorityFields() {}
   Http2PriorityFields(uint32_t stream_dependency, uint32_t weight,
                       bool is_exclusive)
@@ -170,18 +170,18 @@
   bool is_exclusive;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2PriorityFields& a,
-                                      const Http2PriorityFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2PriorityFields& a,
-                                             const Http2PriorityFields& b) {
+QUICHE_EXPORT bool operator==(const Http2PriorityFields& a,
+                              const Http2PriorityFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2PriorityFields& a,
+                                     const Http2PriorityFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2PriorityFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2PriorityFields& v);
 
 // Http2RstStreamFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2RstStreamFields {
+struct QUICHE_EXPORT Http2RstStreamFields {
   static constexpr size_t EncodedSize() { return 4; }
   bool IsSupportedErrorCode() const {
     return IsSupportedHttp2ErrorCode(error_code);
@@ -190,18 +190,18 @@
   Http2ErrorCode error_code;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2RstStreamFields& a,
-                                      const Http2RstStreamFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2RstStreamFields& a,
-                                             const Http2RstStreamFields& b) {
+QUICHE_EXPORT bool operator==(const Http2RstStreamFields& a,
+                              const Http2RstStreamFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2RstStreamFields& a,
+                                     const Http2RstStreamFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2RstStreamFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2RstStreamFields& v);
 
 // Http2SettingFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2SettingFields {
+struct QUICHE_EXPORT Http2SettingFields {
   Http2SettingFields() {}
   Http2SettingFields(Http2SettingsParameter parameter, uint32_t value)
       : parameter(parameter), value(value) {}
@@ -214,52 +214,52 @@
   uint32_t value;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2SettingFields& a,
-                                      const Http2SettingFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2SettingFields& a,
-                                             const Http2SettingFields& b) {
+QUICHE_EXPORT bool operator==(const Http2SettingFields& a,
+                              const Http2SettingFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2SettingFields& a,
+                                     const Http2SettingFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2SettingFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2SettingFields& v);
 
 // Http2PushPromiseFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2PushPromiseFields {
+struct QUICHE_EXPORT Http2PushPromiseFields {
   static constexpr size_t EncodedSize() { return 4; }
 
   uint32_t promised_stream_id;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2PushPromiseFields& a,
-                                      const Http2PushPromiseFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2PushPromiseFields& a,
-                                             const Http2PushPromiseFields& b) {
+QUICHE_EXPORT bool operator==(const Http2PushPromiseFields& a,
+                              const Http2PushPromiseFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2PushPromiseFields& a,
+                                     const Http2PushPromiseFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2PushPromiseFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2PushPromiseFields& v);
 
 // Http2PingFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2PingFields {
+struct QUICHE_EXPORT Http2PingFields {
   static constexpr size_t EncodedSize() { return 8; }
 
   uint8_t opaque_bytes[8];
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2PingFields& a,
-                                      const Http2PingFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2PingFields& a,
-                                             const Http2PingFields& b) {
+QUICHE_EXPORT bool operator==(const Http2PingFields& a,
+                              const Http2PingFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2PingFields& a,
+                                     const Http2PingFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2PingFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2PingFields& v);
 
 // Http2GoAwayFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2GoAwayFields {
+struct QUICHE_EXPORT Http2GoAwayFields {
   Http2GoAwayFields() {}
   Http2GoAwayFields(uint32_t last_stream_id, Http2ErrorCode error_code)
       : last_stream_id(last_stream_id), error_code(error_code) {}
@@ -272,18 +272,18 @@
   Http2ErrorCode error_code;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2GoAwayFields& a,
-                                      const Http2GoAwayFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2GoAwayFields& a,
-                                             const Http2GoAwayFields& b) {
+QUICHE_EXPORT bool operator==(const Http2GoAwayFields& a,
+                              const Http2GoAwayFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2GoAwayFields& a,
+                                     const Http2GoAwayFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2GoAwayFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2GoAwayFields& v);
 
 // Http2WindowUpdateFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2WindowUpdateFields {
+struct QUICHE_EXPORT Http2WindowUpdateFields {
   static constexpr size_t EncodedSize() { return 4; }
 
   // 31-bit, unsigned increase in the window size (only positive values are
@@ -291,36 +291,36 @@
   uint32_t window_size_increment;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2WindowUpdateFields& a,
-                                      const Http2WindowUpdateFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2WindowUpdateFields& a,
-                                             const Http2WindowUpdateFields& b) {
+QUICHE_EXPORT bool operator==(const Http2WindowUpdateFields& a,
+                              const Http2WindowUpdateFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2WindowUpdateFields& a,
+                                     const Http2WindowUpdateFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
-    std::ostream& out, const Http2WindowUpdateFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2WindowUpdateFields& v);
 
 // Http2AltSvcFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2AltSvcFields {
+struct QUICHE_EXPORT Http2AltSvcFields {
   static constexpr size_t EncodedSize() { return 2; }
 
   // This is the one fixed size portion of the ALTSVC payload.
   uint16_t origin_length;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2AltSvcFields& a,
-                                      const Http2AltSvcFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(const Http2AltSvcFields& a,
-                                             const Http2AltSvcFields& b) {
+QUICHE_EXPORT bool operator==(const Http2AltSvcFields& a,
+                              const Http2AltSvcFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2AltSvcFields& a,
+                                     const Http2AltSvcFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               const Http2AltSvcFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2AltSvcFields& v);
 
 // Http2PriorityUpdateFields:
 
-struct QUICHE_EXPORT_PRIVATE Http2PriorityUpdateFields {
+struct QUICHE_EXPORT Http2PriorityUpdateFields {
   Http2PriorityUpdateFields() {}
   Http2PriorityUpdateFields(uint32_t prioritized_stream_id)
       : prioritized_stream_id(prioritized_stream_id) {}
@@ -333,14 +333,14 @@
   uint32_t prioritized_stream_id;
 };
 
-QUICHE_EXPORT_PRIVATE bool operator==(const Http2PriorityUpdateFields& a,
-                                      const Http2PriorityUpdateFields& b);
-QUICHE_EXPORT_PRIVATE inline bool operator!=(
-    const Http2PriorityUpdateFields& a, const Http2PriorityUpdateFields& b) {
+QUICHE_EXPORT bool operator==(const Http2PriorityUpdateFields& a,
+                              const Http2PriorityUpdateFields& b);
+QUICHE_EXPORT inline bool operator!=(const Http2PriorityUpdateFields& a,
+                                     const Http2PriorityUpdateFields& b) {
   return !(a == b);
 }
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(
-    std::ostream& out, const Http2PriorityUpdateFields& v);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       const Http2PriorityUpdateFields& v);
 
 }  // namespace http2
 
diff --git a/quiche/oblivious_http/buffers/oblivious_http_request.h b/quiche/oblivious_http/buffers/oblivious_http_request.h
index 1aef1f2..1963693 100644
--- a/quiche/oblivious_http/buffers/oblivious_http_request.h
+++ b/quiche/oblivious_http/buffers/oblivious_http_request.h
@@ -16,7 +16,7 @@
 // 2. Handles server side decryption of the payload received in HTTP POST body
 // from Relay.
 // https://www.ietf.org/archive/id/draft-ietf-ohai-ohttp-03.html#name-encapsulation-of-requests
-class QUICHE_EXPORT_PRIVATE ObliviousHttpRequest {
+class QUICHE_EXPORT ObliviousHttpRequest {
  public:
   // Holds the HPKE related data received from request. This context is created
   // during request processing, and subsequently passed into response handling
diff --git a/quiche/oblivious_http/buffers/oblivious_http_response.h b/quiche/oblivious_http/buffers/oblivious_http_response.h
index 3ebd25d..40279fc 100644
--- a/quiche/oblivious_http/buffers/oblivious_http_response.h
+++ b/quiche/oblivious_http/buffers/oblivious_http_response.h
@@ -12,7 +12,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE ObliviousHttpResponse {
+class QUICHE_EXPORT ObliviousHttpResponse {
  public:
   // Parse and decrypt the OHttp response using ObliviousHttpContext context obj
   // that was returned from `CreateClientObliviousRequest` method. On success,
diff --git a/quiche/oblivious_http/common/oblivious_http_header_key_config.h b/quiche/oblivious_http/common/oblivious_http_header_key_config.h
index 6447bab..9c46f81 100644
--- a/quiche/oblivious_http/common/oblivious_http_header_key_config.h
+++ b/quiche/oblivious_http/common/oblivious_http_header_key_config.h
@@ -14,7 +14,7 @@
 
 namespace quiche {
 
-class QUICHE_EXPORT_PRIVATE ObliviousHttpHeaderKeyConfig {
+class QUICHE_EXPORT ObliviousHttpHeaderKeyConfig {
  public:
   // https://www.ietf.org/archive/id/draft-ietf-ohai-ohttp-03.html#section-4.1-4.2
   static constexpr absl::string_view kOhttpRequestLabel =
@@ -109,7 +109,7 @@
 // for details of the "Key Configuration" spec.
 //
 // ObliviousHttpKeyConfigs objects are immutable after construction.
-class QUICHE_EXPORT_PRIVATE ObliviousHttpKeyConfigs {
+class QUICHE_EXPORT ObliviousHttpKeyConfigs {
  public:
   // Parses the "application/ohttp-keys" media type, which is a byte string
   // formatted according to the spec:
diff --git a/quiche/oblivious_http/oblivious_http_client.h b/quiche/oblivious_http/oblivious_http_client.h
index 10a2f60..93cf1a2 100644
--- a/quiche/oblivious_http/oblivious_http_client.h
+++ b/quiche/oblivious_http/oblivious_http_client.h
@@ -25,7 +25,7 @@
 // 4. Handles BoringSSL HPKE context setup and bookkeeping.
 
 // This class is immutable (except moves) and thus trivially thread-safe.
-class QUICHE_EXPORT_PRIVATE ObliviousHttpClient {
+class QUICHE_EXPORT ObliviousHttpClient {
  public:
   static absl::StatusOr<ObliviousHttpClient> Create(
       absl::string_view hpke_public_key,
diff --git a/quiche/oblivious_http/oblivious_http_gateway.h b/quiche/oblivious_http/oblivious_http_gateway.h
index 8f70356..299f2bb 100644
--- a/quiche/oblivious_http/oblivious_http_gateway.h
+++ b/quiche/oblivious_http/oblivious_http_gateway.h
@@ -23,7 +23,7 @@
 // This class is immutable (except moves) and thus trivially thread-safe,
 // assuming the `QuicheRandom* quiche_random` passed in with `Create` is
 // thread-safe. Note that default `QuicheRandom::GetInstance()` is thread-safe.
-class QUICHE_EXPORT_PRIVATE ObliviousHttpGateway {
+class QUICHE_EXPORT ObliviousHttpGateway {
  public:
   // @params: If callers would like to pass in their own `QuicheRandom`
   // instance, they can make use of the param `quiche_random`. Otherwise, the
diff --git a/quiche/quic/bindings/quic_libevent.h b/quiche/quic/bindings/quic_libevent.h
index b06ab4e..82783e9 100644
--- a/quiche/quic/bindings/quic_libevent.h
+++ b/quiche/quic/bindings/quic_libevent.h
@@ -20,7 +20,7 @@
 // Provides a libevent-based implementation of QuicEventLoop.  Since libevent
 // uses relative time for all timeouts, the provided clock does not need to use
 // the UNIX time.
-class QUICHE_EXPORT_PRIVATE LibeventQuicEventLoop : public QuicEventLoop {
+class QUICHE_EXPORT LibeventQuicEventLoop : public QuicEventLoop {
  public:
   explicit LibeventQuicEventLoop(event_base* base, QuicClock* clock);
 
@@ -91,7 +91,7 @@
 };
 
 // RAII-style wrapper around event_base.
-class QUICHE_EXPORT_PRIVATE LibeventLoop {
+class QUICHE_EXPORT LibeventLoop {
  public:
   LibeventLoop(struct event_base* base) : event_base_(base) {}
   ~LibeventLoop() { event_base_free(event_base_); }
@@ -106,7 +106,7 @@
 // that the inheritance order here matters, since otherwise the `event_base` in
 // question will be deleted before the LibeventQuicEventLoop object referencing
 // it.
-class QUICHE_EXPORT_PRIVATE LibeventQuicEventLoopWithOwnership
+class QUICHE_EXPORT LibeventQuicEventLoopWithOwnership
     : public LibeventLoop,
       public LibeventQuicEventLoop {
  public:
@@ -119,8 +119,7 @@
       : LibeventLoop(base), LibeventQuicEventLoop(base, clock) {}
 };
 
-class QUICHE_EXPORT_PRIVATE QuicLibeventEventLoopFactory
-    : public QuicEventLoopFactory {
+class QUICHE_EXPORT QuicLibeventEventLoopFactory : public QuicEventLoopFactory {
  public:
   // Provides the preferred libevent backend.
   static QuicLibeventEventLoopFactory* Get() {
diff --git a/quiche/quic/core/connecting_client_socket.h b/quiche/quic/core/connecting_client_socket.h
index d5f8ee4..0670d91 100644
--- a/quiche/quic/core/connecting_client_socket.h
+++ b/quiche/quic/core/connecting_client_socket.h
@@ -28,7 +28,7 @@
 // handles IO on a single thread, so if making calls from that typical
 // environment, it would be problematic to make a blocking call and block that
 // single thread.
-class QUICHE_EXPORT_PRIVATE ConnectingClientSocket {
+class QUICHE_EXPORT ConnectingClientSocket {
  public:
   class AsyncVisitor {
    public:
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 c85911c..a7fb32c 100644
--- a/quiche/quic/core/io/event_loop_connecting_client_socket.h
+++ b/quiche/quic/core/io/event_loop_connecting_client_socket.h
@@ -23,7 +23,7 @@
 
 // A connection-based client socket implemented using an underlying
 // QuicEventLoop.
-class QUICHE_EXPORT_PRIVATE EventLoopConnectingClientSocket
+class QUICHE_EXPORT EventLoopConnectingClientSocket
     : public ConnectingClientSocket,
       public QuicSocketEventListener {
  public:
diff --git a/quiche/quic/core/io/event_loop_socket_factory.h b/quiche/quic/core/io/event_loop_socket_factory.h
index ee9a9f3..8edf020 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_PRIVATE EventLoopSocketFactory : public SocketFactory {
+class QUICHE_EXPORT 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/socket.h b/quiche/quic/core/io/socket.h
index 8d32bc3..7298f7e 100644
--- a/quiche/quic/core/io/socket.h
+++ b/quiche/quic/core/io/socket.h
@@ -51,7 +51,7 @@
   return "unknown";
 }
 
-struct QUICHE_EXPORT_PRIVATE AcceptResult {
+struct QUICHE_EXPORT AcceptResult {
   // Socket for interacting with the accepted connection.
   SocketFd fd;
 
diff --git a/quiche/quic/core/socket_factory.h b/quiche/quic/core/socket_factory.h
index d37499d..708ff7d 100644
--- a/quiche/quic/core/socket_factory.h
+++ b/quiche/quic/core/socket_factory.h
@@ -15,7 +15,7 @@
 namespace quic {
 
 // A factory to create objects of type Socket and derived interfaces.
-class QUICHE_EXPORT_PRIVATE SocketFactory {
+class QUICHE_EXPORT SocketFactory {
  public:
   virtual ~SocketFactory() = default;
 
diff --git a/quiche/quic/platform/api/quic_export.h b/quiche/quic/platform/api/quic_export.h
index 5edb835..13e43ca 100644
--- a/quiche/quic/platform/api/quic_export.h
+++ b/quiche/quic/platform/api/quic_export.h
@@ -12,7 +12,7 @@
 
 // QUIC_EXPORT_PRIVATE is meant for QUIC functionality that is built in Chromium
 // as part of //net, and not fully contained in headers.
-#define QUIC_EXPORT_PRIVATE QUICHE_EXPORT_PRIVATE
+#define QUIC_EXPORT_PRIVATE QUICHE_EXPORT
 
 // QUIC_NO_EXPORT is meant for QUIC functionality that is either fully defined
 // in a header, or is built in Chromium as part of tests or tools.
diff --git a/quiche/spdy/core/array_output_buffer.h b/quiche/spdy/core/array_output_buffer.h
index 002c30a..edce72c 100644
--- a/quiche/spdy/core/array_output_buffer.h
+++ b/quiche/spdy/core/array_output_buffer.h
@@ -12,7 +12,7 @@
 
 namespace spdy {
 
-class QUICHE_EXPORT_PRIVATE ArrayOutputBuffer : public ZeroCopyOutputBuffer {
+class QUICHE_EXPORT ArrayOutputBuffer : public ZeroCopyOutputBuffer {
  public:
   // |buffer| is pointed to the output to write to, and |size| is the capacity
   // of the output.
diff --git a/quiche/spdy/core/header_byte_listener_interface.h b/quiche/spdy/core/header_byte_listener_interface.h
index 7b738af..308110f 100644
--- a/quiche/spdy/core/header_byte_listener_interface.h
+++ b/quiche/spdy/core/header_byte_listener_interface.h
@@ -8,7 +8,7 @@
 namespace spdy {
 
 // Listens for the receipt of uncompressed header bytes.
-class QUICHE_EXPORT_PRIVATE HeaderByteListenerInterface {
+class QUICHE_EXPORT HeaderByteListenerInterface {
  public:
   virtual ~HeaderByteListenerInterface() {}
 
diff --git a/quiche/spdy/core/hpack/hpack_constants.h b/quiche/spdy/core/hpack/hpack_constants.h
index ca57ea0..1220a38 100644
--- a/quiche/spdy/core/hpack/hpack_constants.h
+++ b/quiche/spdy/core/hpack/hpack_constants.h
@@ -19,13 +19,13 @@
 
 // An HpackPrefix signifies |bits| stored in the top |bit_size| bits
 // of an octet.
-struct QUICHE_EXPORT_PRIVATE HpackPrefix {
+struct QUICHE_EXPORT HpackPrefix {
   uint8_t bits;
   size_t bit_size;
 };
 
 // Represents a symbol and its Huffman code (stored in most-significant bits).
-struct QUICHE_EXPORT_PRIVATE HpackHuffmanSymbol {
+struct QUICHE_EXPORT HpackHuffmanSymbol {
   uint32_t code;
   uint8_t length;
   uint16_t id;
@@ -33,7 +33,7 @@
 
 // An entry in the static table. Must be a POD in order to avoid static
 // initializers, i.e. no user-defined constructors or destructors.
-struct QUICHE_EXPORT_PRIVATE HpackStaticEntry {
+struct QUICHE_EXPORT HpackStaticEntry {
   const char* const name;
   const size_t name_len;
   const char* const value;
@@ -70,17 +70,15 @@
 const HpackPrefix kHeaderTableSizeUpdateOpcode = {0b001, 3};
 
 // RFC 7541, Appendix B: Huffman Code.
-QUICHE_EXPORT_PRIVATE const std::vector<HpackHuffmanSymbol>&
-HpackHuffmanCodeVector();
+QUICHE_EXPORT const std::vector<HpackHuffmanSymbol>& HpackHuffmanCodeVector();
 
 // RFC 7541, Appendix A: Static Table Definition.
-QUICHE_EXPORT_PRIVATE const std::vector<HpackStaticEntry>&
-HpackStaticTableVector();
+QUICHE_EXPORT const std::vector<HpackStaticEntry>& HpackStaticTableVector();
 
 // Returns a HpackStaticTable instance initialized with |kHpackStaticTable|.
 // The instance is read-only, has static lifetime, and is safe to share amoung
 // threads. This function is thread-safe.
-QUICHE_EXPORT_PRIVATE const HpackStaticTable& ObtainHpackStaticTable();
+QUICHE_EXPORT const HpackStaticTable& ObtainHpackStaticTable();
 
 // RFC 7541, 8.1.2.1: Pseudo-headers start with a colon.
 const char kPseudoHeaderPrefix = ':';
diff --git a/quiche/spdy/core/hpack/hpack_decoder_adapter.h b/quiche/spdy/core/hpack/hpack_decoder_adapter.h
index 5cd16fc..d5685a5 100644
--- a/quiche/spdy/core/hpack/hpack_decoder_adapter.h
+++ b/quiche/spdy/core/hpack/hpack_decoder_adapter.h
@@ -28,7 +28,7 @@
 class HpackDecoderAdapterPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE HpackDecoderAdapter {
+class QUICHE_EXPORT HpackDecoderAdapter {
  public:
   friend test::HpackDecoderAdapterPeer;
   HpackDecoderAdapter();
@@ -91,8 +91,7 @@
   std::string detailed_error() const { return detailed_error_; }
 
  private:
-  class QUICHE_EXPORT_PRIVATE ListenerAdapter
-      : public http2::HpackDecoderListener {
+  class QUICHE_EXPORT ListenerAdapter : public http2::HpackDecoderListener {
    public:
     ListenerAdapter();
     ~ListenerAdapter() override;
diff --git a/quiche/spdy/core/hpack/hpack_encoder.h b/quiche/spdy/core/hpack/hpack_encoder.h
index d63c9f2..50e4711 100644
--- a/quiche/spdy/core/hpack/hpack_encoder.h
+++ b/quiche/spdy/core/hpack/hpack_encoder.h
@@ -30,7 +30,7 @@
 class HpackEncoderPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE HpackEncoder {
+class QUICHE_EXPORT HpackEncoder {
  public:
   using Representation = std::pair<absl::string_view, absl::string_view>;
   using Representations = std::vector<Representation>;
@@ -53,7 +53,7 @@
   // Encodes and returns the given header set as a string.
   std::string EncodeHeaderBlock(const Http2HeaderBlock& header_set);
 
-  class QUICHE_EXPORT_PRIVATE ProgressiveEncoder {
+  class QUICHE_EXPORT ProgressiveEncoder {
    public:
     virtual ~ProgressiveEncoder() {}
 
diff --git a/quiche/spdy/core/hpack/hpack_entry.h b/quiche/spdy/core/hpack/hpack_entry.h
index 26eeb6a..b57203d 100644
--- a/quiche/spdy/core/hpack/hpack_entry.h
+++ b/quiche/spdy/core/hpack/hpack_entry.h
@@ -23,7 +23,7 @@
 constexpr size_t kHpackEntrySizeOverhead = 32;
 
 // A structure for looking up entries in the static and dynamic tables.
-struct QUICHE_EXPORT_PRIVATE HpackLookupEntry {
+struct QUICHE_EXPORT HpackLookupEntry {
   absl::string_view name;
   absl::string_view value;
 
@@ -40,7 +40,7 @@
 
 // A structure for an entry in the static table (3.3.1)
 // and the header table (3.3.2).
-class QUICHE_EXPORT_PRIVATE HpackEntry {
+class QUICHE_EXPORT HpackEntry {
  public:
   HpackEntry(std::string name, std::string value);
 
diff --git a/quiche/spdy/core/hpack/hpack_header_table.h b/quiche/spdy/core/hpack/hpack_header_table.h
index 7886dde..a22b762 100644
--- a/quiche/spdy/core/hpack/hpack_header_table.h
+++ b/quiche/spdy/core/hpack/hpack_header_table.h
@@ -33,7 +33,7 @@
 constexpr size_t kHpackEntryNotFound = 0;
 
 // A data structure for the static table (2.3.1) and the dynamic table (2.3.2).
-class QUICHE_EXPORT_PRIVATE HpackHeaderTable {
+class QUICHE_EXPORT HpackHeaderTable {
  public:
   friend class test::HpackHeaderTablePeer;
 
diff --git a/quiche/spdy/core/hpack/hpack_output_stream.h b/quiche/spdy/core/hpack/hpack_output_stream.h
index cd8ce46..0d3bf8c 100644
--- a/quiche/spdy/core/hpack/hpack_output_stream.h
+++ b/quiche/spdy/core/hpack/hpack_output_stream.h
@@ -20,7 +20,7 @@
 
 // An HpackOutputStream handles all the low-level details of encoding
 // header fields.
-class QUICHE_EXPORT_PRIVATE HpackOutputStream {
+class QUICHE_EXPORT HpackOutputStream {
  public:
   HpackOutputStream();
   HpackOutputStream(const HpackOutputStream&) = delete;
diff --git a/quiche/spdy/core/hpack/hpack_static_table.h b/quiche/spdy/core/hpack/hpack_static_table.h
index fda34d1..278c242 100644
--- a/quiche/spdy/core/hpack/hpack_static_table.h
+++ b/quiche/spdy/core/hpack/hpack_static_table.h
@@ -19,7 +19,7 @@
 // encoding and decoding contexts.  Once initialized, an instance is read only
 // and may be accessed only through its const interface.  Such an instance may
 // be shared accross multiple HPACK contexts.
-class QUICHE_EXPORT_PRIVATE HpackStaticTable {
+class QUICHE_EXPORT HpackStaticTable {
  public:
   HpackStaticTable();
   ~HpackStaticTable();
diff --git a/quiche/spdy/core/http2_frame_decoder_adapter.h b/quiche/spdy/core/http2_frame_decoder_adapter.h
index f185713..adfb14c 100644
--- a/quiche/spdy/core/http2_frame_decoder_adapter.h
+++ b/quiche/spdy/core/http2_frame_decoder_adapter.h
@@ -33,7 +33,7 @@
 namespace http2 {
 
 // Adapts SpdyFramer interface to use Http2FrameDecoder.
-class QUICHE_EXPORT_PRIVATE Http2DecoderAdapter
+class QUICHE_EXPORT Http2DecoderAdapter
     : public http2::Http2FrameDecoderListener {
  public:
   // HTTP2 states.
@@ -363,7 +363,7 @@
 //      been delivered for the control frame.
 // During step 2, if the visitor is not interested in accepting the header data,
 // it should return a no-op implementation of SpdyHeadersHandlerInterface.
-class QUICHE_EXPORT_PRIVATE SpdyFramerVisitorInterface {
+class QUICHE_EXPORT SpdyFramerVisitorInterface {
  public:
   virtual ~SpdyFramerVisitorInterface() {}
 
@@ -542,7 +542,7 @@
                                      absl::string_view payload) = 0;
 };
 
-class QUICHE_EXPORT_PRIVATE ExtensionVisitorInterface {
+class QUICHE_EXPORT ExtensionVisitorInterface {
  public:
   virtual ~ExtensionVisitorInterface() {}
 
diff --git a/quiche/spdy/core/http2_header_block.h b/quiche/spdy/core/http2_header_block.h
index 867a566..e0da8f5 100644
--- a/quiche/spdy/core/http2_header_block.h
+++ b/quiche/spdy/core/http2_header_block.h
@@ -46,11 +46,11 @@
 //
 // This implementation does not make much of an effort to minimize wasted space.
 // It's expected that keys are rarely deleted from a Http2HeaderBlock.
-class QUICHE_EXPORT_PRIVATE Http2HeaderBlock {
+class QUICHE_EXPORT Http2HeaderBlock {
  private:
   // Stores a list of value fragments that can be joined later with a
   // key-dependent separator.
-  class QUICHE_EXPORT_PRIVATE HeaderValue {
+  class QUICHE_EXPORT HeaderValue {
    public:
     HeaderValue(Http2HeaderStorage* storage, absl::string_view key,
                 absl::string_view initial_value);
@@ -102,7 +102,7 @@
   // absl::string_view>, even though the underlying MapType::value_type is
   // different. Dereferencing the iterator will result in memory allocation for
   // multi-value headers.
-  class QUICHE_EXPORT_PRIVATE iterator {
+  class QUICHE_EXPORT iterator {
    public:
     // The following type definitions fulfill the requirements for iterator
     // implementations.
@@ -205,7 +205,7 @@
   // be nearly a drop-in replacement for
   // SpdyLinkedHashMap<std::string, std::string>.
   // It reads data from or writes data to a Http2HeaderStorage.
-  class QUICHE_EXPORT_PRIVATE ValueProxy {
+  class QUICHE_EXPORT ValueProxy {
    public:
     ~ValueProxy();
 
diff --git a/quiche/spdy/core/http2_header_block_hpack_listener.h b/quiche/spdy/core/http2_header_block_hpack_listener.h
index 598ec96..2733a85 100644
--- a/quiche/spdy/core/http2_header_block_hpack_listener.h
+++ b/quiche/spdy/core/http2_header_block_hpack_listener.h
@@ -11,7 +11,7 @@
 
 // This class simply gathers the key-value pairs emitted by an HpackDecoder in
 // a Http2HeaderBlock.
-class QUICHE_EXPORT_PRIVATE Http2HeaderBlockHpackListener
+class QUICHE_EXPORT Http2HeaderBlockHpackListener
     : public http2::HpackDecoderListener {
  public:
   Http2HeaderBlockHpackListener() {}
diff --git a/quiche/spdy/core/http2_header_storage.h b/quiche/spdy/core/http2_header_storage.h
index fd49cc3..bc275b3 100644
--- a/quiche/spdy/core/http2_header_storage.h
+++ b/quiche/spdy/core/http2_header_storage.h
@@ -16,7 +16,7 @@
 // Write operations always append to the last block. If there is not enough
 // space to perform the write, a new block is allocated, and any unused space
 // is wasted.
-class QUICHE_EXPORT_PRIVATE Http2HeaderStorage {
+class QUICHE_EXPORT Http2HeaderStorage {
  public:
   Http2HeaderStorage();
 
@@ -49,9 +49,9 @@
 
 // Writes |fragments| to |dst|, joined by |separator|. |dst| must be large
 // enough to hold the result. Returns the number of bytes written.
-QUICHE_EXPORT_PRIVATE size_t
-Join(char* dst, const std::vector<absl::string_view>& fragments,
-     absl::string_view separator);
+QUICHE_EXPORT size_t Join(char* dst,
+                          const std::vector<absl::string_view>& fragments,
+                          absl::string_view separator);
 
 }  // namespace spdy
 
diff --git a/quiche/spdy/core/metadata_extension.h b/quiche/spdy/core/metadata_extension.h
index a749904..9ac2b91 100644
--- a/quiche/spdy/core/metadata_extension.h
+++ b/quiche/spdy/core/metadata_extension.h
@@ -21,8 +21,7 @@
 // a setting with a setting ID of kMetadataExtensionId and a value of 1.
 //
 // Metadata is represented as a HPACK header block with literal encoding.
-class QUICHE_EXPORT_PRIVATE MetadataVisitor
-    : public spdy::ExtensionVisitorInterface {
+class QUICHE_EXPORT MetadataVisitor : public spdy::ExtensionVisitorInterface {
  public:
   using MetadataPayload = spdy::Http2HeaderBlock;
 
@@ -93,7 +92,7 @@
 
 // This class uses an HpackEncoder to serialize a METADATA block as a series of
 // METADATA frames.
-class QUICHE_EXPORT_PRIVATE MetadataFrameSequence {
+class QUICHE_EXPORT MetadataFrameSequence {
  public:
   MetadataFrameSequence(SpdyStreamId stream_id, spdy::Http2HeaderBlock payload);
 
diff --git a/quiche/spdy/core/no_op_headers_handler.h b/quiche/spdy/core/no_op_headers_handler.h
index 9db36d2..2e0c82f 100644
--- a/quiche/spdy/core/no_op_headers_handler.h
+++ b/quiche/spdy/core/no_op_headers_handler.h
@@ -9,8 +9,7 @@
 
 // Drops all header data, but passes information about header bytes parsed to
 // a listener.
-class QUICHE_EXPORT_PRIVATE NoOpHeadersHandler
-    : public SpdyHeadersHandlerInterface {
+class QUICHE_EXPORT NoOpHeadersHandler : public SpdyHeadersHandlerInterface {
  public:
   // Does not take ownership of listener.
   explicit NoOpHeadersHandler(HeaderByteListenerInterface* listener)
diff --git a/quiche/spdy/core/recording_headers_handler.h b/quiche/spdy/core/recording_headers_handler.h
index a605944..54165eb 100644
--- a/quiche/spdy/core/recording_headers_handler.h
+++ b/quiche/spdy/core/recording_headers_handler.h
@@ -18,7 +18,7 @@
 
 // RecordingHeadersHandler copies the headers emitted from the deframer, and
 // when needed can forward events to another wrapped handler.
-class QUICHE_EXPORT_PRIVATE RecordingHeadersHandler
+class QUICHE_EXPORT RecordingHeadersHandler
     : public SpdyHeadersHandlerInterface {
  public:
   explicit RecordingHeadersHandler(
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format.h b/quiche/spdy/core/spdy_alt_svc_wire_format.h
index 66e54c7..ec0c124 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format.h
+++ b/quiche/spdy/core/spdy_alt_svc_wire_format.h
@@ -24,11 +24,11 @@
 class SpdyAltSvcWireFormatPeer;
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE SpdyAltSvcWireFormat {
+class QUICHE_EXPORT SpdyAltSvcWireFormat {
  public:
   using VersionVector = absl::InlinedVector<uint32_t, 8>;
 
-  struct QUICHE_EXPORT_PRIVATE AlternativeService {
+  struct QUICHE_EXPORT AlternativeService {
     std::string protocol_id;
     std::string host;
 
diff --git a/quiche/spdy/core/spdy_frame_builder.h b/quiche/spdy/core/spdy_frame_builder.h
index 8fec09b..69cf352 100644
--- a/quiche/spdy/core/spdy_frame_builder.h
+++ b/quiche/spdy/core/spdy_frame_builder.h
@@ -29,7 +29,7 @@
 // to a frame instance.  The SpdyFrameBuilder grows its internal memory buffer
 // dynamically to hold the sequence of primitive values.   The internal memory
 // buffer is exposed as the "data" of the SpdyFrameBuilder.
-class QUICHE_EXPORT_PRIVATE SpdyFrameBuilder {
+class QUICHE_EXPORT SpdyFrameBuilder {
  public:
   // Initializes a SpdyFrameBuilder with a buffer of given size
   explicit SpdyFrameBuilder(size_t size);
diff --git a/quiche/spdy/core/spdy_frame_builder_test.cc b/quiche/spdy/core/spdy_frame_builder_test.cc
index b981a58..293d7d8 100644
--- a/quiche/spdy/core/spdy_frame_builder_test.cc
+++ b/quiche/spdy/core/spdy_frame_builder_test.cc
@@ -16,7 +16,7 @@
 
 namespace test {
 
-class QUICHE_EXPORT_PRIVATE SpdyFrameBuilderPeer {
+class QUICHE_EXPORT SpdyFrameBuilderPeer {
  public:
   static char* GetWritableBuffer(SpdyFrameBuilder* builder, size_t length) {
     return builder->GetWritableBuffer(length);
diff --git a/quiche/spdy/core/spdy_framer.h b/quiche/spdy/core/spdy_framer.h
index db8a64a..ea886ca 100644
--- a/quiche/spdy/core/spdy_framer.h
+++ b/quiche/spdy/core/spdy_framer.h
@@ -32,7 +32,7 @@
 
 }  // namespace test
 
-class QUICHE_EXPORT_PRIVATE SpdyFrameSequence {
+class QUICHE_EXPORT SpdyFrameSequence {
  public:
   virtual ~SpdyFrameSequence() {}
 
@@ -47,7 +47,7 @@
   virtual const SpdyFrameIR& GetIR() const = 0;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyFramer {
+class QUICHE_EXPORT SpdyFramer {
  public:
   enum CompressionOption {
     ENABLE_COMPRESSION,
@@ -252,7 +252,7 @@
   //     // Write failed;
   //   }
   // }
-  class QUICHE_EXPORT_PRIVATE SpdyFrameIterator : public SpdyFrameSequence {
+  class QUICHE_EXPORT SpdyFrameIterator : public SpdyFrameSequence {
    public:
     // Creates an iterator with the provided framer.
     // Does not take ownership of |framer|.
@@ -295,8 +295,7 @@
   // Iteratively converts a SpdyHeadersIR (with a possibly huge
   // Http2HeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
   // write to the output.
-  class QUICHE_EXPORT_PRIVATE SpdyHeaderFrameIterator
-      : public SpdyFrameIterator {
+  class QUICHE_EXPORT SpdyHeaderFrameIterator : public SpdyFrameIterator {
    public:
     // Does not take ownership of |framer|. Take ownership of |headers_ir|.
     SpdyHeaderFrameIterator(SpdyFramer* framer,
@@ -316,8 +315,7 @@
   // Iteratively converts a SpdyPushPromiseIR (with a possibly huge
   // Http2HeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
   // write to the output.
-  class QUICHE_EXPORT_PRIVATE SpdyPushPromiseFrameIterator
-      : public SpdyFrameIterator {
+  class QUICHE_EXPORT SpdyPushPromiseFrameIterator : public SpdyFrameIterator {
    public:
     // Does not take ownership of |framer|. Take ownership of |push_promise_ir|.
     SpdyPushPromiseFrameIterator(
@@ -337,8 +335,7 @@
 
   // Converts a SpdyFrameIR into one Spdy frame (a sequence of length 1), and
   // write it to the output.
-  class QUICHE_EXPORT_PRIVATE SpdyControlFrameIterator
-      : public SpdyFrameSequence {
+  class QUICHE_EXPORT SpdyControlFrameIterator : public SpdyFrameSequence {
    public:
     SpdyControlFrameIterator(SpdyFramer* framer,
                              std::unique_ptr<const SpdyFrameIR> frame_ir);
diff --git a/quiche/spdy/core/spdy_headers_handler_interface.h b/quiche/spdy/core/spdy_headers_handler_interface.h
index 00f95da..6298741 100644
--- a/quiche/spdy/core/spdy_headers_handler_interface.h
+++ b/quiche/spdy/core/spdy_headers_handler_interface.h
@@ -14,7 +14,7 @@
 
 // This interface defines how an object that accepts header data should behave.
 // It is used by both SpdyHeadersBlockParser and HpackDecoder.
-class QUICHE_EXPORT_PRIVATE SpdyHeadersHandlerInterface {
+class QUICHE_EXPORT SpdyHeadersHandlerInterface {
  public:
   virtual ~SpdyHeadersHandlerInterface() {}
 
diff --git a/quiche/spdy/core/spdy_intrusive_list.h b/quiche/spdy/core/spdy_intrusive_list.h
index bbced57..bdf1614 100644
--- a/quiche/spdy/core/spdy_intrusive_list.h
+++ b/quiche/spdy/core/spdy_intrusive_list.h
@@ -97,7 +97,7 @@
 class SpdyIntrusiveList;
 
 template <typename T, typename ListID = void>
-class QUICHE_EXPORT_PRIVATE SpdyIntrusiveLink {
+class QUICHE_EXPORT SpdyIntrusiveLink {
  protected:
   // We declare the constructor protected so that only derived types and the
   // befriended list can construct this.
@@ -122,7 +122,7 @@
 };
 
 template <typename T, typename ListID = void>
-class QUICHE_EXPORT_PRIVATE SpdyIntrusiveList {
+class QUICHE_EXPORT SpdyIntrusiveList {
   template <typename QualifiedT, typename QualifiedLinkT>
   class iterator_impl;
 
@@ -268,7 +268,7 @@
   // variant of T and the matching qualified link type. Essentially, QualifiedT
   // will either be 'T' or 'const T', the latter for a const_iterator.
   template <typename QualifiedT, typename QualifiedLinkT>
-  class QUICHE_EXPORT_PRIVATE iterator_impl {
+  class QUICHE_EXPORT iterator_impl {
    public:
     using iterator_category = std::bidirectional_iterator_tag;
     using value_type = QualifiedT;
diff --git a/quiche/spdy/core/spdy_no_op_visitor.h b/quiche/spdy/core/spdy_no_op_visitor.h
index e8fd79d..b20c9c3 100644
--- a/quiche/spdy/core/spdy_no_op_visitor.h
+++ b/quiche/spdy/core/spdy_no_op_visitor.h
@@ -18,10 +18,9 @@
 
 namespace spdy {
 
-class QUICHE_EXPORT_PRIVATE SpdyNoOpVisitor
-    : public SpdyFramerVisitorInterface,
-      public SpdyFramerDebugVisitorInterface,
-      public SpdyHeadersHandlerInterface {
+class QUICHE_EXPORT SpdyNoOpVisitor : public SpdyFramerVisitorInterface,
+                                      public SpdyFramerDebugVisitorInterface,
+                                      public SpdyHeadersHandlerInterface {
  public:
   SpdyNoOpVisitor();
   ~SpdyNoOpVisitor() override;
diff --git a/quiche/spdy/core/spdy_pinnable_buffer_piece.h b/quiche/spdy/core/spdy_pinnable_buffer_piece.h
index 1b1bd32..d73a400 100644
--- a/quiche/spdy/core/spdy_pinnable_buffer_piece.h
+++ b/quiche/spdy/core/spdy_pinnable_buffer_piece.h
@@ -20,7 +20,7 @@
 // Represents a piece of consumed buffer which may (or may not) own its
 // underlying storage. Users may "pin" the buffer at a later time to ensure
 // a SpdyPinnableBufferPiece owns and retains storage of the buffer.
-struct QUICHE_EXPORT_PRIVATE SpdyPinnableBufferPiece {
+struct QUICHE_EXPORT SpdyPinnableBufferPiece {
  public:
   SpdyPinnableBufferPiece();
   ~SpdyPinnableBufferPiece();
diff --git a/quiche/spdy/core/spdy_prefixed_buffer_reader.h b/quiche/spdy/core/spdy_prefixed_buffer_reader.h
index d0d3956..c102ee6 100644
--- a/quiche/spdy/core/spdy_prefixed_buffer_reader.h
+++ b/quiche/spdy/core/spdy_prefixed_buffer_reader.h
@@ -14,7 +14,7 @@
 
 // Reader class which simplifies reading contiguously from
 // from a disjoint buffer prefix & suffix.
-class QUICHE_EXPORT_PRIVATE SpdyPrefixedBufferReader {
+class QUICHE_EXPORT SpdyPrefixedBufferReader {
  public:
   SpdyPrefixedBufferReader(const char* prefix, size_t prefix_length,
                            const char* suffix, size_t suffix_length);
diff --git a/quiche/spdy/core/spdy_protocol.h b/quiche/spdy/core/spdy_protocol.h
index 1166125..d475cb0 100644
--- a/quiche/spdy/core/spdy_protocol.h
+++ b/quiche/spdy/core/spdy_protocol.h
@@ -81,7 +81,7 @@
 // defined as a string literal with a null terminator, the actual connection
 // preface is only the first |kHttp2ConnectionHeaderPrefixSize| bytes, which
 // excludes the null terminator.
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2ConnectionHeaderPrefix;
+QUICHE_EXPORT extern const char* const kHttp2ConnectionHeaderPrefix;
 const int kHttp2ConnectionHeaderPrefixSize = 24;
 
 // Wire values for HTTP2 frame types.
@@ -163,13 +163,13 @@
 
 // This explicit operator is needed, otherwise compiler finds
 // overloaded operator to be ambiguous.
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               SpdyKnownSettingsId id);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       SpdyKnownSettingsId id);
 
 // This operator is needed, because SpdyFrameType is an enum class,
 // therefore implicit conversion to underlying integer type is not allowed.
-QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                               SpdyFrameType frame_type);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       SpdyFrameType frame_type);
 
 using SettingsMap = std::map<SpdySettingsId, uint32_t>;
 
@@ -211,7 +211,7 @@
 const SpdyPriority kV3LowestPriority = 7;
 
 // Returns SPDY 3.x priority value clamped to the valid range of [0, 7].
-QUICHE_EXPORT_PRIVATE SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
+QUICHE_EXPORT SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
 
 // HTTP/2 stream weights are integers in range [1, 256], as specified in RFC
 // 7540 section 5.3.2. Default stream weight is defined in section 5.3.5.
@@ -220,19 +220,19 @@
 const int kHttp2DefaultStreamWeight = 16;
 
 // Returns HTTP/2 weight clamped to the valid range of [1, 256].
-QUICHE_EXPORT_PRIVATE int ClampHttp2Weight(int weight);
+QUICHE_EXPORT int ClampHttp2Weight(int weight);
 
 // Maps SPDY 3.x priority value in range [0, 7] to HTTP/2 weight value in range
 // [1, 256], where priority 0 (i.e. highest precedence) corresponds to maximum
 // weight 256 and priority 7 (lowest precedence) corresponds to minimum weight
 // 1.
-QUICHE_EXPORT_PRIVATE int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
+QUICHE_EXPORT int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
 
 // Maps HTTP/2 weight value in range [1, 256] to SPDY 3.x priority value in
 // range [0, 7], where minimum weight 1 corresponds to priority 7 (lowest
 // precedence) and maximum weight 256 corresponds to priority 0 (highest
 // precedence).
-QUICHE_EXPORT_PRIVATE SpdyPriority Http2WeightToSpdy3Priority(int weight);
+QUICHE_EXPORT SpdyPriority Http2WeightToSpdy3Priority(int weight);
 
 // Reserved ID for root stream of HTTP/2 stream dependency tree, as specified
 // in RFC 7540 section 5.3.1.
@@ -242,47 +242,46 @@
 
 // Returns true if a given on-the-wire enumeration of a frame type is defined
 // in a standardized HTTP/2 specification, false otherwise.
-QUICHE_EXPORT_PRIVATE bool IsDefinedFrameType(uint8_t frame_type_field);
+QUICHE_EXPORT bool IsDefinedFrameType(uint8_t frame_type_field);
 
 // Parses a frame type from an on-the-wire enumeration.
 // Behavior is undefined for invalid frame type fields; consumers should first
 // use IsValidFrameType() to verify validity of frame type fields.
-QUICHE_EXPORT_PRIVATE SpdyFrameType ParseFrameType(uint8_t frame_type_field);
+QUICHE_EXPORT SpdyFrameType ParseFrameType(uint8_t frame_type_field);
 
 // Serializes a frame type to the on-the-wire value.
-QUICHE_EXPORT_PRIVATE uint8_t SerializeFrameType(SpdyFrameType frame_type);
+QUICHE_EXPORT uint8_t SerializeFrameType(SpdyFrameType frame_type);
 
 // (HTTP/2) All standard frame types except WINDOW_UPDATE are
 // (stream-specific xor connection-level). Returns false iff we know
 // the given frame type does not align with the given streamID.
-QUICHE_EXPORT_PRIVATE bool IsValidHTTP2FrameStreamId(
+QUICHE_EXPORT bool IsValidHTTP2FrameStreamId(
     SpdyStreamId current_frame_stream_id, SpdyFrameType frame_type_field);
 
 // Serialize |frame_type| to string for logging/debugging.
-QUICHE_EXPORT_PRIVATE const char* FrameTypeToString(SpdyFrameType frame_type);
+QUICHE_EXPORT const char* FrameTypeToString(SpdyFrameType frame_type);
 
 // If |wire_setting_id| is the on-the-wire representation of a defined SETTINGS
 // parameter, parse it to |*setting_id| and return true.
-QUICHE_EXPORT_PRIVATE bool ParseSettingsId(SpdySettingsId wire_setting_id,
-                                           SpdyKnownSettingsId* setting_id);
+QUICHE_EXPORT bool ParseSettingsId(SpdySettingsId wire_setting_id,
+                                   SpdyKnownSettingsId* setting_id);
 
 // Returns a string representation of the |id| for logging/debugging. Returns
 // the |id| prefixed with "SETTINGS_UNKNOWN_" for unknown SETTINGS IDs. To parse
 // the |id| into a SpdyKnownSettingsId (if applicable), use ParseSettingsId().
-QUICHE_EXPORT_PRIVATE std::string SettingsIdToString(SpdySettingsId id);
+QUICHE_EXPORT std::string SettingsIdToString(SpdySettingsId id);
 
 // Parse |wire_error_code| to a SpdyErrorCode.
 // Treat unrecognized error codes as INTERNAL_ERROR
 // as recommended by the HTTP/2 specification.
-QUICHE_EXPORT_PRIVATE SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
+QUICHE_EXPORT SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
 
 // Serialize RST_STREAM or GOAWAY frame error code to string
 // for logging/debugging.
-QUICHE_EXPORT_PRIVATE const char* ErrorCodeToString(SpdyErrorCode error_code);
+QUICHE_EXPORT const char* ErrorCodeToString(SpdyErrorCode error_code);
 
 // Serialize |type| to string for logging/debugging.
-QUICHE_EXPORT_PRIVATE const char* WriteSchedulerTypeToString(
-    WriteSchedulerType type);
+QUICHE_EXPORT const char* WriteSchedulerTypeToString(WriteSchedulerType type);
 
 // Minimum size of a frame, in octets.
 const size_t kFrameMinimumSize = kFrameHeaderSize;
@@ -327,30 +326,30 @@
 // Initial window size for a session in bytes.
 const int32_t kInitialSessionWindowSize = 64 * 1024 - 1;
 // The NPN string for HTTP2, "h2".
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2Npn;
+QUICHE_EXPORT extern const char* const kHttp2Npn;
 // An estimate size of the HPACK overhead for each header field. 1 bytes for
 // indexed literal, 1 bytes for key literal and length encoding, and 2 bytes for
 // value literal and length encoding.
 const size_t kPerHeaderHpackOverhead = 4;
 
 // Names of pseudo-headers defined for HTTP/2 requests.
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2AuthorityHeader;
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2MethodHeader;
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2PathHeader;
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2SchemeHeader;
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2ProtocolHeader;
+QUICHE_EXPORT extern const char* const kHttp2AuthorityHeader;
+QUICHE_EXPORT extern const char* const kHttp2MethodHeader;
+QUICHE_EXPORT extern const char* const kHttp2PathHeader;
+QUICHE_EXPORT extern const char* const kHttp2SchemeHeader;
+QUICHE_EXPORT extern const char* const kHttp2ProtocolHeader;
 
 // Name of pseudo-header defined for HTTP/2 responses.
-QUICHE_EXPORT_PRIVATE extern const char* const kHttp2StatusHeader;
+QUICHE_EXPORT extern const char* const kHttp2StatusHeader;
 
-QUICHE_EXPORT_PRIVATE size_t GetNumberRequiredContinuationFrames(size_t size);
+QUICHE_EXPORT size_t GetNumberRequiredContinuationFrames(size_t size);
 
 // Variant type (i.e. tagged union) that is either a SPDY 3.x priority value,
 // or else an HTTP/2 stream dependency tuple {parent stream ID, weight,
 // exclusive bit}. Templated to allow for use by QUIC code; SPDY and HTTP/2
 // code should use the concrete type instantiation SpdyStreamPrecedence.
 template <typename StreamIdType>
-class QUICHE_EXPORT_PRIVATE StreamPrecedence {
+class QUICHE_EXPORT StreamPrecedence {
  public:
   // Constructs instance that is a SPDY 3.x priority. Clamps priority value to
   // the valid range [0, 7].
@@ -426,7 +425,7 @@
   }
 
  private:
-  struct QUICHE_EXPORT_PRIVATE Http2StreamDependency {
+  struct QUICHE_EXPORT Http2StreamDependency {
     StreamIdType parent_id;
     int weight;
     bool is_exclusive;
@@ -444,7 +443,7 @@
 class SpdyFrameVisitor;
 
 // Intermediate representation for HTTP2 frames.
-class QUICHE_EXPORT_PRIVATE SpdyFrameIR {
+class QUICHE_EXPORT SpdyFrameIR {
  public:
   virtual ~SpdyFrameIR() {}
 
@@ -472,7 +471,7 @@
 
 // Abstract class intended to be inherited by IRs that have the option of a FIN
 // flag.
-class QUICHE_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyFrameWithFinIR : public SpdyFrameIR {
  public:
   ~SpdyFrameWithFinIR() override {}
   bool fin() const override;
@@ -490,8 +489,7 @@
 
 // Abstract class intended to be inherited by IRs that contain a header
 // block. Implies SpdyFrameWithFinIR.
-class QUICHE_EXPORT_PRIVATE SpdyFrameWithHeaderBlockIR
-    : public SpdyFrameWithFinIR {
+class QUICHE_EXPORT SpdyFrameWithHeaderBlockIR : public SpdyFrameWithFinIR {
  public:
   ~SpdyFrameWithHeaderBlockIR() override;
 
@@ -515,7 +513,7 @@
   Http2HeaderBlock header_block_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyDataIR : public SpdyFrameWithFinIR {
+class QUICHE_EXPORT SpdyDataIR : public SpdyFrameWithFinIR {
  public:
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, absl::string_view data);
@@ -589,7 +587,7 @@
   int padding_payload_len_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyRstStreamIR : public SpdyFrameIR {
  public:
   SpdyRstStreamIR(SpdyStreamId stream_id, SpdyErrorCode error_code);
   SpdyRstStreamIR(const SpdyRstStreamIR&) = delete;
@@ -610,7 +608,7 @@
   SpdyErrorCode error_code_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdySettingsIR : public SpdyFrameIR {
  public:
   SpdySettingsIR();
   SpdySettingsIR(const SpdySettingsIR&) = delete;
@@ -635,7 +633,7 @@
   bool is_ack_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyPingIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyPingIR : public SpdyFrameIR {
  public:
   explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {}
   SpdyPingIR(const SpdyPingIR&) = delete;
@@ -656,7 +654,7 @@
   bool is_ack_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyGoAwayIR : public SpdyFrameIR {
  public:
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
@@ -703,7 +701,7 @@
   const absl::string_view description_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
+class QUICHE_EXPORT SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdyHeadersIR(SpdyStreamId stream_id)
       : SpdyHeadersIR(stream_id, Http2HeaderBlock()) {}
@@ -745,7 +743,7 @@
   int padding_payload_len_ = 0;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyWindowUpdateIR : public SpdyFrameIR {
  public:
   SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
       : SpdyFrameIR(stream_id) {
@@ -771,8 +769,7 @@
   int32_t delta_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyPushPromiseIR
-    : public SpdyFrameWithHeaderBlockIR {
+class QUICHE_EXPORT SpdyPushPromiseIR : public SpdyFrameWithHeaderBlockIR {
  public:
   SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
       : SpdyPushPromiseIR(stream_id, promised_stream_id, Http2HeaderBlock()) {}
@@ -809,7 +806,7 @@
   int padding_payload_len_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyContinuationIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyContinuationIR : public SpdyFrameIR {
  public:
   explicit SpdyContinuationIR(SpdyStreamId stream_id);
   SpdyContinuationIR(const SpdyContinuationIR&) = delete;
@@ -831,7 +828,7 @@
   bool end_headers_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyAltSvcIR : public SpdyFrameIR {
  public:
   explicit SpdyAltSvcIR(SpdyStreamId stream_id);
   SpdyAltSvcIR(const SpdyAltSvcIR&) = delete;
@@ -859,7 +856,7 @@
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyPriorityIR : public SpdyFrameIR {
  public:
   SpdyPriorityIR(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
                  int weight, bool exclusive)
@@ -885,7 +882,7 @@
   bool exclusive_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyPriorityUpdateIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyPriorityUpdateIR : public SpdyFrameIR {
  public:
   SpdyPriorityUpdateIR(SpdyStreamId stream_id,
                        SpdyStreamId prioritized_stream_id,
@@ -911,7 +908,7 @@
   std::string priority_field_value_;
 };
 
-struct QUICHE_EXPORT_PRIVATE AcceptChOriginValuePair {
+struct QUICHE_EXPORT AcceptChOriginValuePair {
   std::string origin;
   std::string value;
   bool operator==(const AcceptChOriginValuePair& rhs) const {
@@ -919,7 +916,7 @@
   }
 };
 
-class QUICHE_EXPORT_PRIVATE SpdyAcceptChIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyAcceptChIR : public SpdyFrameIR {
  public:
   SpdyAcceptChIR(std::vector<AcceptChOriginValuePair> entries)
       : entries_(std::move(entries)) {}
@@ -941,7 +938,7 @@
 };
 
 // Represents a frame of unrecognized type.
-class QUICHE_EXPORT_PRIVATE SpdyUnknownIR : public SpdyFrameIR {
+class QUICHE_EXPORT SpdyUnknownIR : public SpdyFrameIR {
  public:
   SpdyUnknownIR(SpdyStreamId stream_id, uint8_t type, uint8_t flags,
                 std::string payload)
@@ -976,7 +973,7 @@
   const std::string payload_;
 };
 
-class QUICHE_EXPORT_PRIVATE SpdySerializedFrame {
+class QUICHE_EXPORT SpdySerializedFrame {
  public:
   SpdySerializedFrame()
       : frame_(const_cast<char*>("")), size_(0), owns_buffer_(false) {}
@@ -1062,7 +1059,7 @@
 // having to know what type they are.  An instance of this interface can be
 // passed to a SpdyFrameIR's Visit method, and the appropriate type-specific
 // method of this class will be called.
-class QUICHE_EXPORT_PRIVATE SpdyFrameVisitor {
+class QUICHE_EXPORT SpdyFrameVisitor {
  public:
   SpdyFrameVisitor() {}
   SpdyFrameVisitor(const SpdyFrameVisitor&) = delete;
@@ -1094,7 +1091,7 @@
 // operates.
 //
 // Most HTTP2 implementations need not bother with this interface at all.
-class QUICHE_EXPORT_PRIVATE SpdyFramerDebugVisitorInterface {
+class QUICHE_EXPORT SpdyFramerDebugVisitorInterface {
  public:
   virtual ~SpdyFramerDebugVisitorInterface() {}
 
diff --git a/quiche/spdy/core/spdy_simple_arena.h b/quiche/spdy/core/spdy_simple_arena.h
index a423a79..dae6879 100644
--- a/quiche/spdy/core/spdy_simple_arena.h
+++ b/quiche/spdy/core/spdy_simple_arena.h
@@ -14,9 +14,9 @@
 
 // Allocates large blocks of memory, and doles them out in smaller chunks.
 // Not thread-safe.
-class QUICHE_EXPORT_PRIVATE SpdySimpleArena {
+class QUICHE_EXPORT SpdySimpleArena {
  public:
-  class QUICHE_EXPORT_PRIVATE Status {
+  class QUICHE_EXPORT Status {
    private:
     friend class SpdySimpleArena;
     size_t bytes_allocated_;
@@ -52,7 +52,7 @@
   Status status() const { return status_; }
 
  private:
-  struct QUICHE_EXPORT_PRIVATE Block {
+  struct QUICHE_EXPORT Block {
     std::unique_ptr<char[]> data;
     size_t size = 0;
     size_t used = 0;
diff --git a/quiche/spdy/core/zero_copy_output_buffer.h b/quiche/spdy/core/zero_copy_output_buffer.h
index 2536979..2ab92ed 100644
--- a/quiche/spdy/core/zero_copy_output_buffer.h
+++ b/quiche/spdy/core/zero_copy_output_buffer.h
@@ -11,7 +11,7 @@
 
 namespace spdy {
 
-class QUICHE_EXPORT_PRIVATE ZeroCopyOutputBuffer {
+class QUICHE_EXPORT ZeroCopyOutputBuffer {
  public:
   virtual ~ZeroCopyOutputBuffer() {}