grpc 1.70.1 → 1.71.0

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -50,10 +50,10 @@ class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
                                                  HttpServerFilter* filter);
     void OnServerInitialMetadata(ServerMetadata& md);
     void OnServerTrailingMetadata(ServerMetadata& md);
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -45,17 +45,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor ClientMessageSizeFilter::Call::OnClientInitialMetadata;
-const NoInterceptor ClientMessageSizeFilter::Call::OnServerInitialMetadata;
-const NoInterceptor ClientMessageSizeFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ClientMessageSizeFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ClientMessageSizeFilter::Call::OnFinalize;
-const NoInterceptor ServerMessageSizeFilter::Call::OnClientInitialMetadata;
-const NoInterceptor ServerMessageSizeFilter::Call::OnServerInitialMetadata;
-const NoInterceptor ServerMessageSizeFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ServerMessageSizeFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerMessageSizeFilter::Call::OnFinalize;
-
 //
 // MessageSizeParsedConfig
 //
@@ -76,21 +65,19 @@ MessageSizeParsedConfig MessageSizeParsedConfig::GetFromChannelArgs(
   return limits;
 }
 
-absl::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(
-    const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return absl::nullopt;
+std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return std::nullopt;
   int size = args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
                  .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
-  if (size < 0) return absl::nullopt;
+  if (size < 0) return std::nullopt;
   return static_cast<uint32_t>(size);
 }
 
-absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(
-    const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return absl::nullopt;
+std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return std::nullopt;
   int size = args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
                  .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
-  if (size < 0) return absl::nullopt;
+  if (size < 0) return std::nullopt;
   return static_cast<uint32_t>(size);
 }
 
@@ -154,7 +141,7 @@ ServerMessageSizeFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
 
 namespace {
 ServerMetadataHandle CheckPayload(const Message& msg,
-                                  absl::optional<uint32_t> max_length,
+                                  std::optional<uint32_t> max_length,
                                   bool is_client, bool is_send) {
   if (!max_length.has_value()) return nullptr;
   GRPC_TRACE_LOG(call, INFO)
@@ -162,7 +149,7 @@ ServerMetadataHandle CheckPayload(const Message& msg,
       << (is_send ? "send" : "recv") << " len:" << msg.payload()->Length()
       << " max:" << *max_length;
   if (msg.payload()->Length() <= *max_length) return nullptr;
-  return ServerMetadataFromStatus(
+  return CancelledServerMetadataFromStatus(
       GRPC_STATUS_RESOURCE_EXHAUSTED,
       absl::StrFormat("%s: %s message larger than max (%u vs. %d)",
                       is_client ? "CLIENT" : "SERVER",
@@ -171,8 +158,9 @@ ServerMetadataHandle CheckPayload(const Message& msg,
 }
 }  // namespace
 
-ClientMessageSizeFilter::Call::Call(ClientMessageSizeFilter* filter)
-    : limits_(filter->parsed_config_) {
+void ClientMessageSizeFilter::Call::OnClientInitialMetadata(
+    ClientMetadata&, ClientMessageSizeFilter* filter) {
+  limits_ = filter->parsed_config_;
   // Get max sizes from channel data, then merge in per-method config values.
   // Note: Per-method config is only available on the client, so we
   // apply the max request size to the send limit and the max response
@@ -181,8 +169,8 @@ ClientMessageSizeFilter::Call::Call(ClientMessageSizeFilter* filter)
       MessageSizeParsedConfig::GetFromCallContext(
           GetContext<Arena>(), filter->service_config_parser_index_);
   if (config_from_call_context != nullptr) {
-    absl::optional<uint32_t> max_send_size = limits_.max_send_size();
-    absl::optional<uint32_t> max_recv_size = limits_.max_recv_size();
+    std::optional<uint32_t> max_send_size = limits_.max_send_size();
+    std::optional<uint32_t> max_recv_size = limits_.max_recv_size();
     if (config_from_call_context->max_send_size().has_value() &&
         (!max_send_size.has_value() ||
          *config_from_call_context->max_send_size() < *max_send_size)) {

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -22,10 +22,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -42,13 +42,13 @@ namespace grpc_core {
 
 class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
  public:
-  absl::optional<uint32_t> max_send_size() const { return max_send_size_; }
-  absl::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
+  std::optional<uint32_t> max_send_size() const { return max_send_size_; }
+  std::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
 
   MessageSizeParsedConfig() = default;
 
-  MessageSizeParsedConfig(absl::optional<uint32_t> max_send_size,
-                          absl::optional<uint32_t> max_recv_size)
+  MessageSizeParsedConfig(std::optional<uint32_t> max_send_size,
+                          std::optional<uint32_t> max_recv_size)
       : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
 
   static const MessageSizeParsedConfig* GetFromCallContext(
@@ -59,8 +59,8 @@ class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
 
  private:
-  absl::optional<uint32_t> max_send_size_;
-  absl::optional<uint32_t> max_recv_size_;
+  std::optional<uint32_t> max_send_size_;
+  std::optional<uint32_t> max_recv_size_;
 };
 
 class MessageSizeParser : public ServiceConfigParser::Parser {
@@ -79,8 +79,8 @@ class MessageSizeParser : public ServiceConfigParser::Parser {
   static absl::string_view parser_name() { return "message_size"; }
 };
 
-absl::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
-absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
+std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
+std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
 
 class ServerMessageSizeFilter final
     : public ImplementChannelFilter<ServerMessageSizeFilter> {
@@ -97,13 +97,13 @@ class ServerMessageSizeFilter final
 
   class Call {
    public:
-    static const NoInterceptor OnClientInitialMetadata;
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientInitialMetadata;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnFinalize;
     ServerMetadataHandle OnClientToServerMessage(
         const Message& message, ServerMessageSizeFilter* filter);
-    static const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnClientToServerHalfClose;
     ServerMetadataHandle OnServerToClientMessage(
         const Message& message, ServerMessageSizeFilter* filter);
   };
@@ -127,14 +127,13 @@ class ClientMessageSizeFilter final
 
   class Call {
    public:
-    explicit Call(ClientMessageSizeFilter* filter);
-
-    static const NoInterceptor OnClientInitialMetadata;
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    void OnClientInitialMetadata(ClientMetadata&,
+                                 ClientMessageSizeFilter* filter);
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnFinalize;
     ServerMetadataHandle OnClientToServerMessage(const Message& message);
-    static const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnClientToServerHalfClose;
     ServerMetadataHandle OnServerToClientMessage(const Message& message);
 
    private:

data/src/core/ext/filters/rbac/rbac_filter.cc

@@ -41,13 +41,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor RbacFilter::Call::OnServerInitialMetadata;
-const NoInterceptor RbacFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor RbacFilter::Call::OnClientToServerMessage;
-const NoInterceptor RbacFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor RbacFilter::Call::OnServerToClientMessage;
-const NoInterceptor RbacFilter::Call::OnFinalize;
-
 absl::Status RbacFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
                                                        RbacFilter* filter) {
   GRPC_LATENT_SEE_INNER_SCOPE("RbacFilter::Call::OnClientInitialMetadata");

data/src/core/ext/filters/rbac/rbac_filter.h

@@ -52,12 +52,12 @@ class RbacFilter : public ImplementChannelFilter<RbacFilter> {
    public:
     absl::Status OnClientInitialMetadata(ClientMetadata& md,
                                          RbacFilter* filter);
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/ext/filters/rbac/rbac_service_config_parser.cc

@@ -22,12 +22,12 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/security/authorization/audit_logging.h"
 #include "src/core/util/json/json_args.h"
@@ -152,7 +152,7 @@ struct RbacConfig {
           };
 
           struct Authenticated {
-            absl::optional<StringMatch> principal_name;
+            std::optional<StringMatch> principal_name;
 
             static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
           };
@@ -218,7 +218,7 @@ struct RbacConfig {
       void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors);
     };
 
-    absl::optional<Rules> rules;
+    std::optional<Rules> rules;
 
     Rbac TakeAsRbac();
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,7 +35,6 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -54,11 +54,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor StatefulSessionFilter::Call::OnClientToServerMessage;
-const NoInterceptor StatefulSessionFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor StatefulSessionFilter::Call::OnServerToClientMessage;
-const NoInterceptor StatefulSessionFilter::Call::OnFinalize;
-
 UniqueTypeName XdsOverrideHostAttribute::TypeName() {
   static UniqueTypeName::Factory kFactory("xds_override_host");
   return kFactory.Create();

data/src/core/ext/filters/stateful_session/stateful_session_filter.h

@@ -85,10 +85,10 @@ class StatefulSessionFilter
                                  StatefulSessionFilter* filter);
     void OnServerInitialMetadata(ServerMetadata& md);
     void OnServerTrailingMetadata(ServerMetadata& md);
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
 
    private:
     const StatefulSessionMethodParsedConfig::CookieConfig* cookie_config_;

data/src/core/ext/filters/stateful_session/stateful_session_service_config_parser.cc

@@ -18,9 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 
 namespace grpc_core {

data/src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h

@@ -21,11 +21,11 @@
 #include <stddef.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/service_config/service_config_parser.h"
@@ -45,7 +45,7 @@ class StatefulSessionMethodParsedConfig
     : public ServiceConfigParser::ParsedConfig {
  public:
   struct CookieConfig {
-    absl::optional<std::string> name;  // Will be unset if disabled.
+    std::optional<std::string> name;  // Will be unset if disabled.
     std::string path;
     Duration ttl;
 

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -157,7 +157,6 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
     timer_handle_ = event_engine_->RunAfter(
         args_.deadline - Timestamp::Now(),
         [self = RefAsSubclass<Chttp2Connector>()]() mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->OnTimeout();
           // Ensure the Chttp2Connector is deleted under an ExecCtx.
@@ -256,7 +255,7 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
           "security connector already present in channel args.");
     }
     // Find the authority to use in the security connector.
-    absl::optional<std::string> authority =
+    std::optional<std::string> authority =
         args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY);
     if (!authority.has_value()) {
       return absl::InternalError("authority not present in channel args");

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -22,8 +22,9 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/base/thread_annotations.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -61,13 +62,13 @@ class Chttp2Connector : public SubchannelConnector {
   grpc_closure* notify_ = nullptr;
   bool shutdown_ = false;
   grpc_closure on_receive_settings_;
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       timer_handle_ ABSL_GUARDED_BY(mu_);
   // A raw pointer will suffice since args_ holds a copy of the ChannelArgs
   // which holds an std::shared_ptr of the EventEngine.
   grpc_event_engine::experimental::EventEngine* event_engine_
       ABSL_GUARDED_BY(mu_);
-  absl::optional<grpc_error_handle> notify_error_;
+  std::optional<grpc_error_handle> notify_error_;
   RefCountedPtr<HandshakeManager> handshake_mgr_;
 };
 

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -32,6 +32,7 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -45,7 +46,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
@@ -212,7 +212,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
           ABSL_GUARDED_BY(&ActiveConnection::mu_);
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
       Timestamp const deadline_;
-      absl::optional<EventEngine::TaskHandle> timer_handle_
+      std::optional<EventEngine::TaskHandle> timer_handle_
           ABSL_GUARDED_BY(&ActiveConnection::mu_);
       grpc_closure on_receive_settings_ ABSL_GUARDED_BY(&ActiveConnection::mu_);
       grpc_pollset_set* const interested_parties_;
@@ -250,7 +250,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
     RefCountedPtr<grpc_chttp2_transport> transport_ ABSL_GUARDED_BY(&mu_) =
         nullptr;
     grpc_closure on_close_;
-    absl::optional<EventEngine::TaskHandle> drain_grace_timer_handle_
+    std::optional<EventEngine::TaskHandle> drain_grace_timer_handle_
         ABSL_GUARDED_BY(&mu_);
     // Use a raw pointer since this event_engine_ is grabbed from the
     // ChannelArgs of the listener_.
@@ -297,7 +297,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
   MemoryQuotaRefPtr memory_quota_;
   ConnectionQuotaRefPtr connection_quota_;
   ServerConfigFetcher* config_fetcher_ = nullptr;
-  // TODO(yashykt): consider using absl::variant<> to minimize memory usage for
+  // TODO(yashykt): consider using std::variant<> to minimize memory usage for
   // disjoint cases where different fields are used.
   std::shared_ptr<experimental::PassiveListenerImpl> passive_listener_;
 };
@@ -530,7 +530,6 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
               &on_receive_settings_, nullptr, on_close);
           timer_handle_ = connection_->event_engine_->RunAfter(
               deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
-                ApplicationCallbackExecCtx callback_exec_ctx;
                 ExecCtx exec_ctx;
                 self->OnTimeout();
                 // HandshakingState deletion might require an active ExecCtx.
@@ -614,7 +613,6 @@ void Chttp2ServerListener::ActiveConnection::SendGoAway() {
                              GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS)
                          .value_or(Duration::Minutes(10))),
             [self = Ref(DEBUG_LOCATION, "drain_grace_timer")]() mutable {
-              ApplicationCallbackExecCtx callback_exec_ctx;
               ExecCtx exec_ctx;
               self->OnDrainGraceTimeExpiry();
               self.reset(DEBUG_LOCATION, "drain_grace_timer");
@@ -972,7 +970,11 @@ NewChttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
     RefCountedPtr<ActiveConnection> connection_ref, grpc_tcp_server* tcp_server,
     grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
     const ChannelArgs& args, OrphanablePtr<grpc_endpoint> endpoint)
-    : connection_(std::move(connection_ref)),
+    : InternallyRefCounted(
+          GRPC_TRACE_FLAG_ENABLED(chttp2_server_refcount)
+              ? "NewChttp2ServerListener::ActiveConnection::HandshakingState"
+              : nullptr),
+      connection_(std::move(connection_ref)),
       tcp_server_(tcp_server),
       accepting_pollset_(accepting_pollset),
       acceptor_(std::move(acceptor)),
@@ -1039,7 +1041,7 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
     return;
   }
   timer_handle_.reset();
-  auto t = absl::get<RefCountedPtr<grpc_chttp2_transport>>(connection_->state_);
+  auto t = std::get<RefCountedPtr<grpc_chttp2_transport>>(connection_->state_);
   t->DisconnectWithError(GRPC_ERROR_CREATE(
       "Did not receive HTTP/2 settings before handshake timeout"));
 }
@@ -1093,7 +1095,6 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
       timer_handle_ = connection_->listener_state_->event_engine()->RunAfter(
           deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
             // HandshakingState deletion might require an active ExecCtx.
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();
             self_ptr->connection_->work_serializer_.Run(
@@ -1112,7 +1113,7 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
   handshake_mgr_.reset();
   connection_->listener_state_->OnHandshakeDone(connection_.get());
   // Clean up if we don't have a transport
-  if (!absl::holds_alternative<RefCountedPtr<grpc_chttp2_transport>>(
+  if (!std::holds_alternative<RefCountedPtr<grpc_chttp2_transport>>(
           connection_->state_)) {
     connection_->listener_state_->connection_quota()->ReleaseConnections(1);
     connection_->listener_state_->RemoveLogicalConnection(connection_.get());
@@ -1128,7 +1129,10 @@ NewChttp2ServerListener::ActiveConnection::ActiveConnection(
     grpc_tcp_server* tcp_server, grpc_pollset* accepting_pollset,
     AcceptorPtr acceptor, const ChannelArgs& args, MemoryOwner memory_owner,
     OrphanablePtr<grpc_endpoint> endpoint)
-    : listener_state_(std::move(listener_state)),
+    : LogicalConnection(GRPC_TRACE_FLAG_ENABLED(chttp2_server_refcount)
+                            ? "NewChttp2ServerListener::ActiveConnection"
+                            : nullptr),
+      listener_state_(std::move(listener_state)),
       work_serializer_(
           args.GetObjectRef<grpc_event_engine::experimental::EventEngine>()),
       state_(memory_owner.MakeOrphanable<HandshakingState>(
@@ -1146,7 +1150,7 @@ void NewChttp2ServerListener::ActiveConnection::Orphan() {
         // shutting down and a transport has already been established, GOAWAYs
         // should be sent separately.
         shutdown_ = true;
-        if (absl::holds_alternative<OrphanablePtr<HandshakingState>>(state_)) {
+        if (std::holds_alternative<OrphanablePtr<HandshakingState>>(state_)) {
           state_ = OrphanablePtr<HandshakingState>(nullptr);
         }
         Unref();
@@ -1177,7 +1181,7 @@ void NewChttp2ServerListener::ActiveConnection::Start(const ChannelArgs& args) {
         // owning NewChttp2ServerListener and all associated
         // ActiveConnections have been orphaned.
         if (self->shutdown_) return;
-        absl::get<OrphanablePtr<HandshakingState>>(self->state_)
+        std::get<OrphanablePtr<HandshakingState>>(self->state_)
             ->StartLocked(args);
       },
       DEBUG_LOCATION);
@@ -1207,8 +1211,10 @@ void NewChttp2ServerListener::ActiveConnection::SendGoAwayImplLocked() {
           // Send a GOAWAY if the transport exists
           if (transport != nullptr) {
             grpc_transport_op* op = grpc_make_transport_op(nullptr);
-            op->goaway_error =
-                GRPC_ERROR_CREATE("Server is stopping to serve requests.");
+            // Set an HTTP2 error of NO_ERROR to do graceful GOAWAYs.
+            op->goaway_error = grpc_error_set_int(
+                GRPC_ERROR_CREATE("Server is stopping to serve requests."),
+                StatusIntProperty::kHttp2Error, GRPC_HTTP2_NO_ERROR);
             transport->PerformOp(op);
           }
         });
@@ -1276,7 +1282,7 @@ grpc_error_handle NewChttp2ServerListener::Create(
   if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
           .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
     auto string_address =
-        grpc_event_engine::experimental::ResolvedAddressToString(addr);
+        grpc_event_engine::experimental::ResolvedAddressToURI(addr);
     if (!string_address.ok()) {
       return GRPC_ERROR_CREATE(string_address.status().ToString());
     }
@@ -1317,7 +1323,11 @@ NewChttp2ServerListener* NewChttp2ServerListener::CreateForPassiveListener(
 NewChttp2ServerListener::NewChttp2ServerListener(
     const ChannelArgs& args,
     std::shared_ptr<experimental::PassiveListenerImpl> passive_listener)
-    : args_(args), passive_listener_(std::move(passive_listener)) {
+    : ListenerInterface(GRPC_TRACE_FLAG_ENABLED(chttp2_server_refcount)
+                            ? "NewChttp2ServerListener"
+                            : nullptr),
+      args_(args),
+      passive_listener_(std::move(passive_listener)) {
   GRPC_CLOSURE_INIT(&tcp_server_shutdown_complete_, TcpServerShutdownComplete,
                     this, grpc_schedule_on_exec_ctx);
 }
@@ -1410,7 +1420,7 @@ void NewChttp2ServerListener::OnAccept(
       std::move(endpoint));
   RefCountedPtr<ActiveConnection> connection_ref =
       connection->RefAsSubclass<ActiveConnection>();
-  absl::optional<ChannelArgs> new_args =
+  std::optional<ChannelArgs> new_args =
       self->listener_state_->AddLogicalConnection(std::move(connection),
                                                   self->args_, tcp);
   if (new_args.has_value()) {
@@ -1569,7 +1579,7 @@ absl::Status PassiveListenerImpl::AcceptConnectedEndpoint(
     {
       MutexLock lock(&mu_);
       auto* new_listener_ptr =
-          absl::get_if<NewChttp2ServerListener*>(&listener_);
+          std::get_if<NewChttp2ServerListener*>(&listener_);
       if (new_listener_ptr != nullptr && *new_listener_ptr != nullptr) {
         new_listener = (*new_listener_ptr)
                            ->RefIfNonZero()
@@ -1585,7 +1595,7 @@ absl::Status PassiveListenerImpl::AcceptConnectedEndpoint(
     RefCountedPtr<Chttp2ServerListener> listener;
     {
       MutexLock lock(&mu_);
-      auto* listener_ptr = absl::get_if<Chttp2ServerListener*>(&listener_);
+      auto* listener_ptr = std::get_if<Chttp2ServerListener*>(&listener_);
       if (listener_ptr != nullptr && *listener_ptr != nullptr) {
         listener = (*listener_ptr)
                        ->RefIfNonZero()

data/src/core/ext/transport/chttp2/server/chttp2_server.h

@@ -92,7 +92,7 @@ class NewChttp2ServerListener : public Server::ListenerInterface {
       // Following fields are protected by WorkSerializer.
       RefCountedPtr<HandshakeManager> handshake_mgr_;
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
-      absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
           timer_handle_;
       grpc_closure on_receive_settings_;
     };
@@ -127,8 +127,8 @@ class NewChttp2ServerListener : public Server::ListenerInterface {
     // Following fields are protected by WorkSerializer.
     // Set by HandshakingState before the handshaking begins and set to a valid
     // transport when handshaking is done successfully.
-    absl::variant<OrphanablePtr<HandshakingState>,
-                  RefCountedPtr<grpc_chttp2_transport>>
+    std::variant<OrphanablePtr<HandshakingState>,
+                 RefCountedPtr<grpc_chttp2_transport>>
         state_;
     grpc_closure on_close_;
     bool shutdown_ = false;
@@ -212,7 +212,7 @@ class NewChttp2ServerListener : public Server::ListenerInterface {
   grpc_closure tcp_server_shutdown_complete_ ABSL_GUARDED_BY(mu_);
   grpc_closure* on_destroy_done_ ABSL_GUARDED_BY(mu_) = nullptr;
   RefCountedPtr<channelz::ListenSocketNode> channelz_listen_socket_;
-  // TODO(yashykt): consider using absl::variant<> to minimize memory usage for
+  // TODO(yashykt): consider using std::variant<> to minimize memory usage for
   // disjoint cases where different fields are used.
   std::shared_ptr<experimental::PassiveListenerImpl> passive_listener_;
 };
@@ -247,7 +247,7 @@ class PassiveListenerImpl final : public PassiveListener {
   Mutex mu_;
   // Data members will be populated when initialized.
   RefCountedPtr<Server> server_;
-  absl::variant<Chttp2ServerListener*, NewChttp2ServerListener*> listener_;
+  std::variant<Chttp2ServerListener*, NewChttp2ServerListener*> listener_;
 };
 
 }  // namespace experimental

data/src/core/ext/transport/chttp2/transport/bin_decoder.cc

@@ -142,7 +142,7 @@ bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx) {
       switch (input_tail) {
         case 3:
           ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur);
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
         case 2:
           ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
       }

data/src/core/ext/transport/chttp2/transport/call_tracer_wrapper.cc

@@ -30,7 +30,7 @@ void Chttp2CallTracerWrapper::RecordIncomingBytes(
   stream_->stats.incoming.header_bytes += transport_byte_size.header_bytes;
   // Update new API.
   if (!IsCallTracerInTransportEnabled()) return;
-  auto* call_tracer = stream_->arena->GetContext<CallTracerInterface>();
+  auto* call_tracer = stream_->CallTracer();
   if (call_tracer != nullptr) {
     call_tracer->RecordIncomingBytes(transport_byte_size);
   }
@@ -44,7 +44,7 @@ void Chttp2CallTracerWrapper::RecordOutgoingBytes(
   stream_->stats.outgoing.header_bytes +=
       transport_byte_size.header_bytes;  // Update new API.
   if (!IsCallTracerInTransportEnabled()) return;
-  auto* call_tracer = stream_->arena->GetContext<CallTracerInterface>();
+  auto* call_tracer = stream_->CallTracer();
   if (call_tracer != nullptr) {
     call_tracer->RecordOutgoingBytes(transport_byte_size);
   }