grpc 1.63.0 → 1.65.2

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/channel/channel_args.h"
 
 #include <limits.h>
@@ -30,6 +28,8 @@
 #include <string>
 #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"
@@ -37,10 +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;
   }
 }
@@ -428,7 +427,7 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
   for (size_t i = 0; i < num_to_add; ++i) {
     dst->args[dst_idx++] = copy_arg(&to_add[i]);
   }
-  GPR_ASSERT(dst_idx == dst->num_args);
+  CHECK(dst_idx == dst->num_args);
   return dst;
 }
 
@@ -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);
       }
@@ -700,7 +696,7 @@ grpc_channel_args_client_channel_creation_mutator g_mutator = nullptr;
 
 void grpc_channel_args_set_client_channel_creation_mutator(
     grpc_channel_args_client_channel_creation_mutator cb) {
-  GPR_DEBUG_ASSERT(g_mutator == nullptr);
+  DCHECK_EQ(g_mutator, nullptr);
   g_mutator = cb;
 }
 grpc_channel_args_client_channel_creation_mutator

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H
 #define GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -37,9 +35,9 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
+#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"
@@ -47,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
@@ -84,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.
@@ -92,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_args_preconditioning.cc

@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 void ChannelArgsPreconditioning::Builder::RegisterStage(Stage stage) {

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

@@ -15,12 +15,11 @@
 #ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H
 #define GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <vector>
 
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/channel/channel_stack.h"
 
 #include <stdint.h>
@@ -25,18 +23,19 @@
 #include <memory>
 #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;
@@ -68,8 +67,8 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                                sizeof(grpc_channel_element));
   size_t i;
 
-  GPR_ASSERT((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0 &&
-             "GPR_MAX_ALIGNMENT must be a power of two");
+  CHECK((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0)
+      << "GPR_MAX_ALIGNMENT must be a power of two";
 
   // add the size for each filter
   for (i = 0; i < filter_count; i++) {
@@ -119,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;
     }
   }
 
@@ -168,9 +166,9 @@ grpc_error_handle grpc_channel_stack_init(
     call_size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
   }
 
-  GPR_ASSERT(user_data > (char*)stack);
-  GPR_ASSERT((uintptr_t)(user_data - (char*)stack) ==
-             grpc_channel_stack_size(filters, filter_count));
+  CHECK(user_data > (char*)stack);
+  CHECK((uintptr_t)(user_data - (char*)stack) ==
+        grpc_channel_stack_size(filters, filter_count));
 
   stack->call_stack_size = call_size;
   return first_error;
@@ -295,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

@@ -44,8 +44,6 @@
 // it can have an effect on the call status.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <functional>
@@ -56,14 +54,12 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #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"
@@ -75,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;
@@ -85,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;
@@ -108,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
@@ -231,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
@@ -347,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");
 }
@@ -387,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.cc

@@ -16,12 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/channel/channel_stack_builder.h"
 
 #include <algorithm>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 
 namespace grpc_core {

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

@@ -15,14 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H
 #define GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 #include <vector>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.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/gprpp/ref_counted_ptr.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,