grpc 1.64.0 → 1.65.0.pre1

data/src/core/lib/address_utils/parse_address.cc

@@ -18,8 +18,6 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 
-#include "absl/log/check.h"
-
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
@@ -43,18 +41,18 @@
 #endif  // GRPC_HAVE_UNIX_SOCKET
 #include <string>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/grpc_if_nametoindex.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
+#include "src/core/util/string.h"
 
 // IWYU pragma: no_include <arpa/inet.h>
 
@@ -63,14 +61,13 @@
 bool grpc_parse_unix(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "unix") {
-    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'unix' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   grpc_error_handle error =
       grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
   if (!error.ok()) {
-    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "" << grpc_core::StatusToString(error);
     return false;
   }
   return true;
@@ -79,14 +76,14 @@ bool grpc_parse_unix(const grpc_core::URI& uri,
 bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
                               grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "unix-abstract") {
-    gpr_log(GPR_ERROR, "Expected 'unix-abstract' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'unix-abstract' scheme, got '" << uri.scheme()
+               << "'";
     return false;
   }
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
   if (!error.ok()) {
-    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "" << grpc_core::StatusToString(error);
     return false;
   }
   return true;
@@ -163,14 +160,13 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
 bool grpc_parse_vsock(const grpc_core::URI& uri,
                       grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "vsock") {
-    gpr_log(GPR_ERROR, "Expected 'vsock' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'vsock' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   grpc_error_handle error =
       grpc_core::VSockaddrPopulate(uri.path(), resolved_addr);
   if (!error.ok()) {
-    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "" << grpc_core::StatusToString(error);
     return false;
   }
   return true;
@@ -220,8 +216,7 @@ bool grpc_parse_ipv4_hostport(absl::string_view hostport,
   std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)",
-              std::string(hostport).c_str());
+      LOG(ERROR) << "Failed gpr_split_host_port(" << hostport << ", ...)";
     }
     return false;
   }
@@ -232,19 +227,19 @@ bool grpc_parse_ipv4_hostport(absl::string_view hostport,
   in->sin_family = GRPC_AF_INET;
   if (grpc_inet_pton(GRPC_AF_INET, host.c_str(), &in->sin_addr) == 0) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.c_str());
+      LOG(ERROR) << "invalid ipv4 address: '" << host << "'";
     }
     goto done;
   }
   // Parse port.
   if (port.empty()) {
-    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
+    if (log_errors) LOG(ERROR) << "no port given for ipv4 scheme";
     goto done;
   }
   int port_num;
   if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
       port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.c_str());
+    if (log_errors) LOG(ERROR) << "invalid ipv4 port: '" << port << "'";
     goto done;
   }
   in->sin_port = grpc_htons(static_cast<uint16_t>(port_num));
@@ -256,8 +251,7 @@ done:
 bool grpc_parse_ipv4(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "ipv4") {
-    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'ipv4' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   return grpc_parse_ipv4_hostport(absl::StripPrefix(uri.path(), "/"),
@@ -272,8 +266,7 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
   std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)",
-              std::string(hostport).c_str());
+      LOG(ERROR) << "Failed gpr_split_host_port(" << hostport << ", ...)";
     }
     return false;
   }
@@ -293,11 +286,9 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
     uint32_t sin6_scope_id = 0;
     if (host_without_scope_len > GRPC_INET6_ADDRSTRLEN) {
       if (log_errors) {
-        gpr_log(
-            GPR_ERROR,
-            "invalid ipv6 address length %zu. Length cannot be greater than "
-            "GRPC_INET6_ADDRSTRLEN i.e %d)",
-            host_without_scope_len, GRPC_INET6_ADDRSTRLEN);
+        LOG(ERROR) << "invalid ipv6 address length " << host_without_scope_len
+                   << ". Length cannot be greater than "
+                   << "GRPC_INET6_ADDRSTRLEN i.e " << GRPC_INET6_ADDRSTRLEN;
       }
       goto done;
     }
@@ -306,7 +297,7 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
     if (grpc_inet_pton(GRPC_AF_INET6, host_without_scope, &in6->sin6_addr) ==
         0) {
       if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host_without_scope);
+        LOG(ERROR) << "invalid ipv6 address: '" << host_without_scope << "'";
       }
       goto done;
     }
@@ -314,10 +305,8 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
                                   host.size() - host_without_scope_len - 1,
                                   &sin6_scope_id) == 0) {
       if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) {
-        gpr_log(GPR_ERROR,
-                "Invalid interface name: '%s'. "
-                "Non-numeric and failed if_nametoindex.",
-                host_end + 1);
+        LOG(ERROR) << "Invalid interface name: '" << host_end + 1
+                   << "'. Non-numeric and failed if_nametoindex.";
         goto done;
       }
     }
@@ -326,20 +315,20 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
   } else {
     if (grpc_inet_pton(GRPC_AF_INET6, host.c_str(), &in6->sin6_addr) == 0) {
       if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.c_str());
+        LOG(ERROR) << "invalid ipv6 address: '" << host << "'";
       }
       goto done;
     }
   }
   // Parse port.
   if (port.empty()) {
-    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
+    if (log_errors) LOG(ERROR) << "no port given for ipv6 scheme";
     goto done;
   }
   int port_num;
   if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
       port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.c_str());
+    if (log_errors) LOG(ERROR) << "invalid ipv6 port: '" << port << "'";
     goto done;
   }
   in6->sin6_port = grpc_htons(static_cast<uint16_t>(port_num));
@@ -351,8 +340,7 @@ done:
 bool grpc_parse_ipv6(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   if (uri.scheme() != "ipv6") {
-    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'",
-            uri.scheme().c_str());
+    LOG(ERROR) << "Expected 'ipv6' scheme, got '" << uri.scheme() << "'";
     return false;
   }
   return grpc_parse_ipv6_hostport(absl::StripPrefix(uri.path(), "/"),
@@ -376,7 +364,7 @@ bool grpc_parse_uri(const grpc_core::URI& uri,
   if (uri.scheme() == "ipv6") {
     return grpc_parse_ipv6(uri, resolved_addr);
   }
-  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri.scheme().c_str());
+  LOG(ERROR) << "Can't parse scheme '" << uri.scheme() << "'";
   return false;
 }
 

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -32,12 +32,11 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/port.h"
@@ -372,8 +371,8 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
       return 1;
 #endif
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in grpc_sockaddr_get_port";
       return 0;
   }
 }
@@ -394,8 +393,8 @@ int grpc_sockaddr_set_port(grpc_resolved_address* resolved_addr, int port) {
           grpc_htons(static_cast<uint16_t>(port));
       return 1;
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in grpc_sockaddr_set_port";
       return 0;
   }
 }

data/src/core/lib/avl/avl.h

@@ -23,9 +23,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/lib/channel/channel_args.cc

@@ -29,6 +29,7 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -36,11 +37,10 @@
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 
@@ -264,8 +264,7 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   if (v == nullptr) return absl::nullopt;
   auto i = v->GetIfInt();
   if (!i.has_value()) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
-            std::string(name).c_str());
+    LOG(ERROR) << name << " ignored: it must be an integer";
     return absl::nullopt;
   }
   switch (*i) {
@@ -274,8 +273,8 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
     case 1:
       return true;
     default:
-      gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
-              std::string(name).c_str(), *i);
+      LOG(ERROR) << name << " treated as bool but set to " << *i
+                 << " (assuming true)";
       return true;
   }
 }
@@ -557,17 +556,15 @@ int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options) {
   if (arg == nullptr) return options.default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
+    LOG(ERROR) << arg->key << " ignored: it must be an integer";
     return options.default_value;
   }
   if (arg->value.integer < options.min_value) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be >= %d", arg->key,
-            options.min_value);
+    LOG(ERROR) << arg->key << " ignored: it must be >= " << options.min_value;
     return options.default_value;
   }
   if (arg->value.integer > options.max_value) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be <= %d", arg->key,
-            options.max_value);
+    LOG(ERROR) << arg->key << " ignored: it must be <= " << options.max_value;
     return options.default_value;
   }
   return arg->value.integer;
@@ -583,7 +580,7 @@ int grpc_channel_args_find_integer(const grpc_channel_args* args,
 char* grpc_channel_arg_get_string(const grpc_arg* arg) {
   if (arg == nullptr) return nullptr;
   if (arg->type != GRPC_ARG_STRING) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an string", arg->key);
+    LOG(ERROR) << arg->key << " ignored: it must be an string";
     return nullptr;
   }
   return arg->value.string;
@@ -598,7 +595,7 @@ char* grpc_channel_args_find_string(const grpc_channel_args* args,
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
   if (arg == nullptr) return default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
+    LOG(ERROR) << arg->key << " ignored: it must be an integer";
     return default_value;
   }
   switch (arg->value.integer) {
@@ -607,8 +604,8 @@ bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
     case 1:
       return true;
     default:
-      gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
-              arg->key, arg->value.integer);
+      LOG(ERROR) << arg->key << " treated as bool but set to "
+                 << arg->value.integer << " (assuming true)";
       return true;
   }
 }
@@ -667,8 +664,7 @@ ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
     if (key == GRPC_ARG_PRIMARY_USER_AGENT_STRING ||
         key == GRPC_ARG_SECONDARY_USER_AGENT_STRING) {
       if (src->args[i].type != GRPC_ARG_STRING) {
-        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
-                std::string(key).c_str());
+        LOG(ERROR) << "Channel argument '" << key << "' should be a string";
       } else {
         concatenated_values[key].push_back(src->args[i].value.string);
       }

data/src/core/lib/channel/channel_args.h

@@ -38,7 +38,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/avl/avl.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -46,6 +45,7 @@
 #include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/util/useful.h"
 
 // TODO(hork): When we're ready to allow setting via a channel arg from the
 // application, replace this with a macro in
@@ -83,6 +83,16 @@ inline int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
 // before the crt refcount base class.
 template <typename T>
 using RefType = absl::remove_cvref_t<decltype(*std::declval<T>().Ref())>;
+
+template <typename T, typename Ignored = void /* for SFINAE */>
+struct IsRawPointerTagged {
+  static constexpr bool kValue = false;
+};
+template <typename T>
+struct IsRawPointerTagged<T,
+                          absl::void_t<typename T::RawPointerChannelArgTag>> {
+  static constexpr bool kValue = true;
+};
 }  // namespace channel_args_detail
 
 // Specialization for ref-counted pointers.
@@ -91,13 +101,14 @@ using RefType = absl::remove_cvref_t<decltype(*std::declval<T>().Ref())>;
 template <typename T>
 struct ChannelArgTypeTraits<
     T, absl::enable_if_t<
-           std::is_base_of<RefCounted<channel_args_detail::RefType<T>>,
-                           channel_args_detail::RefType<T>>::value ||
-               std::is_base_of<RefCounted<channel_args_detail::RefType<T>,
-                                          NonPolymorphicRefCount>,
-                               channel_args_detail::RefType<T>>::value ||
-               std::is_base_of<DualRefCounted<channel_args_detail::RefType<T>>,
-                               channel_args_detail::RefType<T>>::value,
+           !channel_args_detail::IsRawPointerTagged<T>::kValue &&
+               (std::is_base_of<RefCounted<channel_args_detail::RefType<T>>,
+                                channel_args_detail::RefType<T>>::value ||
+                std::is_base_of<RefCounted<channel_args_detail::RefType<T>,
+                                           NonPolymorphicRefCount>,
+                                channel_args_detail::RefType<T>>::value ||
+                std::is_base_of<DualRefCounted<channel_args_detail::RefType<T>>,
+                                channel_args_detail::RefType<T>>::value),
            void>> {
   static const grpc_arg_pointer_vtable* VTable() {
     static const grpc_arg_pointer_vtable tbl = {

data/src/core/lib/channel/channel_stack.cc

@@ -24,20 +24,18 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
-#include "src/core/lib/channel/channel_stack_trace.h"
-#include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/surface/channel_init.h"
+#include "src/core/util/alloc.h"
 
 using grpc_event_engine::experimental::EventEngine;
 
-grpc_core::TraceFlag grpc_trace_channel(false, "channel");
-
 static int register_get_name_fn = []() {
   grpc_core::NameFromChannelFilter = [](const grpc_channel_filter* filter) {
     return filter->name;
@@ -120,11 +118,10 @@ grpc_error_handle grpc_channel_stack_init(
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_core::ChannelArgs& channel_args, const char* name,
     grpc_channel_stack* stack) {
-  if (grpc_trace_channel_stack.enabled()) {
-    gpr_log(GPR_INFO, "CHANNEL_STACK: init %s", name);
+  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
+    LOG(INFO) << "CHANNEL_STACK: init " << name;
     for (size_t i = 0; i < filter_count; i++) {
-      gpr_log(GPR_INFO, "CHANNEL_STACK:   filter %s%s", filters[i]->name,
-              filters[i]->make_call_promise ? " [promise-capable]" : "");
+      LOG(INFO) << "CHANNEL_STACK:   filter " << filters[i]->name;
     }
   }
 
@@ -296,61 +293,6 @@ grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
 void grpc_channel_stack_no_post_init(grpc_channel_stack*,
                                      grpc_channel_element*) {}
 
-namespace {
-
-grpc_core::NextPromiseFactory ClientNext(grpc_channel_element* elem) {
-  return [elem](grpc_core::CallArgs args) {
-    return elem->filter->make_call_promise(elem, std::move(args),
-                                           ClientNext(elem + 1));
-  };
-}
-
-grpc_core::NextPromiseFactory ServerNext(grpc_channel_element* elem) {
-  return [elem](grpc_core::CallArgs args) {
-    return elem->filter->make_call_promise(elem, std::move(args),
-                                           ServerNext(elem - 1));
-  };
-}
-
-}  // namespace
-
-grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-grpc_channel_stack::MakeClientCallPromise(grpc_core::CallArgs call_args) {
-  return ClientNext(grpc_channel_stack_element(this, 0))(std::move(call_args));
-}
-
-grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-grpc_channel_stack::MakeServerCallPromise(grpc_core::CallArgs call_args) {
-  return ServerNext(grpc_channel_stack_element(this, this->count - 1))(
-      std::move(call_args));
-}
-
-void grpc_channel_stack::InitClientCallSpine(
-    grpc_core::CallSpineInterface* call) {
-  for (size_t i = 0; i < count; i++) {
-    auto* elem = grpc_channel_stack_element(this, i);
-    if (elem->filter->init_call == nullptr) {
-      grpc_core::Crash(
-          absl::StrCat("Filter '", elem->filter->name,
-                       "' does not support the call-v3 interface"));
-    }
-    elem->filter->init_call(elem, call);
-  }
-}
-
-void grpc_channel_stack::InitServerCallSpine(
-    grpc_core::CallSpineInterface* call) {
-  for (size_t i = 0; i < count; i++) {
-    auto* elem = grpc_channel_stack_element(this, count - 1 - i);
-    if (elem->filter->init_call == nullptr) {
-      grpc_core::Crash(
-          absl::StrCat("Filter '", elem->filter->name,
-                       "' does not support the call-v3 interface"));
-    }
-    elem->filter->init_call(elem, call);
-  }
-}
-
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {

data/src/core/lib/channel/channel_stack.h

@@ -59,10 +59,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
-#include "src/core/lib/channel/context.h"
-#include "src/core/lib/channel/metrics.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
@@ -74,6 +71,8 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/metrics.h"
+#include "src/core/util/time_precise.h"
 
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
@@ -84,7 +83,6 @@ struct grpc_channel_element_args {
 struct grpc_call_element_args {
   grpc_call_stack* call_stack;
   const void* server_transport_data;
-  grpc_call_context_element* context;
   const grpc_slice& path;
   gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
   grpc_core::Timestamp deadline;
@@ -107,24 +105,6 @@ struct grpc_channel_filter {
   // See grpc_call_next_op on how to call the next element in the stack
   void (*start_transport_stream_op_batch)(grpc_call_element* elem,
                                           grpc_transport_stream_op_batch* op);
-  // Create a promise to execute one call.
-  // If this is non-null, it may be used in preference to
-  // start_transport_stream_op_batch.
-  // If this is used in preference to start_transport_stream_op_batch, the
-  // following can be omitted also:
-  //   - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
-  //   - allocation of memory for call data
-  // There is an on-going migration to move all filters to providing this, and
-  // then to drop start_transport_stream_op_batch.
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
-      grpc_channel_element* elem, grpc_core::CallArgs call_args,
-      grpc_core::NextPromiseFactory next_promise_factory);
-  // Register interceptors into a call.
-  // If this is non-null it may be used in preference to make_call_promise.
-  // There is an on-going migration to move all filters to providing this, and
-  // then to drop start_transport_stream_op_batch.
-  void (*init_call)(grpc_channel_element* elem,
-                    grpc_core::CallSpineInterface* call_spine);
   // Called to handle channel level operations - e.g. new calls, or transport
   // closure.
   // See grpc_channel_next_op on how to call the next element in the stack
@@ -230,18 +210,11 @@ struct grpc_channel_stack {
   // full C++-ification for now.
   void IncrementRefCount();
   void Unref();
+  void Unref(const grpc_core::DebugLocation& location, const char* reason);
   grpc_core::RefCountedPtr<grpc_channel_stack> Ref() {
     IncrementRefCount();
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
-
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-  MakeClientCallPromise(grpc_core::CallArgs call_args);
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-  MakeServerCallPromise(grpc_core::CallArgs call_args);
-
-  void InitClientCallSpine(grpc_core::CallSpineInterface* call);
-  void InitServerCallSpine(grpc_core::CallSpineInterface* call);
 };
 
 // A call stack tracks a set of related filters for one call, and guarantees
@@ -346,6 +319,11 @@ inline void grpc_channel_stack::Unref() {
   GRPC_CHANNEL_STACK_UNREF(this, "smart_pointer");
 }
 
+inline void grpc_channel_stack::Unref(const grpc_core::DebugLocation&,
+                                      const char* reason) {
+  GRPC_CHANNEL_STACK_UNREF(this, reason);
+}
+
 inline void grpc_call_stack::IncrementRefCount() {
   GRPC_CALL_STACK_REF(this, "smart_pointer");
 }
@@ -386,13 +364,11 @@ void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
 void grpc_channel_stack_no_post_init(grpc_channel_stack* stk,
                                      grpc_channel_element* elem);
 
-extern grpc_core::TraceFlag grpc_trace_channel;
-
-#define GRPC_CALL_LOG_OP(sev, elem, op)                \
-  do {                                                 \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_channel)) { \
-      grpc_call_log_op(sev, elem, op);                 \
-    }                                                  \
+#define GRPC_CALL_LOG_OP(sev, elem, op)     \
+  do {                                      \
+    if (GRPC_TRACE_FLAG_ENABLED(channel)) { \
+      grpc_call_log_op(sev, elem, op);      \
+    }                                       \
   } while (0)
 
 #endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_H

data/src/core/lib/channel/channel_stack_builder.h

@@ -74,11 +74,6 @@ class ChannelStackBuilder {
   // Helper to add a filter to the end of the stack.
   void AppendFilter(const grpc_channel_filter* filter);
 
-  // Determine whether a promise-based call stack is able to be built.
-  // Iterates each filter and ensures that there's a promise factory there.
-  // This will go away once the promise conversion is completed.
-  virtual bool IsPromising() const = 0;
-
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,