grpc 1.46.2 → 1.48.0.pre1

data/src/core/lib/surface/lame_client.cc

@@ -20,69 +20,75 @@
 
 #include "src/core/lib/surface/lame_client.h"
 
-#include <string.h>
+#include <memory>
+#include <utility>
 
-#include <atomic>
+#include "absl/memory/memory.h"
+#include "absl/status/statusor.h"
 
 #include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/transport.h"
+
+// Avoid some IWYU confusion:
+// IWYU pragma: no_include "src/core/lib/gprpp/orphanable.h"
 
 #define GRPC_ARG_LAME_FILTER_ERROR "grpc.lame_filter_error"
 
 namespace grpc_core {
 
-namespace {
+const grpc_channel_filter LameClientFilter::kFilter =
+    MakePromiseBasedFilter<LameClientFilter, FilterEndpoint::kClient,
+                           kFilterIsLast>("lame-client");
 
-struct ChannelData {
-  explicit ChannelData(grpc_channel_element_args* args)
-      : state_tracker("lame_channel", GRPC_CHANNEL_SHUTDOWN) {
-    grpc_error_handle* err = grpc_channel_args_find_pointer<grpc_error_handle>(
-        args->channel_args, GRPC_ARG_LAME_FILTER_ERROR);
-    if (err != nullptr) error = GRPC_ERROR_REF(*err);
-  }
-
-  ~ChannelData() { GRPC_ERROR_UNREF(error); }
+absl::StatusOr<LameClientFilter> LameClientFilter::Create(ChannelArgs args,
+                                                          ChannelFilter::Args) {
+  return LameClientFilter(
+      *args.GetPointer<absl::Status>(GRPC_ARG_LAME_FILTER_ERROR));
+}
 
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  Mutex mu;
-  ConnectivityStateTracker state_tracker;
-};
+LameClientFilter::LameClientFilter(absl::Status error)
+    : error_(std::move(error)), state_(absl::make_unique<State>()) {}
 
-struct CallData {
-  CallCombiner* call_combiner;
-};
+LameClientFilter::State::State()
+    : state_tracker("lame_client", GRPC_CHANNEL_SHUTDOWN) {}
 
-void lame_start_transport_stream_op_batch(grpc_call_element* elem,
-                                          grpc_transport_stream_op_batch* op) {
-  CallData* calld = static_cast<CallData*>(elem->call_data);
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  grpc_transport_stream_op_batch_finish_with_failure(
-      op, GRPC_ERROR_REF(chand->error), calld->call_combiner);
+ArenaPromise<ServerMetadataHandle> LameClientFilter::MakeCallPromise(
+    CallArgs, NextPromiseFactory) {
+  return Immediate(ServerMetadataHandle(error_));
 }
 
-void lame_get_channel_info(grpc_channel_element* /*elem*/,
-                           const grpc_channel_info* /*channel_info*/) {}
+bool LameClientFilter::GetChannelInfo(const grpc_channel_info*) { return true; }
 
-void lame_start_transport_op(grpc_channel_element* elem,
-                             grpc_transport_op* op) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+bool LameClientFilter::StartTransportOp(grpc_transport_op* op) {
   {
-    MutexLock lock(&chand->mu);
+    MutexLock lock(&state_->mu);
     if (op->start_connectivity_watch != nullptr) {
-      chand->state_tracker.AddWatcher(op->start_connectivity_watch_state,
-                                      std::move(op->start_connectivity_watch));
+      state_->state_tracker.AddWatcher(op->start_connectivity_watch_state,
+                                       std::move(op->start_connectivity_watch));
     }
     if (op->stop_connectivity_watch != nullptr) {
-      chand->state_tracker.RemoveWatcher(op->stop_connectivity_watch);
+      state_->state_tracker.RemoveWatcher(op->stop_connectivity_watch);
     }
   }
   if (op->send_ping.on_initiate != nullptr) {
@@ -97,50 +103,18 @@ void lame_start_transport_op(grpc_channel_element* elem,
   if (op->on_consumed != nullptr) {
     ExecCtx::Run(DEBUG_LOCATION, op->on_consumed, GRPC_ERROR_NONE);
   }
+  return true;
 }
 
-grpc_error_handle lame_init_call_elem(grpc_call_element* elem,
-                                      const grpc_call_element_args* args) {
-  CallData* calld = static_cast<CallData*>(elem->call_data);
-  calld->call_combiner = args->call_combiner;
-  return GRPC_ERROR_NONE;
-}
-
-void lame_destroy_call_elem(grpc_call_element* /*elem*/,
-                            const grpc_call_final_info* /*final_info*/,
-                            grpc_closure* then_schedule_closure) {
-  ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, GRPC_ERROR_NONE);
-}
-
-grpc_error_handle lame_init_channel_elem(grpc_channel_element* elem,
-                                         grpc_channel_element_args* args) {
-  new (elem->channel_data) ChannelData(args);
-  return GRPC_ERROR_NONE;
-}
-
-void lame_destroy_channel_elem(grpc_channel_element* elem) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->~ChannelData();
-}
+namespace {
 
 // Channel arg vtable for a grpc_error_handle.
 void* ErrorCopy(void* p) {
-  grpc_error_handle* new_error = nullptr;
-  if (p != nullptr) {
-    grpc_error_handle* error = static_cast<grpc_error_handle*>(p);
-    new_error = new grpc_error_handle();
-    *new_error = GRPC_ERROR_REF(*error);
-  }
-  return new_error;
-}
-void ErrorDestroy(void* p) {
-  if (p != nullptr) {
-    grpc_error_handle* error = static_cast<grpc_error_handle*>(p);
-    GRPC_ERROR_UNREF(*error);
-    delete error;
-  }
+  return new absl::Status(*static_cast<absl::Status*>(p));
 }
+void ErrorDestroy(void* p) { delete static_cast<absl::Status*>(p); }
 int ErrorCompare(void* p, void* q) { return QsortCompare(p, q); }
+
 const grpc_arg_pointer_vtable kLameFilterErrorArgVtable = {
     ErrorCopy, ErrorDestroy, ErrorCompare};
 
@@ -154,23 +128,6 @@ grpc_arg MakeLameClientErrorArg(grpc_error_handle* error) {
 
 }  // namespace grpc_core
 
-const grpc_channel_filter grpc_lame_filter = {
-    grpc_core::lame_start_transport_stream_op_batch,
-    nullptr,
-    grpc_core::lame_start_transport_op,
-    sizeof(grpc_core::CallData),
-    grpc_core::lame_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    grpc_core::lame_destroy_call_elem,
-    sizeof(grpc_core::ChannelData),
-    grpc_core::lame_init_channel_elem,
-    grpc_core::lame_destroy_channel_elem,
-    grpc_core::lame_get_channel_info,
-    "lame-client",
-};
-
-#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack*)((c) + 1))
-
 grpc_channel* grpc_lame_client_channel_create(const char* target,
                                               grpc_status_code error_code,
                                               const char* error_message) {
@@ -179,21 +136,18 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
       "grpc_lame_client_channel_create(target=%s, error_code=%d, "
       "error_message=%s)",
       3, (target, (int)error_code, error_message));
-  grpc_error_handle error = grpc_error_set_str(
-      grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("lame client channel"),
-          GRPC_ERROR_INT_GRPC_STATUS, error_code),
-      GRPC_ERROR_STR_GRPC_MESSAGE, error_message);
-  grpc_arg error_arg = grpc_core::MakeLameClientErrorArg(&error);
-  grpc_channel_args* args0 =
-      grpc_channel_args_copy_and_add(nullptr, &error_arg, 1);
-  const grpc_channel_args* args = grpc_core::CoreConfiguration::Get()
-                                      .channel_args_preconditioning()
-                                      .PreconditionChannelArgs(args0);
-  grpc_channel_args_destroy(args0);
-  grpc_channel* channel = grpc_channel_create_internal(
-      target, args, GRPC_CLIENT_LAME_CHANNEL, nullptr, nullptr);
-  grpc_channel_args_destroy(args);
-  GRPC_ERROR_UNREF(error);
-  return channel;
+  if (error_code == GRPC_STATUS_OK) error_code = GRPC_STATUS_UNKNOWN;
+  grpc_core::ChannelArgs args =
+      grpc_core::CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(nullptr)
+          .Set(GRPC_ARG_LAME_FILTER_ERROR,
+               grpc_core::ChannelArgs::Pointer(
+                   new absl::Status(static_cast<absl::StatusCode>(error_code),
+                                    error_message),
+                   &grpc_core::kLameFilterErrorArgVtable));
+  auto channel = grpc_core::Channel::Create(target, std::move(args),
+                                            GRPC_CLIENT_LAME_CHANNEL, nullptr);
+  GPR_ASSERT(channel.ok());
+  return channel->release()->c_ptr();
 }

data/src/core/lib/surface/lame_client.h

@@ -21,13 +21,51 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 // Does NOT take ownership of error.
 grpc_arg MakeLameClientErrorArg(grpc_error_handle* error);
-}  // namespace grpc_core
 
-extern const grpc_channel_filter grpc_lame_filter;
+// This filter becomes the entire channel stack for a channel that fails to be
+// created. Every call returns failure.
+class LameClientFilter : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<LameClientFilter> Create(
+      ChannelArgs args, ChannelFilter::Args filter_args);
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  bool StartTransportOp(grpc_transport_op*) override;
+  bool GetChannelInfo(const grpc_channel_info*) override;
+
+ private:
+  explicit LameClientFilter(absl::Status error);
+
+  absl::Status error_;
+  struct State {
+    State();
+    Mutex mu;
+    ConnectivityStateTracker state_tracker ABSL_GUARDED_BY(mu);
+  };
+  std::unique_ptr<State> state_;
+};
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H */

data/src/core/lib/surface/metadata_array.cc

@@ -21,8 +21,10 @@
 #include <string.h>
 
 #include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 
 void grpc_metadata_array_init(grpc_metadata_array* array) {

data/src/core/lib/surface/server.cc

@@ -18,41 +18,48 @@
 
 #include "src/core/lib/surface/server.h"
 
-#include <limits.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <atomic>
-#include <iterator>
 #include <list>
+#include <new>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/byte_buffer.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/channel/connected_channel.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/mpscq.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/surface/init.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
 
@@ -439,16 +446,16 @@ class ChannelBroadcaster {
   // when the actual setup and shutdown broadcast take place.
 
   // Copies over the channels from the locked server.
-  void FillChannelsLocked(std::vector<grpc_channel*> channels) {
+  void FillChannelsLocked(std::vector<RefCountedPtr<Channel>> channels) {
     GPR_DEBUG_ASSERT(channels_.empty());
     channels_ = std::move(channels);
   }
 
   // Broadcasts a shutdown on each channel.
   void BroadcastShutdown(bool send_goaway, grpc_error_handle force_disconnect) {
-    for (grpc_channel* channel : channels_) {
-      SendShutdown(channel, send_goaway, GRPC_ERROR_REF(force_disconnect));
-      GRPC_CHANNEL_INTERNAL_UNREF(channel, "broadcast");
+    for (const RefCountedPtr<Channel>& channel : channels_) {
+      SendShutdown(channel->c_ptr(), send_goaway,
+                   GRPC_ERROR_REF(force_disconnect));
     }
     channels_.clear();  // just for safety against double broadcast
     GRPC_ERROR_UNREF(force_disconnect);
@@ -486,7 +493,7 @@ class ChannelBroadcaster {
     elem->filter->start_transport_op(elem, op);
   }
 
-  std::vector<grpc_channel*> channels_;
+  std::vector<RefCountedPtr<Channel>> channels_;
 };
 
 }  // namespace
@@ -505,6 +512,7 @@ const grpc_channel_filter Server::kServerTopFilter = {
     Server::CallData::DestroyCallElement,
     sizeof(Server::ChannelData),
     Server::ChannelData::InitChannelElement,
+    grpc_channel_stack_no_post_init,
     Server::ChannelData::DestroyChannelElement,
     grpc_channel_next_get_info,
     "server",
@@ -512,14 +520,13 @@ const grpc_channel_filter Server::kServerTopFilter = {
 
 namespace {
 
-RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
-    const grpc_channel_args* args) {
+RefCountedPtr<channelz::ServerNode> CreateChannelzNode(ChannelArgs args) {
   RefCountedPtr<channelz::ServerNode> channelz_node;
-  if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
-                                  GRPC_ENABLE_CHANNELZ_DEFAULT)) {
-    size_t channel_tracer_max_memory = grpc_channel_args_find_integer(
-        args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE,
-        {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX});
+  if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
+          .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
+    size_t channel_tracer_max_memory = std::max(
+        0, args.GetInt(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE)
+               .value_or(GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT));
     channelz_node =
         MakeRefCounted<channelz::ServerNode>(channel_tracer_max_memory);
     channelz_node->AddTraceEvent(
@@ -531,9 +538,8 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
 
 }  // namespace
 
-Server::Server(const grpc_channel_args* args)
-    : channel_args_(grpc_channel_args_copy(args)),
-      channelz_node_(CreateChannelzNode(args)) {}
+Server::Server(ChannelArgs args)
+    : channel_args_(args.ToC()), channelz_node_(CreateChannelzNode(args)) {}
 
 Server::~Server() {
   grpc_channel_args_destroy(channel_args_);
@@ -601,15 +607,13 @@ grpc_error_handle Server::SetupTransport(
     const grpc_channel_args* args,
     const RefCountedPtr<channelz::SocketNode>& socket_node) {
   // Create channel.
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_channel* channel = grpc_channel_create_internal(
-      nullptr, args, GRPC_SERVER_CHANNEL, transport, &error);
-  if (channel == nullptr) {
-    return error;
+  absl::StatusOr<RefCountedPtr<Channel>> channel = Channel::Create(
+      nullptr, ChannelArgs::FromC(args), GRPC_SERVER_CHANNEL, transport);
+  if (!channel.ok()) {
+    return absl_status_to_grpc_error(channel.status());
   }
   ChannelData* chand = static_cast<ChannelData*>(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
-          ->channel_data);
+      grpc_channel_stack_element((*channel)->channel_stack(), 0)->channel_data);
   // Set up CQs.
   size_t cq_idx;
   for (cq_idx = 0; cq_idx < cqs_.size(); cq_idx++) {
@@ -626,7 +630,8 @@ grpc_error_handle Server::SetupTransport(
     channelz_node_->AddChildSocket(socket_node);
   }
   // Initialize chand.
-  chand->InitTransport(Ref(), channel, cq_idx, transport, channelz_socket_uuid);
+  chand->InitTransport(Ref(), std::move(*channel), cq_idx, transport,
+                       channelz_socket_uuid);
   return GRPC_ERROR_NONE;
 }
 
@@ -702,7 +707,7 @@ void Server::FailCall(size_t cq_idx, RequestedCall* rc,
                       grpc_error_handle error) {
   *rc->call = nullptr;
   rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc,
                  &rc->completion);
 }
@@ -751,12 +756,11 @@ void Server::KillPendingWorkLocked(grpc_error_handle error) {
   GRPC_ERROR_UNREF(error);
 }
 
-std::vector<grpc_channel*> Server::GetChannelsLocked() const {
-  std::vector<grpc_channel*> channels;
+std::vector<RefCountedPtr<Channel>> Server::GetChannelsLocked() const {
+  std::vector<RefCountedPtr<Channel>> channels;
   channels.reserve(channels_.size());
   for (const ChannelData* chand : channels_) {
-    channels.push_back(chand->channel());
-    GRPC_CHANNEL_INTERNAL_REF(chand->channel(), "broadcast");
+    channels.push_back(chand->channel()->Ref());
   }
   return channels;
 }
@@ -825,8 +829,13 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
   if (await_requests != nullptr) {
     await_requests->WaitForNotification();
   }
-  // Shutdown listeners.
+  StopListening();
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
+}
+
+void Server::StopListening() {
   for (auto& listener : listeners_) {
+    if (listener.listener == nullptr) continue;
     channelz::ListenSocketNode* channelz_listen_socket_node =
         listener.listener->channelz_listen_socket_node();
     if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) {
@@ -838,7 +847,6 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
     listener.listener->SetOnDestroyDone(&listener.destroy_done);
     listener.listener.reset();
   }
-  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
 }
 
 void Server::CancelAllCalls() {
@@ -852,6 +860,15 @@ void Server::CancelAllCalls() {
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
 }
 
+void Server::SendGoaways() {
+  ChannelBroadcaster broadcaster;
+  {
+    MutexLock lock(&mu_global_);
+    broadcaster.FillChannelsLocked(GetChannelsLocked());
+  }
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
+}
+
 void Server::Orphan() {
   {
     MutexLock lock(&mu_global_);
@@ -956,13 +973,8 @@ grpc_call_error Server::RequestRegisteredCall(
 class Server::ChannelData::ConnectivityWatcher
     : public AsyncConnectivityStateWatcherInterface {
  public:
-  explicit ConnectivityWatcher(ChannelData* chand) : chand_(chand) {
-    GRPC_CHANNEL_INTERNAL_REF(chand_->channel_, "connectivity");
-  }
-
-  ~ConnectivityWatcher() override {
-    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel_, "connectivity");
-  }
+  explicit ConnectivityWatcher(ChannelData* chand)
+      : chand_(chand), channel_(chand_->channel_->Ref()) {}
 
  private:
   void OnConnectivityStateChange(grpc_connectivity_state new_state,
@@ -974,7 +986,8 @@ class Server::ChannelData::ConnectivityWatcher
     chand_->Destroy();
   }
 
-  ChannelData* chand_;
+  ChannelData* const chand_;
+  const RefCountedPtr<Channel> channel_;
 };
 
 //
@@ -999,7 +1012,8 @@ Server::ChannelData::~ChannelData() {
 }
 
 void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
-                                        grpc_channel* channel, size_t cq_idx,
+                                        RefCountedPtr<Channel> channel,
+                                        size_t cq_idx,
                                         grpc_transport* transport,
                                         intptr_t channelz_socket_uuid) {
   server_ = std::move(server);
@@ -1107,7 +1121,7 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   grpc_call_element* elem =
       grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
   auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     GRPC_ERROR_UNREF(error);
     calld->FailCallCreation();
     return;
@@ -1119,8 +1133,10 @@ void Server::ChannelData::FinishDestroy(void* arg,
                                         grpc_error_handle /*error*/) {
   auto* chand = static_cast<Server::ChannelData*>(arg);
   Server* server = chand->server_.get();
-  GRPC_CHANNEL_INTERNAL_UNREF(chand->channel_, "server");
+  auto* channel_stack = chand->channel_->channel_stack();
+  chand->channel_.reset();
   server->Unref();
+  GRPC_CHANNEL_STACK_UNREF(channel_stack, "Server::ChannelData::Destroy");
 }
 
 void Server::ChannelData::Destroy() {
@@ -1130,6 +1146,9 @@ void Server::ChannelData::Destroy() {
   list_position_.reset();
   server_->Ref().release();
   server_->MaybeFinishShutdown();
+  // Unreffed by FinishDestroy
+  GRPC_CHANNEL_STACK_REF(channel_->channel_stack(),
+                         "Server::ChannelData::Destroy");
   GRPC_CLOSURE_INIT(&finish_destroy_channel_closure_, FinishDestroy, this,
                     grpc_schedule_on_exec_ctx);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) {
@@ -1138,9 +1157,8 @@ void Server::ChannelData::Destroy() {
   grpc_transport_op* op =
       grpc_make_transport_op(&finish_destroy_channel_closure_);
   op->set_accept_stream = true;
-  grpc_channel_next_op(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel_), 0),
-      op);
+  grpc_channel_next_op(grpc_channel_stack_element(channel_->channel_stack(), 0),
+                       op);
 }
 
 grpc_error_handle Server::ChannelData::InitChannelElement(
@@ -1255,7 +1273,7 @@ void Server::CallData::PublishNewRpc(void* arg, grpc_error_handle error) {
   auto* chand = static_cast<Server::ChannelData*>(call_elem->channel_data);
   RequestMatcherInterface* rm = calld->matcher_;
   Server* server = rm->server();
-  if (error != GRPC_ERROR_NONE || server->ShutdownCalled()) {
+  if (!GRPC_ERROR_IS_NONE(error) || server->ShutdownCalled()) {
     calld->state_.store(CallState::ZOMBIED, std::memory_order_relaxed);
     calld->KillZombie();
     return;
@@ -1319,7 +1337,7 @@ void Server::CallData::RecvInitialMetadataBatchComplete(
     void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_DEBUG, "Failed call creation: %s",
             grpc_error_std_string(error).c_str());
     calld->FailCallCreation();
@@ -1354,9 +1372,11 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
                                                 grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     calld->path_ = calld->recv_initial_metadata_->Take(HttpPathMetadata());
-    calld->host_ = calld->recv_initial_metadata_->Take(HttpAuthorityMetadata());
+    auto* host =
+        calld->recv_initial_metadata_->get_pointer(HttpAuthorityMetadata());
+    if (host != nullptr) calld->host_.emplace(host->Ref());
   } else {
     (void)GRPC_ERROR_REF(error);
   }
@@ -1436,11 +1456,10 @@ void Server::CallData::StartTransportStreamOpBatch(
 grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved));
-  const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
-                                          .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args);
-  grpc_core::Server* server = new grpc_core::Server(new_args);
-  grpc_channel_args_destroy(new_args);
+  grpc_core::Server* server =
+      new grpc_core::Server(grpc_core::CoreConfiguration::Get()
+                                .channel_args_preconditioning()
+                                .PreconditionChannelArgs(args));
   return server->c_ptr();
 }