grpc 1.70.1 → 1.71.0

data/src/core/resolver/xds/xds_resolver.cc

@@ -25,9 +25,11 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/log/check.h"
@@ -43,8 +45,6 @@
 #include "absl/strings/str_replace.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "re2/re2.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/config_selector.h"
@@ -164,11 +164,9 @@ class XdsResolver final : public Resolver {
 
     void Orphaned() override {
       XdsResolver* resolver_ptr = resolver_.get();
-      resolver_ptr->work_serializer_->Run(
-          [resolver = std::move(resolver_)]() {
-            resolver->MaybeRemoveUnusedClusters();
-          },
-          DEBUG_LOCATION);
+      resolver_ptr->work_serializer_->Run([resolver = std::move(resolver_)]() {
+        resolver->MaybeRemoveUnusedClusters();
+      });
       cluster_subscription_.reset();
     }
 
@@ -325,32 +323,31 @@ class XdsResolver final : public Resolver {
     class Call {
      public:
       void OnClientInitialMetadata(ClientMetadata& md);
-      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;
     };
   };
 
   RefCountedPtr<ClusterRef> GetOrCreateClusterRef(
       absl::string_view cluster_key, absl::string_view cluster_name) {
     auto it = cluster_ref_map_.find(cluster_key);
-    if (it == cluster_ref_map_.end()) {
-      RefCountedPtr<XdsDependencyManager::ClusterSubscription> subscription;
-      if (!cluster_name.empty()) {
-        // The cluster ref will hold a subscription to ensure that the
-        // XdsDependencyManager stays subscribed to the CDS resource as
-        // long as the cluster ref exists.
-        subscription = dependency_mgr_->GetClusterSubscription(cluster_name);
-      }
-      auto cluster = MakeRefCounted<ClusterRef>(
-          RefAsSubclass<XdsResolver>(), std::move(subscription), cluster_key);
-      cluster_ref_map_.emplace(cluster->cluster_key(), cluster->WeakRef());
-      return cluster;
+    if (it != cluster_ref_map_.end()) return it->second->Ref();
+    // Not found, so create a new one.
+    RefCountedPtr<XdsDependencyManager::ClusterSubscription> subscription;
+    if (!cluster_name.empty()) {
+      // The cluster ref will hold a subscription to ensure that the
+      // XdsDependencyManager stays subscribed to the CDS resource as
+      // long as the cluster ref exists.
+      subscription = dependency_mgr_->GetClusterSubscription(cluster_name);
     }
-    return it->second->Ref();
+    auto cluster = MakeRefCounted<ClusterRef>(
+        RefAsSubclass<XdsResolver>(), std::move(subscription), cluster_key);
+    cluster_ref_map_.emplace(cluster->cluster_key(), cluster->WeakRef());
+    return cluster;
   }
 
   void OnUpdate(absl::StatusOr<RefCountedPtr<const XdsConfig>> config);
@@ -375,18 +372,6 @@ class XdsResolver final : public Resolver {
   std::map<absl::string_view, WeakRefCountedPtr<ClusterRef>> cluster_ref_map_;
 };
 
-const NoInterceptor
-    XdsResolver::ClusterSelectionFilter::Call::OnServerInitialMetadata;
-const NoInterceptor
-    XdsResolver::ClusterSelectionFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor
-    XdsResolver::ClusterSelectionFilter::Call::OnClientToServerMessage;
-const NoInterceptor
-    XdsResolver::ClusterSelectionFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor
-    XdsResolver::ClusterSelectionFilter::Call::OnServerToClientMessage;
-const NoInterceptor XdsResolver::ClusterSelectionFilter::Call::OnFinalize;
-
 //
 // XdsResolver::RouteConfigData::RouteListIterator
 //
@@ -452,7 +437,7 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
         cluster_weight) {
   std::vector<std::string> fields;
   const auto& route_action =
-      absl::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
+      std::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
   // Set retry policy if any.
   if (route_action.retry_policy.has_value() &&
       !route_action.retry_policy->retry_on.Empty()) {
@@ -498,7 +483,7 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
                         route_action.max_stream_duration->ToJsonString()));
   }
   // Handle xDS HTTP filters.
-  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
       resolver->current_config_->listener->listener);
   auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
       DownCast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
@@ -506,10 +491,9 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
       hcm.http_filters, *resolver->current_config_->virtual_host, route,
       cluster_weight, resolver->args_);
   if (!result.ok()) return result.status();
-  for (const auto& p : result->per_filter_configs) {
-    fields.emplace_back(absl::StrCat("    \"", p.first, "\": [\n",
-                                     absl::StrJoin(p.second, ",\n"),
-                                     "\n    ]"));
+  for (const auto& [name, config] : result->per_filter_configs) {
+    fields.emplace_back(absl::StrCat("    \"", name, "\": [\n",
+                                     absl::StrJoin(config, ",\n"), "\n    ]"));
   }
   // Construct service config.
   if (!fields.empty()) {
@@ -544,7 +528,7 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
     absl::string_view key = cluster_state->cluster_key();
     clusters_.emplace(key, std::move(cluster_state));
   };
-  auto* route_action = absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+  auto* route_action = std::get_if<XdsRouteConfigResource::Route::RouteAction>(
       &route_entry->route.action);
   if (route_action != nullptr) {
     // If the route doesn't specify a timeout, set its timeout to the global
@@ -628,7 +612,7 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
   const auto& http_filter_registry =
       static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
           .http_filter_registry();
-  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
       resolver_->current_config_->listener->listener);
   for (const auto& http_filter : hcm.http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
@@ -647,25 +631,19 @@ XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
       << "[xds_resolver " << resolver_.get()
       << "] destroying XdsConfigSelector " << this;
   route_config_data_.reset();
-  if (!IsWorkSerializerDispatchEnabled()) {
-    resolver_->MaybeRemoveUnusedClusters();
-    return;
-  }
-  resolver_->work_serializer_->Run(
-      [resolver = std::move(resolver_)]() {
-        resolver->MaybeRemoveUnusedClusters();
-      },
-      DEBUG_LOCATION);
+  resolver_->work_serializer_->Run([resolver = std::move(resolver_)]() {
+    resolver->MaybeRemoveUnusedClusters();
+  });
 }
 
-absl::optional<uint64_t> HeaderHashHelper(
+std::optional<uint64_t> HeaderHashHelper(
     const XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header&
         header_policy,
     grpc_metadata_batch* initial_metadata) {
   std::string value_buffer;
-  absl::optional<absl::string_view> header_value = XdsRouting::GetHeaderValue(
+  std::optional<absl::string_view> header_value = XdsRouting::GetHeaderValue(
       initial_metadata, header_policy.header_name, &value_buffer);
-  if (!header_value.has_value()) return absl::nullopt;
+  if (!header_value.has_value()) return std::nullopt;
   if (header_policy.regex != nullptr) {
     // If GetHeaderValue() did not already store the value in
     // value_buffer, copy it there now, so we can modify it.
@@ -691,7 +669,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
   }
   // Found a route match
   const auto* route_action =
-      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+      std::get_if<XdsRouteConfigResource::Route::RouteAction>(
           &entry->route.action);
   if (route_action == nullptr) {
     return absl::UnavailableError("Matching route has inappropriate action");
@@ -746,16 +724,16 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
   auto cluster = route_config_data_->FindClusterRef(cluster_name);
   CHECK(cluster != nullptr);
   // Generate a hash.
-  absl::optional<uint64_t> hash;
+  std::optional<uint64_t> hash;
   for (const auto& hash_policy : route_action->hash_policies) {
-    absl::optional<uint64_t> new_hash = Match(
+    std::optional<uint64_t> new_hash = Match(
         hash_policy.policy,
         [&](const XdsRouteConfigResource::Route::RouteAction::HashPolicy::
                 Header& header) {
           return HeaderHashHelper(header, args.initial_metadata);
         },
         [&](const XdsRouteConfigResource::Route::RouteAction::HashPolicy::
-                ChannelId&) -> absl::optional<uint64_t> {
+                ChannelId&) -> std::optional<uint64_t> {
           return resolver_->channel_id_;
         });
     if (new_hash.has_value()) {
@@ -819,7 +797,7 @@ bool XdsResolver::XdsRouteStateAttributeImpl::HasClusterForRoute(
     absl::string_view cluster_name) const {
   // Found a route match
   const auto* route_action =
-      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+      std::get_if<XdsRouteConfigResource::Route::RouteAction>(
           &static_cast<RouteConfigData::RouteEntry*>(route_)->route.action);
   if (route_action == nullptr) return false;
   return Match(
@@ -985,18 +963,18 @@ void XdsResolver::OnUpdate(
 absl::StatusOr<RefCountedPtr<ServiceConfig>>
 XdsResolver::CreateServiceConfig() {
   std::vector<std::string> clusters;
-  for (const auto& cluster : cluster_ref_map_) {
-    absl::string_view child_name = cluster.first;
-    if (absl::ConsumePrefix(&child_name, "cluster_specifier_plugin:")) {
+  for (const auto& [child_name, _] : cluster_ref_map_) {
+    absl::string_view cluster_name = child_name;
+    if (absl::ConsumePrefix(&cluster_name, "cluster_specifier_plugin:")) {
       clusters.push_back(absl::StrFormat(
           "      \"%s\":{\n"
           "        \"childPolicy\": %s\n"
           "       }",
-          cluster.first,
+          child_name,
           current_config_->route_config->cluster_specifier_plugin_map.at(
-              std::string(child_name))));
+              std::string(cluster_name))));
     } else {
-      absl::ConsumePrefix(&child_name, "cluster:");
+      absl::ConsumePrefix(&cluster_name, "cluster:");
       clusters.push_back(
           absl::StrFormat("      \"%s\":{\n"
                           "        \"childPolicy\":[ {\n"
@@ -1005,7 +983,7 @@ XdsResolver::CreateServiceConfig() {
                           "          }\n"
                           "        } ]\n"
                           "       }",
-                          cluster.first, child_name));
+                          child_name, cluster_name));
     }
   }
   std::vector<std::string> config_parts;
@@ -1017,7 +995,7 @@ XdsResolver::CreateServiceConfig() {
                    "    }\n"
                    "    } }\n"
                    "  ]"));
-  auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+  auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
       current_config_->listener->listener);
   auto filter_configs =
       XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
@@ -1025,9 +1003,9 @@ XdsResolver::CreateServiceConfig() {
               .http_filter_registry(),
           hcm.http_filters, args_);
   if (!filter_configs.ok()) return filter_configs.status();
-  for (const auto& p : filter_configs->per_filter_configs) {
+  for (const auto& [name, config] : filter_configs->per_filter_configs) {
     config_parts.emplace_back(absl::StrCat(
-        "  \"", p.first, "\": [\n", absl::StrJoin(p.second, ",\n"), "\n  ]"));
+        "  \"", name, "\": [\n", absl::StrJoin(config, ",\n"), "\n  ]"));
   }
   std::string json = absl::StrCat("{", absl::StrJoin(config_parts, ",\n"), "}");
   return ServiceConfigImpl::Create(filter_configs->args, json.c_str());
@@ -1037,7 +1015,7 @@ void XdsResolver::GenerateResult() {
   if (xds_client_ == nullptr || current_config_ == nullptr) return;
   // First create XdsConfigSelector, which may add new entries to the cluster
   // state map.
-  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
       current_config_->listener->listener);
   auto route_config_data =
       RouteConfigData::Create(this, hcm.http_max_stream_duration);
@@ -1114,7 +1092,7 @@ class XdsResolverFactory final : public ResolverFactory {
  private:
   std::string GetDataPlaneAuthority(const ChannelArgs& args,
                                     const URI& uri) const {
-    absl::optional<absl::string_view> authority =
+    std::optional<absl::string_view> authority =
         args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
     if (authority.has_value()) return URI::PercentEncodeAuthority(*authority);
     return GetDefaultAuthority(uri);

data/src/core/server/server.cc

@@ -33,6 +33,7 @@
 #include <list>
 #include <memory>
 #include <new>
+#include <optional>
 #include <queue>
 #include <type_traits>
 #include <utility>
@@ -43,7 +44,6 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
@@ -180,7 +180,7 @@ void Server::ListenerState::Stop() {
   listener_.reset();
 }
 
-absl::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
+std::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
     OrphanablePtr<ListenerInterface::LogicalConnection> connection,
     const ChannelArgs& args, grpc_endpoint* endpoint) {
   RefCountedPtr<ServerConfigFetcher::ConnectionManager> connection_manager;
@@ -188,7 +188,7 @@ absl::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
     MutexLock lock(&mu_);
     if (!is_serving_) {
       // Not serving
-      return absl::nullopt;
+      return std::nullopt;
     }
     connection_manager = connection_manager_;
   }
@@ -204,24 +204,24 @@ absl::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
   if (server_->config_fetcher() != nullptr) {
     if (connection_manager == nullptr) {
       // Connection manager not available
-      return absl::nullopt;
+      return std::nullopt;
     }
     absl::StatusOr<ChannelArgs> args_result =
         connection_manager->UpdateChannelArgsForConnection(new_args, endpoint);
     if (!args_result.ok()) {
-      return absl::nullopt;
+      return std::nullopt;
     }
     auto* server_credentials =
         (*args_result).GetObject<grpc_server_credentials>();
     if (server_credentials == nullptr) {
       // Could not find server credentials
-      return absl::nullopt;
+      return std::nullopt;
     }
     auto security_connector =
         server_credentials->create_security_connector(*args_result);
     if (security_connector == nullptr) {
       // Unable to create secure server with credentials
-      return absl::nullopt;
+      return std::nullopt;
     }
     new_args = (*args_result).SetObject(security_connector);
   }
@@ -232,7 +232,7 @@ absl::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
   // to the list of tracked connections.
   if (!is_serving_ || connection_manager != connection_manager_) {
     // Not serving
-    return absl::nullopt;
+    return std::nullopt;
   }
   connections_.emplace(std::move(connection));
   return new_args;
@@ -328,7 +328,6 @@ void Server::ListenerState::MaybeStartNewGraceTimerLocked() {
   drain_grace_timer_handle_ = event_engine()->RunAfter(
       connections_to_be_drained_list_.front().timestamp - Timestamp::Now(),
       [self = Ref()]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         self->OnDrainGraceTimer();
         // resetting within an active ExecCtx
@@ -1085,71 +1084,71 @@ absl::StatusOr<ClientMetadataHandle> CheckClientMetadata(
 }
 }  // namespace
 
+auto Server::MatchRequestAndMaybeReadFirstMessage(CallHandler call_handler,
+                                                  ClientMetadataHandle md) {
+  auto* registered_method = static_cast<RegisteredMethod*>(
+      md->get(GrpcRegisteredMethod()).value_or(nullptr));
+  RequestMatcherInterface* rm;
+  grpc_server_register_method_payload_handling payload_handling =
+      GRPC_SRM_PAYLOAD_NONE;
+  if (registered_method == nullptr) {
+    rm = unregistered_request_matcher_.get();
+  } else {
+    payload_handling = registered_method->payload_handling;
+    rm = registered_method->matcher.get();
+  }
+  using FirstMessageResult = ValueOrFailure<std::optional<MessageHandle>>;
+  auto maybe_read_first_message = If(
+      payload_handling == GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER,
+      [call_handler]() mutable {
+        return Map(
+            call_handler.PullMessage(),
+            [](ClientToServerNextMessage next_msg) -> FirstMessageResult {
+              if (!next_msg.ok()) return Failure{};
+              if (!next_msg.has_value()) {
+                return FirstMessageResult(std::nullopt);
+              }
+              return FirstMessageResult(next_msg.TakeValue());
+            });
+      },
+      []() -> FirstMessageResult { return FirstMessageResult(std::nullopt); });
+  return TryJoin<absl::StatusOr>(
+      std::move(maybe_read_first_message), rm->MatchRequest(0),
+      [md = std::move(md)]() mutable {
+        return ValueOrFailure<ClientMetadataHandle>(std::move(md));
+      });
+}
+
 auto Server::MatchAndPublishCall(CallHandler call_handler) {
-  call_handler.SpawnGuardedUntilCallCompletes(
-      "request_matcher", [this, call_handler]() mutable {
-        return TrySeq(
+  call_handler.SpawnGuarded("request_matcher", [this, call_handler]() mutable {
+    return TrySeq(
+        call_handler.UntilCallCompletes(TrySeq(
             // Wait for initial metadata to pass through all filters
             Map(call_handler.PullClientInitialMetadata(), CheckClientMetadata),
             // Match request with requested call
             [this, call_handler](ClientMetadataHandle md) mutable {
-              auto* registered_method = static_cast<RegisteredMethod*>(
-                  md->get(GrpcRegisteredMethod()).value_or(nullptr));
-              RequestMatcherInterface* rm;
-              grpc_server_register_method_payload_handling payload_handling =
-                  GRPC_SRM_PAYLOAD_NONE;
-              if (registered_method == nullptr) {
-                rm = unregistered_request_matcher_.get();
-              } else {
-                payload_handling = registered_method->payload_handling;
-                rm = registered_method->matcher.get();
-              }
-              using FirstMessageResult =
-                  ValueOrFailure<absl::optional<MessageHandle>>;
-              auto maybe_read_first_message = If(
-                  payload_handling == GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER,
-                  [call_handler]() mutable {
-                    return Map(
-                        call_handler.PullMessage(),
-                        [](ClientToServerNextMessage next_msg)
-                            -> FirstMessageResult {
-                          if (!next_msg.ok()) return Failure{};
-                          if (!next_msg.has_value()) {
-                            return FirstMessageResult(absl::nullopt);
-                          }
-                          return FirstMessageResult(next_msg.TakeValue());
-                        });
-                  },
-                  []() -> FirstMessageResult {
-                    return FirstMessageResult(absl::nullopt);
-                  });
-              return TryJoin<absl::StatusOr>(
-                  std::move(maybe_read_first_message), rm->MatchRequest(0),
-                  [md = std::move(md)]() mutable {
-                    return ValueOrFailure<ClientMetadataHandle>(std::move(md));
-                  });
-            },
-            // Publish call to cq
-            [call_handler,
-             this](std::tuple<absl::optional<MessageHandle>,
-                              RequestMatcherInterface::MatchResult,
-                              ClientMetadataHandle>
-                       r) {
-              RequestMatcherInterface::MatchResult& mr = std::get<1>(r);
-              auto md = std::move(std::get<2>(r));
-              auto* rc = mr.TakeCall();
-              rc->Complete(std::move(std::get<0>(r)), *md);
-              grpc_call* call =
-                  MakeServerCall(call_handler, std::move(md), this,
-                                 rc->cq_bound_to_call, rc->initial_metadata);
-              *rc->call = call;
-              return Map(
-                  WaitForCqEndOp(false, rc->tag, absl::OkStatus(), mr.cq()),
-                  [rc = std::unique_ptr<RequestedCall>(rc)](Empty) {
-                    return absl::OkStatus();
-                  });
-            });
-      });
+              return MatchRequestAndMaybeReadFirstMessage(
+                  std::move(call_handler), std::move(md));
+            })),
+        // Publish call to cq
+        [call_handler, this](std::tuple<std::optional<MessageHandle>,
+                                        RequestMatcherInterface::MatchResult,
+                                        ClientMetadataHandle>
+                                 r) {
+          RequestMatcherInterface::MatchResult& mr = std::get<1>(r);
+          auto md = std::move(std::get<2>(r));
+          auto* rc = mr.TakeCall();
+          rc->Complete(std::move(std::get<0>(r)), *md);
+          grpc_call* call =
+              MakeServerCall(call_handler, std::move(md), this,
+                             rc->cq_bound_to_call, rc->initial_metadata);
+          *rc->call = call;
+          return Map(WaitForCqEndOp(false, rc->tag, absl::OkStatus(), mr.cq()),
+                     [rc = std::unique_ptr<RequestedCall>(rc)](Empty) {
+                       return absl::OkStatus();
+                     });
+        });
+  });
 }
 
 absl::StatusOr<RefCountedPtr<UnstartedCallDestination>>
@@ -1343,7 +1342,7 @@ Server::RegisteredMethod* Server::RegisterMethod(
     LOG(ERROR) << "grpc_server_register_method method string cannot be NULL";
     return nullptr;
   }
-  auto key = std::make_pair(host ? host : "", method);
+  auto key = std::pair(host ? host : "", method);
   if (registered_methods_.find(key) != registered_methods_.end()) {
     LOG(ERROR) << "duplicate registration for " << method << "@"
                << (host ? host : "*");
@@ -1697,12 +1696,12 @@ Server::RegisteredMethod* Server::GetRegisteredMethod(
     const absl::string_view& host, const absl::string_view& path) {
   if (registered_methods_.empty()) return nullptr;
   // check for an exact match with host
-  auto it = registered_methods_.find(std::make_pair(host, path));
+  auto it = registered_methods_.find(std::pair(host, path));
   if (it != registered_methods_.end()) {
     return it->second.get();
   }
   // check for wildcard method definition (no host set)
-  it = registered_methods_.find(std::make_pair("", path));
+  it = registered_methods_.find(std::pair("", path));
   if (it != registered_methods_.end()) {
     return it->second.get();
   }
@@ -2111,7 +2110,6 @@ void grpc_server_start(grpc_server* server) {
 
 void grpc_server_shutdown_and_notify(grpc_server* server,
                                      grpc_completion_queue* cq, void* tag) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_server_shutdown_and_notify(server=" << server << ", cq=" << cq
@@ -2120,7 +2118,6 @@ void grpc_server_shutdown_and_notify(grpc_server* server,
 }
 
 void grpc_server_cancel_all_calls(grpc_server* server) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_server_cancel_all_calls(server=" << server << ")";
@@ -2128,7 +2125,6 @@ void grpc_server_cancel_all_calls(grpc_server* server) {
 }
 
 void grpc_server_destroy(grpc_server* server) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO) << "grpc_server_destroy(server=" << server << ")";
   grpc_core::Server::FromC(server)->Orphan();
@@ -2139,7 +2135,6 @@ grpc_call_error grpc_server_request_call(
     grpc_metadata_array* request_metadata,
     grpc_completion_queue* cq_bound_to_call,
     grpc_completion_queue* cq_for_notification, void* tag) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_server_request_call(" << "server=" << server << ", call=" << call
@@ -2157,7 +2152,6 @@ grpc_call_error grpc_server_request_registered_call(
     grpc_byte_buffer** optional_payload,
     grpc_completion_queue* cq_bound_to_call,
     grpc_completion_queue* cq_for_notification, void* tag_new) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   auto* rm =
       static_cast<grpc_core::Server::RegisteredMethod*>(registered_method);
@@ -2176,7 +2170,6 @@ grpc_call_error grpc_server_request_registered_call(
 
 void grpc_server_set_config_fetcher(
     grpc_server* server, grpc_server_config_fetcher* server_config_fetcher) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_server_set_config_fetcher(server=" << server
@@ -2188,7 +2181,6 @@ void grpc_server_set_config_fetcher(
 
 void grpc_server_config_fetcher_destroy(
     grpc_server_config_fetcher* server_config_fetcher) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_server_config_fetcher_destroy(config_fetcher="

data/src/core/server/server.h

@@ -31,6 +31,7 @@
 #include <functional>
 #include <list>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -42,7 +43,6 @@
 #include "absl/random/random.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -181,6 +181,8 @@ class Server : public ServerInterface,
     // tracking systems, without increasing memory utilization.
     class LogicalConnection : public InternallyRefCounted<LogicalConnection> {
      public:
+      explicit LogicalConnection(const char* trace = nullptr)
+          : InternallyRefCounted(trace) {}
       ~LogicalConnection() override = default;
 
       // The following two methods are called in the context of a server config
@@ -189,6 +191,8 @@ class Server : public ServerInterface,
       virtual void DisconnectImmediately() = 0;
     };
 
+    explicit ListenerInterface(const char* trace = nullptr)
+        : InternallyRefCounted(trace) {}
     ~ListenerInterface() override = default;
 
     /// Starts listening.
@@ -228,7 +232,7 @@ class Server : public ServerInterface,
 
     // Adds a LogicalConnection to the listener and updates the channel args if
     // needed, and returns ChannelArgs if successful.
-    absl::optional<ChannelArgs> AddLogicalConnection(
+    std::optional<ChannelArgs> AddLogicalConnection(
         OrphanablePtr<ListenerInterface::LogicalConnection> connection,
         const ChannelArgs& args, grpc_endpoint* endpoint)
         ABSL_LOCKS_EXCLUDED(mu_);
@@ -449,7 +453,7 @@ class Server : public ServerInterface,
     // The index into Server::cqs_ of the CQ used as a starting point for
     // where to publish new incoming calls.
     size_t cq_idx_;
-    absl::optional<std::list<ChannelData*>::iterator> list_position_;
+    std::optional<std::list<ChannelData*>::iterator> list_position_;
     grpc_closure finish_destroy_channel_closure_;
     intptr_t channelz_socket_uuid_;
   };
@@ -513,8 +517,8 @@ class Server : public ServerInterface,
 
     std::atomic<CallState> state_{CallState::NOT_STARTED};
 
-    absl::optional<Slice> path_;
-    absl::optional<Slice> host_;
+    std::optional<Slice> path_;
+    std::optional<Slice> host_;
     Timestamp deadline_ = Timestamp::InfFuture();
 
     grpc_completion_queue* cq_new_ = nullptr;
@@ -629,6 +633,13 @@ class Server : public ServerInterface,
     return shutdown_refs_.load(std::memory_order_acquire) == 0;
   }
 
+  // Returns a promise that resolves to
+  // tuple<
+  //     optional<MessageHandle>,
+  //     RequestMatcherInterface::MatchResult,
+  //     ClientMetadataHandle>
+  auto MatchRequestAndMaybeReadFirstMessage(CallHandler call_handler,
+                                            ClientMetadataHandle md);
   auto MatchAndPublishCall(CallHandler call_handler);
   absl::StatusOr<RefCountedPtr<UnstartedCallDestination>> MakeCallDestination(
       const ChannelArgs& args);