Migrate `absl::variant` to `std::variant`
This was largely automated with the following commands:
```
fgrep -lr '"third_party/absl/types/variant.h"' third_party/{quiche,http2,quic} | xargs sed -i -e 's;"third_party/absl/types/variant.h";<variant>;g'
fgrep -lr 'absl::visit' third_party/{quiche,http2,quic} | grep -v METADATA.common | xargs sed -i -e 's/absl::visit/std::visit/g'
fgrep -lr 'absl::variant' third_party/{quiche,http2,quic} | grep -v METADATA.common | xargs sed -i -e 's/absl::variant/std::variant/g'
fgrep -lr 'absl::get' third_party/{quiche,http2,quic} | grep -v METADATA.common | xargs sed -i -e 's/absl::get/std::get/g'
fgrep -lr 'absl::holds_alternative' third_party/{quiche,http2,quic} | grep -v METADATA.common | xargs sed -i -e 's/absl::holds_alternative/std::holds_alternative/g'
fgrep -lr 'absl::monostate' third_party/{quiche,http2,quic} | grep -v METADATA.common | xargs sed -i -e 's/absl::monostate/std::monostate/g'
```
This should be a no-op when `absl::variant` is already a typedef for `std::variant`, which should now be the case everywhere.
PiperOrigin-RevId: 738550360
diff --git a/quiche/common/capsule.cc b/quiche/common/capsule.cc
index 90da0d7..ad25bbc 100644
--- a/quiche/common/capsule.cc
+++ b/quiche/common/capsule.cc
@@ -13,6 +13,7 @@
#include <string>
#include <type_traits>
#include <utility>
+#include <variant>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
@@ -20,7 +21,6 @@
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
-#include "absl/types/variant.h"
#include "quiche/common/platform/api/quiche_bug_tracker.h"
#include "quiche/common/platform/api/quiche_export.h"
#include "quiche/common/platform/api/quiche_logging.h"
@@ -230,8 +230,8 @@
}
std::string Capsule::ToString() const {
- return absl::visit([](const auto& capsule) { return capsule.ToString(); },
- capsule_);
+ return std::visit([](const auto& capsule) { return capsule.ToString(); },
+ capsule_);
}
std::ostream& operator<<(std::ostream& os, const Capsule& capsule) {
diff --git a/quiche/common/capsule.h b/quiche/common/capsule.h
index ec71c2b..45970db 100644
--- a/quiche/common/capsule.h
+++ b/quiche/common/capsule.h
@@ -10,11 +10,11 @@
#include <cstdint>
#include <optional>
#include <string>
+#include <variant>
#include <vector>
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/common/platform/api/quiche_export.h"
#include "quiche/common/platform/api/quiche_logging.h"
#include "quiche/common/quiche_buffer_allocator.h"
@@ -265,114 +265,114 @@
const Capsule& capsule);
CapsuleType capsule_type() const {
- return absl::visit(
+ return std::visit(
[](const auto& capsule) { return capsule.capsule_type(); }, capsule_);
}
DatagramCapsule& datagram_capsule() {
- return absl::get<DatagramCapsule>(capsule_);
+ return std::get<DatagramCapsule>(capsule_);
}
const DatagramCapsule& datagram_capsule() const {
- return absl::get<DatagramCapsule>(capsule_);
+ return std::get<DatagramCapsule>(capsule_);
}
LegacyDatagramCapsule& legacy_datagram_capsule() {
- return absl::get<LegacyDatagramCapsule>(capsule_);
+ return std::get<LegacyDatagramCapsule>(capsule_);
}
const LegacyDatagramCapsule& legacy_datagram_capsule() const {
- return absl::get<LegacyDatagramCapsule>(capsule_);
+ return std::get<LegacyDatagramCapsule>(capsule_);
}
LegacyDatagramWithoutContextCapsule&
legacy_datagram_without_context_capsule() {
- return absl::get<LegacyDatagramWithoutContextCapsule>(capsule_);
+ return std::get<LegacyDatagramWithoutContextCapsule>(capsule_);
}
const LegacyDatagramWithoutContextCapsule&
legacy_datagram_without_context_capsule() const {
- return absl::get<LegacyDatagramWithoutContextCapsule>(capsule_);
+ return std::get<LegacyDatagramWithoutContextCapsule>(capsule_);
}
CloseWebTransportSessionCapsule& close_web_transport_session_capsule() {
- return absl::get<CloseWebTransportSessionCapsule>(capsule_);
+ return std::get<CloseWebTransportSessionCapsule>(capsule_);
}
const CloseWebTransportSessionCapsule& close_web_transport_session_capsule()
const {
- return absl::get<CloseWebTransportSessionCapsule>(capsule_);
+ return std::get<CloseWebTransportSessionCapsule>(capsule_);
}
AddressRequestCapsule& address_request_capsule() {
- return absl::get<AddressRequestCapsule>(capsule_);
+ return std::get<AddressRequestCapsule>(capsule_);
}
const AddressRequestCapsule& address_request_capsule() const {
- return absl::get<AddressRequestCapsule>(capsule_);
+ return std::get<AddressRequestCapsule>(capsule_);
}
AddressAssignCapsule& address_assign_capsule() {
- return absl::get<AddressAssignCapsule>(capsule_);
+ return std::get<AddressAssignCapsule>(capsule_);
}
const AddressAssignCapsule& address_assign_capsule() const {
- return absl::get<AddressAssignCapsule>(capsule_);
+ return std::get<AddressAssignCapsule>(capsule_);
}
RouteAdvertisementCapsule& route_advertisement_capsule() {
- return absl::get<RouteAdvertisementCapsule>(capsule_);
+ return std::get<RouteAdvertisementCapsule>(capsule_);
}
const RouteAdvertisementCapsule& route_advertisement_capsule() const {
- return absl::get<RouteAdvertisementCapsule>(capsule_);
+ return std::get<RouteAdvertisementCapsule>(capsule_);
}
CompressionAssignCapsule& compression_assign_capsule() {
- return absl::get<CompressionAssignCapsule>(capsule_);
+ return std::get<CompressionAssignCapsule>(capsule_);
}
const CompressionAssignCapsule& compression_assign_capsule() const {
- return absl::get<CompressionAssignCapsule>(capsule_);
+ return std::get<CompressionAssignCapsule>(capsule_);
}
CompressionCloseCapsule& compression_close_capsule() {
- return absl::get<CompressionCloseCapsule>(capsule_);
+ return std::get<CompressionCloseCapsule>(capsule_);
}
const CompressionCloseCapsule& compression_close_capsule() const {
- return absl::get<CompressionCloseCapsule>(capsule_);
+ return std::get<CompressionCloseCapsule>(capsule_);
}
WebTransportStreamDataCapsule& web_transport_stream_data() {
- return absl::get<WebTransportStreamDataCapsule>(capsule_);
+ return std::get<WebTransportStreamDataCapsule>(capsule_);
}
const WebTransportStreamDataCapsule& web_transport_stream_data() const {
- return absl::get<WebTransportStreamDataCapsule>(capsule_);
+ return std::get<WebTransportStreamDataCapsule>(capsule_);
}
WebTransportResetStreamCapsule& web_transport_reset_stream() {
- return absl::get<WebTransportResetStreamCapsule>(capsule_);
+ return std::get<WebTransportResetStreamCapsule>(capsule_);
}
const WebTransportResetStreamCapsule& web_transport_reset_stream() const {
- return absl::get<WebTransportResetStreamCapsule>(capsule_);
+ return std::get<WebTransportResetStreamCapsule>(capsule_);
}
WebTransportStopSendingCapsule& web_transport_stop_sending() {
- return absl::get<WebTransportStopSendingCapsule>(capsule_);
+ return std::get<WebTransportStopSendingCapsule>(capsule_);
}
const WebTransportStopSendingCapsule& web_transport_stop_sending() const {
- return absl::get<WebTransportStopSendingCapsule>(capsule_);
+ return std::get<WebTransportStopSendingCapsule>(capsule_);
}
WebTransportMaxStreamDataCapsule& web_transport_max_stream_data() {
- return absl::get<WebTransportMaxStreamDataCapsule>(capsule_);
+ return std::get<WebTransportMaxStreamDataCapsule>(capsule_);
}
const WebTransportMaxStreamDataCapsule& web_transport_max_stream_data()
const {
- return absl::get<WebTransportMaxStreamDataCapsule>(capsule_);
+ return std::get<WebTransportMaxStreamDataCapsule>(capsule_);
}
WebTransportMaxStreamsCapsule& web_transport_max_streams() {
- return absl::get<WebTransportMaxStreamsCapsule>(capsule_);
+ return std::get<WebTransportMaxStreamsCapsule>(capsule_);
}
const WebTransportMaxStreamsCapsule& web_transport_max_streams() const {
- return absl::get<WebTransportMaxStreamsCapsule>(capsule_);
+ return std::get<WebTransportMaxStreamsCapsule>(capsule_);
}
UnknownCapsule& unknown_capsule() {
- return absl::get<UnknownCapsule>(capsule_);
+ return std::get<UnknownCapsule>(capsule_);
}
const UnknownCapsule& unknown_capsule() const {
- return absl::get<UnknownCapsule>(capsule_);
+ return std::get<UnknownCapsule>(capsule_);
}
private:
- absl::variant<DatagramCapsule, LegacyDatagramCapsule,
- LegacyDatagramWithoutContextCapsule,
- CloseWebTransportSessionCapsule,
- DrainWebTransportSessionCapsule, AddressRequestCapsule,
- AddressAssignCapsule, RouteAdvertisementCapsule,
- WebTransportStreamDataCapsule, WebTransportResetStreamCapsule,
- WebTransportStopSendingCapsule, WebTransportMaxStreamsCapsule,
- WebTransportMaxStreamDataCapsule, UnknownCapsule,
- CompressionAssignCapsule, CompressionCloseCapsule>
+ std::variant<DatagramCapsule, LegacyDatagramCapsule,
+ LegacyDatagramWithoutContextCapsule,
+ CloseWebTransportSessionCapsule, DrainWebTransportSessionCapsule,
+ AddressRequestCapsule, AddressAssignCapsule,
+ RouteAdvertisementCapsule, WebTransportStreamDataCapsule,
+ WebTransportResetStreamCapsule, WebTransportStopSendingCapsule,
+ WebTransportMaxStreamsCapsule, WebTransportMaxStreamDataCapsule,
+ UnknownCapsule, CompressionAssignCapsule,
+ CompressionCloseCapsule>
capsule_;
};
diff --git a/quiche/common/structured_headers.h b/quiche/common/structured_headers.h
index 32acedd..fd05782 100644
--- a/quiche/common/structured_headers.h
+++ b/quiche/common/structured_headers.h
@@ -12,10 +12,10 @@
#include <string>
#include <tuple>
#include <utility>
+#include <variant>
#include <vector>
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/common/platform/api/quiche_export.h"
#include "quiche/common/platform/api/quiche_logging.h"
@@ -92,30 +92,30 @@
bool is_boolean() const { return Type() == kBooleanType; }
int64_t GetInteger() const {
- const auto* value = absl::get_if<int64_t>(&value_);
+ const auto* value = std::get_if<int64_t>(&value_);
QUICHE_CHECK(value);
return *value;
}
double GetDecimal() const {
- const auto* value = absl::get_if<double>(&value_);
+ const auto* value = std::get_if<double>(&value_);
QUICHE_CHECK(value);
return *value;
}
bool GetBoolean() const {
- const auto* value = absl::get_if<bool>(&value_);
+ const auto* value = std::get_if<bool>(&value_);
QUICHE_CHECK(value);
return *value;
}
// TODO(iclelland): Split up accessors for String, Token and Byte Sequence.
const std::string& GetString() const {
struct Visitor {
- const std::string* operator()(const absl::monostate&) { return nullptr; }
+ const std::string* operator()(const std::monostate&) { return nullptr; }
const std::string* operator()(const int64_t&) { return nullptr; }
const std::string* operator()(const double&) { return nullptr; }
const std::string* operator()(const std::string& value) { return &value; }
const std::string* operator()(const bool&) { return nullptr; }
};
- const std::string* value = absl::visit(Visitor(), value_);
+ const std::string* value = std::visit(Visitor(), value_);
QUICHE_CHECK(value);
return *value;
}
@@ -123,13 +123,13 @@
// Transfers ownership of the underlying String, Token, or Byte Sequence.
std::string TakeString() && {
struct Visitor {
- std::string* operator()(absl::monostate&) { return nullptr; }
+ std::string* operator()(std::monostate&) { return nullptr; }
std::string* operator()(int64_t&) { return nullptr; }
std::string* operator()(double&) { return nullptr; }
std::string* operator()(std::string& value) { return &value; }
std::string* operator()(bool&) { return nullptr; }
};
- std::string* value = absl::visit(Visitor(), value_);
+ std::string* value = std::visit(Visitor(), value_);
QUICHE_CHECK(value);
return std::move(*value);
}
@@ -137,8 +137,8 @@
ItemType Type() const { return static_cast<ItemType>(value_.index()); }
private:
- absl::variant<absl::monostate, int64_t, double, std::string, std::string,
- std::string, bool>
+ std::variant<std::monostate, int64_t, double, std::string, std::string,
+ std::string, bool>
value_;
};
diff --git a/quiche/http2/adapter/http2_protocol.cc b/quiche/http2/adapter/http2_protocol.cc
index d26abdd..15060df 100644
--- a/quiche/http2/adapter/http2_protocol.cc
+++ b/quiche/http2/adapter/http2_protocol.cc
@@ -10,10 +10,10 @@
namespace adapter {
std::pair<absl::string_view, bool> GetStringView(const HeaderRep& rep) {
- if (absl::holds_alternative<absl::string_view>(rep)) {
- return std::make_pair(absl::get<absl::string_view>(rep), true);
+ if (std::holds_alternative<absl::string_view>(rep)) {
+ return std::make_pair(std::get<absl::string_view>(rep), true);
} else {
- absl::string_view view = absl::get<std::string>(rep);
+ absl::string_view view = std::get<std::string>(rep);
return std::make_pair(view, false);
}
}
diff --git a/quiche/http2/adapter/http2_protocol.h b/quiche/http2/adapter/http2_protocol.h
index 7597f43..9967a96 100644
--- a/quiche/http2/adapter/http2_protocol.h
+++ b/quiche/http2/adapter/http2_protocol.h
@@ -4,10 +4,10 @@
#include <cstdint>
#include <string>
#include <utility>
+#include <variant>
#include "absl/base/attributes.h"
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/common/platform/api/quiche_export.h"
namespace http2 {
@@ -23,7 +23,7 @@
using Http2PingId = uint64_t;
// Represents a single header name or value.
-using HeaderRep = absl::variant<absl::string_view, std::string>;
+using HeaderRep = std::variant<absl::string_view, std::string>;
// Boolean return value is true if |rep| holds a string_view, which is assumed
// to have an indefinite lifetime.
diff --git a/quiche/http2/adapter/oghttp2_session.cc b/quiche/http2/adapter/oghttp2_session.cc
index 3d22313..2a5ec62 100644
--- a/quiche/http2/adapter/oghttp2_session.cc
+++ b/quiche/http2/adapter/oghttp2_session.cc
@@ -487,10 +487,10 @@
int64_t OgHttp2Session::ProcessBytes(absl::string_view bytes) {
QUICHE_VLOG(3) << TracePerspectiveAsString(options_.perspective)
<< " processing [" << absl::CEscape(bytes) << "]";
- return absl::visit(ProcessBytesResultVisitor(), ProcessBytesImpl(bytes));
+ return std::visit(ProcessBytesResultVisitor(), ProcessBytesImpl(bytes));
}
-absl::variant<int64_t, OgHttp2Session::ProcessBytesError>
+std::variant<int64_t, OgHttp2Session::ProcessBytesError>
OgHttp2Session::ProcessBytesImpl(absl::string_view bytes) {
if (processing_bytes_) {
QUICHE_VLOG(2) << "Returning early; already processing bytes.";
diff --git a/quiche/http2/adapter/oghttp2_session.h b/quiche/http2/adapter/oghttp2_session.h
index 62b7f3e..363f0ce 100644
--- a/quiche/http2/adapter/oghttp2_session.h
+++ b/quiche/http2/adapter/oghttp2_session.h
@@ -6,10 +6,10 @@
#include <list>
#include <memory>
#include <optional>
+#include <variant>
#include <vector>
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/http2/adapter/chunked_buffer.h"
#include "quiche/http2/adapter/data_source.h"
#include "quiche/http2/adapter/event_forwarder.h"
@@ -364,7 +364,7 @@
// A user/visitor callback failed with a fatal error.
kVisitorCallbackFailed,
};
- using ProcessBytesResult = absl::variant<int64_t, ProcessBytesError>;
+ using ProcessBytesResult = std::variant<int64_t, ProcessBytesError>;
// Attempts to process `bytes` and returns the number of bytes proccessed on
// success or the processing error on failure.
diff --git a/quiche/http2/core/spdy_protocol.h b/quiche/http2/core/spdy_protocol.h
index cc2fc73..a5ec174 100644
--- a/quiche/http2/core/spdy_protocol.h
+++ b/quiche/http2/core/spdy_protocol.h
@@ -18,10 +18,10 @@
#include <optional>
#include <string>
#include <utility>
+#include <variant>
#include <vector>
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
#include "quiche/http2/core/spdy_bitmasks.h"
#include "quiche/common/http/http_header_block.h"
@@ -378,7 +378,7 @@
// Returns true if this instance is a SPDY 3.x priority, or false if this
// instance is an HTTP/2 stream dependency.
bool is_spdy3_priority() const {
- return absl::holds_alternative<SpdyPriority>(precedence_);
+ return std::holds_alternative<SpdyPriority>(precedence_);
}
// Returns SPDY 3.x priority value. If |is_spdy3_priority()| is true, this is
@@ -389,9 +389,9 @@
// precedence).
SpdyPriority spdy3_priority() const {
return is_spdy3_priority()
- ? absl::get<SpdyPriority>(precedence_)
+ ? std::get<SpdyPriority>(precedence_)
: Http2WeightToSpdy3Priority(
- absl::get<Http2StreamDependency>(precedence_).weight);
+ std::get<Http2StreamDependency>(precedence_).weight);
}
// Returns HTTP/2 parent stream ID. If |is_spdy3_priority()| is false, this is
@@ -399,7 +399,7 @@
StreamIdType parent_id() const {
return is_spdy3_priority()
? kHttp2RootStreamId
- : absl::get<Http2StreamDependency>(precedence_).parent_id;
+ : std::get<Http2StreamDependency>(precedence_).parent_id;
}
// Returns HTTP/2 stream weight. If |is_spdy3_priority()| is false, this is
@@ -410,16 +410,15 @@
// minimum weight 1.
int weight() const {
return is_spdy3_priority()
- ? Spdy3PriorityToHttp2Weight(
- absl::get<SpdyPriority>(precedence_))
- : absl::get<Http2StreamDependency>(precedence_).weight;
+ ? Spdy3PriorityToHttp2Weight(std::get<SpdyPriority>(precedence_))
+ : std::get<Http2StreamDependency>(precedence_).weight;
}
// Returns HTTP/2 parent stream exclusivity. If |is_spdy3_priority()| is
// false, this is the value provided at construction, otherwise it is false.
bool is_exclusive() const {
- return absl::holds_alternative<Http2StreamDependency>(precedence_) &&
- absl::get<Http2StreamDependency>(precedence_).is_exclusive;
+ return std::holds_alternative<Http2StreamDependency>(precedence_) &&
+ std::get<Http2StreamDependency>(precedence_).is_exclusive;
}
// Facilitates test assertions.
@@ -443,7 +442,7 @@
}
};
- absl::variant<SpdyPriority, Http2StreamDependency> precedence_;
+ std::variant<SpdyPriority, Http2StreamDependency> precedence_;
};
typedef StreamPrecedence<SpdyStreamId> SpdyStreamPrecedence;
diff --git a/quiche/quic/core/crypto/proof_source.h b/quiche/quic/core/crypto/proof_source.h
index 1e263e5..3976bfb 100644
--- a/quiche/quic/core/crypto/proof_source.h
+++ b/quiche/quic/core/crypto/proof_source.h
@@ -11,11 +11,11 @@
#include <memory>
#include <optional>
#include <string>
+#include <variant>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "openssl/base.h"
#include "openssl/pool.h"
#include "openssl/ssl.h"
@@ -280,7 +280,7 @@
QuicDelayedSSLConfig delayed_ssl_config;
};
- using SSLConfig = absl::variant<LocalSSLConfig, HintsSSLConfig>;
+ using SSLConfig = std::variant<LocalSSLConfig, HintsSSLConfig>;
// Called when a ProofSourceHandle::SelectCertificate operation completes.
// |ok| indicates whether the operation was successful.
diff --git a/quiche/quic/core/io/event_loop_connecting_client_socket.cc b/quiche/quic/core/io/event_loop_connecting_client_socket.cc
index 53dfb1f..f4bb6ff 100644
--- a/quiche/quic/core/io/event_loop_connecting_client_socket.cc
+++ b/quiche/quic/core/io/event_loop_connecting_client_socket.cc
@@ -7,12 +7,12 @@
#include <limits>
#include <string>
#include <utility>
+#include <variant>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/io/socket.h"
#include "quiche/quic/platform/api/quic_socket_address.h"
@@ -43,7 +43,7 @@
// safely recover if state indicates caller may be expecting async callbacks.
QUICHE_DCHECK(connect_status_ != ConnectStatus::kConnecting);
QUICHE_DCHECK(!receive_max_size_.has_value());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
if (descriptor_ != kInvalidSocketFd) {
QUICHE_BUG(quic_event_loop_connecting_socket_invalid_destruction)
<< "Must call Disconnect() on connected socket before destruction.";
@@ -58,7 +58,7 @@
QUICHE_DCHECK_EQ(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kNotConnected);
QUICHE_DCHECK(!receive_max_size_.has_value());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
absl::Status status = Open();
if (!status.ok()) {
@@ -108,7 +108,7 @@
QUICHE_DCHECK_EQ(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kNotConnected);
QUICHE_DCHECK(!receive_max_size_.has_value());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
absl::Status status = Open();
if (!status.ok()) {
@@ -132,8 +132,8 @@
bool require_receive_callback = receive_max_size_.has_value();
receive_max_size_.reset();
bool require_send_callback =
- !absl::holds_alternative<absl::monostate>(send_data_);
- send_data_ = absl::monostate();
+ !std::holds_alternative<std::monostate>(send_data_);
+ send_data_ = std::monostate();
send_remaining_ = "";
if (require_connect_callback) {
@@ -213,7 +213,7 @@
absl::Status EventLoopConnectingClientSocket::SendBlocking(std::string data) {
QUICHE_DCHECK(!data.empty());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
send_data_ = std::move(data);
return SendBlockingInternal();
@@ -222,7 +222,7 @@
absl::Status EventLoopConnectingClientSocket::SendBlocking(
quiche::QuicheMemSlice data) {
QUICHE_DCHECK(!data.empty());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
send_data_ = std::move(data);
return SendBlockingInternal();
@@ -230,21 +230,20 @@
void EventLoopConnectingClientSocket::SendAsync(std::string data) {
QUICHE_DCHECK(!data.empty());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
send_data_ = std::move(data);
- send_remaining_ = absl::get<std::string>(send_data_);
+ send_remaining_ = std::get<std::string>(send_data_);
FinishOrRearmAsyncSend(SendInternal());
}
void EventLoopConnectingClientSocket::SendAsync(quiche::QuicheMemSlice data) {
QUICHE_DCHECK(!data.empty());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
send_data_ = std::move(data);
- send_remaining_ =
- absl::get<quiche::QuicheMemSlice>(send_data_).AsStringView();
+ send_remaining_ = std::get<quiche::QuicheMemSlice>(send_data_).AsStringView();
FinishOrRearmAsyncSend(SendInternal());
}
@@ -274,7 +273,7 @@
QUICHE_DCHECK_EQ(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kNotConnected);
QUICHE_DCHECK(!receive_max_size_.has_value());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
QUICHE_DCHECK(send_remaining_.empty());
absl::StatusOr<SocketFd> descriptor =
@@ -356,7 +355,7 @@
QUICHE_DCHECK_NE(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kNotConnected);
QUICHE_DCHECK(!receive_max_size_.has_value());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
absl::Status connect_result = socket_api::Connect(descriptor_, peer_address_);
@@ -379,7 +378,7 @@
QUICHE_DCHECK_NE(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kConnecting);
QUICHE_DCHECK(!receive_max_size_.has_value());
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
absl::Status error = socket_api::GetSocketError(descriptor_);
@@ -516,7 +515,7 @@
absl::Status EventLoopConnectingClientSocket::SendBlockingInternal() {
QUICHE_DCHECK_NE(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kConnected);
- QUICHE_DCHECK(!absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(!std::holds_alternative<std::monostate>(send_data_));
QUICHE_DCHECK(send_remaining_.empty());
absl::Status status =
@@ -525,15 +524,15 @@
QUICHE_LOG_FIRST_N(WARNING, 100)
<< "Failed to set socket to address: " << peer_address_.ToString()
<< " as blocking for send with error: " << status;
- send_data_ = absl::monostate();
+ send_data_ = std::monostate();
return status;
}
- if (absl::holds_alternative<std::string>(send_data_)) {
- send_remaining_ = absl::get<std::string>(send_data_);
+ if (std::holds_alternative<std::string>(send_data_)) {
+ send_remaining_ = std::get<std::string>(send_data_);
} else {
send_remaining_ =
- absl::get<quiche::QuicheMemSlice>(send_data_).AsStringView();
+ std::get<quiche::QuicheMemSlice>(send_data_).AsStringView();
}
status = SendInternal();
@@ -541,10 +540,10 @@
QUICHE_LOG_FIRST_N(ERROR, 100)
<< "Non-blocking send for should-be blocking socket to address:"
<< peer_address_.ToString();
- send_data_ = absl::monostate();
+ send_data_ = std::monostate();
send_remaining_ = "";
} else {
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
QUICHE_DCHECK(send_remaining_.empty());
}
@@ -564,7 +563,7 @@
absl::Status EventLoopConnectingClientSocket::SendInternal() {
QUICHE_DCHECK_NE(descriptor_, kInvalidSocketFd);
QUICHE_DCHECK(connect_status_ == ConnectStatus::kConnected);
- QUICHE_DCHECK(!absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(!std::holds_alternative<std::monostate>(send_data_));
QUICHE_DCHECK(!send_remaining_.empty());
// Repeat send until all data sent, unavailable, or error.
@@ -586,14 +585,14 @@
QUICHE_DVLOG(1) << "Failed to send to socket to address: "
<< peer_address_.ToString()
<< " with error: " << remainder.status();
- send_data_ = absl::monostate();
+ send_data_ = std::monostate();
send_remaining_ = "";
}
return remainder.status();
}
}
- send_data_ = absl::monostate();
+ send_data_ = std::monostate();
return absl::OkStatus();
}
@@ -608,10 +607,10 @@
descriptor_, kSocketEventWritable | kSocketEventError);
QUICHE_DCHECK(result);
}
- QUICHE_DCHECK(!absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(!std::holds_alternative<std::monostate>(send_data_));
QUICHE_DCHECK(!send_remaining_.empty());
} else {
- QUICHE_DCHECK(absl::holds_alternative<absl::monostate>(send_data_));
+ QUICHE_DCHECK(std::holds_alternative<std::monostate>(send_data_));
QUICHE_DCHECK(send_remaining_.empty());
async_visitor_->SendComplete(status);
}
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 a4fb9e9..73d547f 100644
--- a/quiche/quic/core/io/event_loop_connecting_client_socket.h
+++ b/quiche/quic/core/io/event_loop_connecting_client_socket.h
@@ -7,10 +7,10 @@
#include <optional>
#include <string>
+#include <variant>
#include "absl/status/status.h"
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/connecting_client_socket.h"
#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/io/socket.h"
@@ -93,8 +93,7 @@
std::optional<QuicByteCount> receive_max_size_;
// Only contains data while send in progress or pending, otherwise monostate.
- absl::variant<absl::monostate, std::string, quiche::QuicheMemSlice>
- send_data_;
+ std::variant<std::monostate, std::string, quiche::QuicheMemSlice> send_data_;
// Points to the unsent portion of `send_data_` while send in progress or
// pending, otherwise empty.
absl::string_view send_remaining_;
diff --git a/quiche/quic/core/quic_connection_alarms.h b/quiche/quic/core/quic_connection_alarms.h
index b3ace88..a8e45d5 100644
--- a/quiche/quic/core/quic_connection_alarms.h
+++ b/quiche/quic/core/quic_connection_alarms.h
@@ -10,9 +10,9 @@
#include <cstdint>
#include <optional>
#include <string>
+#include <variant>
#include "absl/base/nullability.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/quic_alarm.h"
#include "quiche/quic/core/quic_alarm_factory.h"
#include "quiche/quic/core/quic_arena_scoped_ptr.h"
@@ -381,21 +381,21 @@
: alarm_(alarm) {}
bool IsSet() const {
- return absl::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
+ return std::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
}
QuicTime deadline() const {
- return absl::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
+ return std::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
}
bool IsPermanentlyCancelled() const {
- return absl::visit(
+ return std::visit(
[](auto& alarm) { return alarm.IsPermanentlyCancelled(); }, alarm_);
}
private:
friend class ::quic::test::QuicConnectionAlarmsPeer;
- absl::variant<QuicConnectionAlarmHolder::ConstAlarmProxy,
- QuicAlarmMultiplexer::ConstAlarmProxy>
+ std::variant<QuicConnectionAlarmHolder::ConstAlarmProxy,
+ QuicAlarmMultiplexer::ConstAlarmProxy>
alarm_;
};
@@ -409,35 +409,35 @@
: alarm_(alarm) {}
bool IsSet() const {
- return absl::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
+ return std::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
}
QuicTime deadline() const {
- return absl::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
+ return std::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
}
bool IsPermanentlyCancelled() const {
- return absl::visit(
+ return std::visit(
[](auto& alarm) { return alarm.IsPermanentlyCancelled(); }, alarm_);
}
void Set(QuicTime new_deadline) {
- absl::visit([&](auto& alarm) { alarm.Set(new_deadline); }, alarm_);
+ std::visit([&](auto& alarm) { alarm.Set(new_deadline); }, alarm_);
}
void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
- absl::visit([&](auto& alarm) { alarm.Update(new_deadline, granularity); },
- alarm_);
+ std::visit([&](auto& alarm) { alarm.Update(new_deadline, granularity); },
+ alarm_);
}
void Cancel() {
- absl::visit([&](auto& alarm) { alarm.Cancel(); }, alarm_);
+ std::visit([&](auto& alarm) { alarm.Cancel(); }, alarm_);
}
void PermanentCancel() {
- absl::visit([&](auto& alarm) { alarm.PermanentCancel(); }, alarm_);
+ std::visit([&](auto& alarm) { alarm.PermanentCancel(); }, alarm_);
}
private:
friend class ::quic::test::QuicConnectionAlarmsPeer;
- absl::variant<QuicConnectionAlarmHolder::AlarmProxy,
- QuicAlarmMultiplexer::AlarmProxy>
+ std::variant<QuicConnectionAlarmHolder::AlarmProxy,
+ QuicAlarmMultiplexer::AlarmProxy>
alarm_;
};
diff --git a/quiche/quic/core/quic_stream_priority.h b/quiche/quic/core/quic_stream_priority.h
index b1b35df..40817b6 100644
--- a/quiche/quic/core/quic_stream_priority.h
+++ b/quiche/quic/core/quic_stream_priority.h
@@ -9,9 +9,9 @@
#include <optional>
#include <string>
#include <tuple>
+#include <variant>
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/common/platform/api/quiche_bug_tracker.h"
#include "quiche/common/platform/api/quiche_export.h"
@@ -74,19 +74,19 @@
explicit QuicStreamPriority(WebTransportStreamPriority priority)
: value_(priority) {}
- QuicPriorityType type() const { return absl::visit(TypeExtractor(), value_); }
+ QuicPriorityType type() const { return std::visit(TypeExtractor(), value_); }
HttpStreamPriority http() const {
- if (absl::holds_alternative<HttpStreamPriority>(value_)) {
- return absl::get<HttpStreamPriority>(value_);
+ if (std::holds_alternative<HttpStreamPriority>(value_)) {
+ return std::get<HttpStreamPriority>(value_);
}
QUICHE_BUG(invalid_priority_type_http)
<< "Tried to access HTTP priority for a priority type" << type();
return HttpStreamPriority();
}
WebTransportStreamPriority web_transport() const {
- if (absl::holds_alternative<WebTransportStreamPriority>(value_)) {
- return absl::get<WebTransportStreamPriority>(value_);
+ if (std::holds_alternative<WebTransportStreamPriority>(value_)) {
+ return std::get<WebTransportStreamPriority>(value_);
}
QUICHE_BUG(invalid_priority_type_wt)
<< "Tried to access WebTransport priority for a priority type"
@@ -108,7 +108,7 @@
}
};
- absl::variant<HttpStreamPriority, WebTransportStreamPriority> value_;
+ std::variant<HttpStreamPriority, WebTransportStreamPriority> value_;
};
// Serializes the Priority Field Value for a PRIORITY_UPDATE frame.
diff --git a/quiche/quic/core/tls_server_handshaker.cc b/quiche/quic/core/tls_server_handshaker.cc
index 884e57d..12b1637 100644
--- a/quiche/quic/core/tls_server_handshaker.cc
+++ b/quiche/quic/core/tls_server_handshaker.cc
@@ -11,13 +11,13 @@
#include <optional>
#include <string>
#include <utility>
+#include <variant>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
-#include "absl/types/variant.h"
#include "openssl/base.h"
#include "openssl/bytestring.h"
#include "openssl/ssl.h"
@@ -1074,7 +1074,7 @@
// Extract the delayed SSL config from either LocalSSLConfig or
// HintsSSLConfig.
- const QuicDelayedSSLConfig& delayed_ssl_config = absl::visit(
+ const QuicDelayedSSLConfig& delayed_ssl_config = std::visit(
[](const auto& config) { return config.delayed_ssl_config; }, ssl_config);
if (delayed_ssl_config.quic_transport_parameters.has_value()) {
@@ -1100,7 +1100,7 @@
}
if (ok) {
- if (auto* local_config = absl::get_if<LocalSSLConfig>(&ssl_config);
+ if (auto* local_config = std::get_if<LocalSSLConfig>(&ssl_config);
local_config != nullptr) {
if (local_config->chain && !local_config->chain->certs.empty()) {
tls_connection_.SetCertChain(
@@ -1114,7 +1114,7 @@
<< ", client_address:"
<< session()->connection()->peer_address();
}
- } else if (auto* hints_config = absl::get_if<HintsSSLConfig>(&ssl_config);
+ } else if (auto* hints_config = std::get_if<HintsSSLConfig>(&ssl_config);
hints_config != nullptr) {
select_alpn_ = std::move(hints_config->select_alpn);
if (hints_config->configure_ssl) {
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index 862d7e3..e086460 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -11,13 +11,13 @@
#include <string>
#include <type_traits>
#include <utility>
+#include <variant>
#include <vector>
#include "absl/container/inlined_vector.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/quic_data_writer.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/moqt/moqt_messages.h"
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index d961905..070e415 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -13,6 +13,7 @@
#include <optional>
#include <string>
#include <utility>
+#include <variant>
#include <vector>
#include "absl/container/inlined_vector.h"
@@ -20,7 +21,6 @@
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/quic_versions.h"
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index 926980e..cbca5fc 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -11,11 +11,11 @@
#include <memory>
#include <optional>
#include <string>
+#include <variant>
#include <vector>
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/quic_data_writer.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/moqt/moqt_messages.h"
@@ -66,7 +66,7 @@
};
using GeneralizedMessageType =
- absl::variant<MoqtMessageType, MoqtDataStreamType>;
+ std::variant<MoqtMessageType, MoqtDataStreamType>;
} // namespace
struct MoqtParserTestParams {
@@ -107,8 +107,8 @@
}
std::string ParamNameFormatter(
const testing::TestParamInfo<MoqtParserTestParams>& info) {
- return absl::visit([](auto x) { return TypeFormatter(x); },
- info.param.message_type) +
+ return std::visit([](auto x) { return TypeFormatter(x); },
+ info.param.message_type) +
"_" + (info.param.uses_web_transport ? "WebTransport" : "QUIC");
}
@@ -247,14 +247,14 @@
data_parser_(&data_stream_, &visitor_) {}
bool IsDataStream() {
- return absl::holds_alternative<MoqtDataStreamType>(message_type_);
+ return std::holds_alternative<MoqtDataStreamType>(message_type_);
}
std::unique_ptr<TestMessageBase> MakeMessage() {
if (IsDataStream()) {
- return CreateTestDataStream(absl::get<MoqtDataStreamType>(message_type_));
+ return CreateTestDataStream(std::get<MoqtDataStreamType>(message_type_));
} else {
- return CreateTestMessage(absl::get<MoqtMessageType>(message_type_),
+ return CreateTestMessage(std::get<MoqtMessageType>(message_type_),
webtrans_);
}
}
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
index e991830..709907e 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -5,13 +5,13 @@
#include "quiche/quic/moqt/test_tools/moqt_framer_utils.h"
#include <string>
+#include <variant>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
-#include "absl/types/variant.h"
#include "quiche/quic/moqt/moqt_framer.h"
#include "quiche/quic/moqt/moqt_messages.h"
#include "quiche/quic/moqt/moqt_parser.h"
@@ -293,11 +293,11 @@
std::string SerializeGenericMessage(const MoqtGenericFrame& frame,
bool use_webtrans) {
MoqtFramer framer(quiche::SimpleBufferAllocator::Get(), use_webtrans);
- return std::string(absl::visit(FramingVisitor{framer}, frame).AsStringView());
+ return std::string(std::visit(FramingVisitor{framer}, frame).AsStringView());
}
MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame) {
- return absl::visit(TypeVisitor(), frame);
+ return std::visit(TypeVisitor(), frame);
}
std::vector<MoqtGenericFrame> ParseGenericMessage(absl::string_view body) {
@@ -313,12 +313,11 @@
const quiche::StreamWriteOptions& options) const {
std::string merged_message = absl::StrJoin(data, "");
std::vector<MoqtGenericFrame> frames = ParseGenericMessage(merged_message);
- if (frames.size() != 1 ||
- !absl::holds_alternative<MoqtSubscribe>(frames[0])) {
+ if (frames.size() != 1 || !std::holds_alternative<MoqtSubscribe>(frames[0])) {
ADD_FAILURE() << "Expected one SUBSCRIBE frame in a write";
return absl::InternalError("Expected one SUBSCRIBE frame in a write");
}
- *subscribe_ = absl::get<MoqtSubscribe>(frames[0]);
+ *subscribe_ = std::get<MoqtSubscribe>(frames[0]);
return absl::OkStatus();
}
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index 944e50b..ac5760b 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -8,13 +8,13 @@
#include <cstdint>
#include <optional>
#include <string>
+#include <variant>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
-#include "absl/types/variant.h"
#include "quiche/quic/moqt/moqt_messages.h"
#include "quiche/common/platform/api/quiche_test.h"
#include "quiche/common/quiche_data_reader.h"
@@ -25,15 +25,15 @@
// TODO: remove MoqtObject from TestMessageBase::MessageStructuredData and merge
// those two types.
using MoqtGenericFrame =
- absl::variant<MoqtClientSetup, MoqtServerSetup, MoqtSubscribe,
- MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
- MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
- MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
- MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
- MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
- MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
- MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
- MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>;
+ std::variant<MoqtClientSetup, MoqtServerSetup, MoqtSubscribe,
+ MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
+ MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
+ MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
+ MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
+ MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
+ MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
+ MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
+ MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>;
MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame);
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index 1eca5c6..dd0a326 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -12,10 +12,10 @@
#include <optional>
#include <string>
#include <utility>
+#include <variant>
#include <vector>
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/quic_data_reader.h"
#include "quiche/quic/core/quic_data_writer.h"
#include "quiche/quic/core/quic_time.h"
@@ -37,15 +37,16 @@
public:
virtual ~TestMessageBase() = default;
- using MessageStructuredData = absl::variant<
- MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
- MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, MoqtSubscribeDone,
- MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError,
- MoqtAnnounceCancel, MoqtTrackStatusRequest, MoqtUnannounce,
- MoqtTrackStatus, MoqtGoAway, MoqtSubscribeAnnounces,
- MoqtSubscribeAnnouncesOk, MoqtSubscribeAnnouncesError,
- MoqtUnsubscribeAnnounces, MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel,
- MoqtFetchOk, MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>;
+ using MessageStructuredData =
+ std::variant<MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
+ MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
+ MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
+ MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
+ MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
+ MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
+ MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
+ MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
+ MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>;
// The total actual size of the message.
size_t total_message_size() const { return wire_image_size_; }
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index 73bce8d..e74ae4c 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -6,10 +6,10 @@
#include <memory>
#include <string>
+#include <variant>
#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
#include "quiche/quic/core/quic_connection.h"
#include "quiche/quic/core/quic_connection_alarms.h"
@@ -36,7 +36,7 @@
alarm.multiplexer_->Fire(alarm.slot_);
}
} visitor;
- absl::visit(visitor, alarm.alarm_);
+ std::visit(visitor, alarm.alarm_);
}
// static
