Rename QUICHE_EXPORT_PRIVATE to QUICHE_EXPORT
We do not distinguish between those in practice, and this is causing confusion, so we should stick to one, and QUICHE_EXPORT is shorter.
PiperOrigin-RevId: 482823752
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() {}
