grpc 1.73.0 → 1.74.0

data/src/core/ext/upbdefs-gen/src/proto/grpc/channelz/v2/property_list.upbdefs.c

@@ -0,0 +1,135 @@
+/* This file was generated by upb_generator from the input file:
+ *
+ *     src/proto/grpc/channelz/v2/property_list.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated.
+ * NO CHECKED-IN PROTOBUF GENCODE */
+
+
+#include "upb/reflection/def.h"
+#include "src/proto/grpc/channelz/v2/property_list.upbdefs.h"
+#include "src/proto/grpc/channelz/v2/property_list.upb_minitable.h"
+
+extern _upb_DefPool_Init google_protobuf_any_proto_upbdefinit;
+extern _upb_DefPool_Init google_protobuf_empty_proto_upbdefinit;
+extern _upb_DefPool_Init google_protobuf_timestamp_proto_upbdefinit;
+extern _upb_DefPool_Init google_protobuf_duration_proto_upbdefinit;
+
+static const char descriptor[1190] = {
+    '\n', '.', 's', 'r', 'c', '/', 'p', 'r', 'o', 't', 'o', '/',
+    'g', 'r', 'p', 'c', '/', 'c', 'h', 'a', 'n', 'n', 'e', 'l',
+    'z', '/', 'v', '2', '/', 'p', 'r', 'o', 'p', 'e', 'r', 't',
+    'y', '_', 'l', 'i', 's', 't', '.', 'p', 'r', 'o', 't', 'o',
+    '\022', '\020', 'g', 'r', 'p', 'c', '.', 'c', 'h', 'a', 'n', 'n',
+    'e', 'l', 'z', '.', 'v', '2', '\032', '\031', 'g', 'o', 'o', 'g',
+    'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/',
+    'a', 'n', 'y', '.', 'p', 'r', 'o', 't', 'o', '\032', '\033', 'g',
+    'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b',
+    'u', 'f', '/', 'e', 'm', 'p', 't', 'y', '.', 'p', 'r', 'o',
+    't', 'o', '\032', '\037', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p',
+    'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 't', 'i', 'm', 'e',
+    's', 't', 'a', 'm', 'p', '.', 'p', 'r', 'o', 't', 'o', '\032',
+    '\036', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't',
+    'o', 'b', 'u', 'f', '/', 'd', 'u', 'r', 'a', 't', 'i', 'o',
+    'n', '.', 'p', 'r', 'o', 't', 'o', '\"', '\276', '\001', '\n', '\014',
+    'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'L', 'i', 's', 't',
+    '\022', 'N', '\n', '\n', 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i',
+    'e', 's', '\030', '\001', ' ', '\003', '(', '\013', '2', '.', '.', 'g',
+    'r', 'p', 'c', '.', 'c', 'h', 'a', 'n', 'n', 'e', 'l', 'z',
+    '.', 'v', '2', '.', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y',
+    'L', 'i', 's', 't', '.', 'P', 'r', 'o', 'p', 'e', 'r', 't',
+    'i', 'e', 's', 'E', 'n', 't', 'r', 'y', 'R', '\n', 'p', 'r',
+    'o', 'p', 'e', 'r', 't', 'i', 'e', 's', '\032', '^', '\n', '\017',
+    'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's', 'E', 'n',
+    't', 'r', 'y', '\022', '\020', '\n', '\003', 'k', 'e', 'y', '\030', '\001',
+    ' ', '\001', '(', '\t', 'R', '\003', 'k', 'e', 'y', '\022', '5', '\n',
+    '\005', 'v', 'a', 'l', 'u', 'e', '\030', '\002', ' ', '\001', '(', '\013',
+    '2', '\037', '.', 'g', 'r', 'p', 'c', '.', 'c', 'h', 'a', 'n',
+    'n', 'e', 'l', 'z', '.', 'v', '2', '.', 'P', 'r', 'o', 'p',
+    'e', 'r', 't', 'y', 'V', 'a', 'l', 'u', 'e', 'R', '\005', 'v',
+    'a', 'l', 'u', 'e', ':', '\002', '8', '\001', '\"', '\264', '\001', '\n',
+    '\014', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'G', 'r', 'i',
+    'd', '\022', '\030', '\n', '\007', 'c', 'o', 'l', 'u', 'm', 'n', 's',
+    '\030', '\001', ' ', '\003', '(', '\t', 'R', '\007', 'c', 'o', 'l', 'u',
+    'm', 'n', 's', '\022', '6', '\n', '\004', 'r', 'o', 'w', 's', '\030',
+    '\002', ' ', '\003', '(', '\013', '2', '\"', '.', 'g', 'r', 'p', 'c',
+    '.', 'c', 'h', 'a', 'n', 'n', 'e', 'l', 'z', '.', 'v', '2',
+    '.', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'G', 'r', 'i',
+    'd', '.', 'R', 'o', 'w', 'R', '\004', 'r', 'o', 'w', 's', '\032',
+    'R', '\n', '\003', 'R', 'o', 'w', '\022', '\024', '\n', '\005', 'l', 'a',
+    'b', 'e', 'l', '\030', '\001', ' ', '\001', '(', '\t', 'R', '\005', 'l',
+    'a', 'b', 'e', 'l', '\022', '5', '\n', '\005', 'v', 'a', 'l', 'u',
+    'e', '\030', '\002', ' ', '\003', '(', '\013', '2', '\037', '.', 'g', 'r',
+    'p', 'c', '.', 'c', 'h', 'a', 'n', 'n', 'e', 'l', 'z', '.',
+    'v', '2', '.', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'V',
+    'a', 'l', 'u', 'e', 'R', '\005', 'v', 'a', 'l', 'u', 'e', '\"',
+    '\240', '\001', '\n', '\r', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y',
+    'T', 'a', 'b', 'l', 'e', '\022', '\030', '\n', '\007', 'c', 'o', 'l',
+    'u', 'm', 'n', 's', '\030', '\001', ' ', '\003', '(', '\t', 'R', '\007',
+    'c', 'o', 'l', 'u', 'm', 'n', 's', '\022', '7', '\n', '\004', 'r',
+    'o', 'w', 's', '\030', '\002', ' ', '\003', '(', '\013', '2', '#', '.',
+    'g', 'r', 'p', 'c', '.', 'c', 'h', 'a', 'n', 'n', 'e', 'l',
+    'z', '.', 'v', '2', '.', 'P', 'r', 'o', 'p', 'e', 'r', 't',
+    'y', 'T', 'a', 'b', 'l', 'e', '.', 'R', 'o', 'w', 'R', '\004',
+    'r', 'o', 'w', 's', '\032', '<', '\n', '\003', 'R', 'o', 'w', '\022',
+    '5', '\n', '\005', 'v', 'a', 'l', 'u', 'e', '\030', '\001', ' ', '\003',
+    '(', '\013', '2', '\037', '.', 'g', 'r', 'p', 'c', '.', 'c', 'h',
+    'a', 'n', 'n', 'e', 'l', 'z', '.', 'v', '2', '.', 'P', 'r',
+    'o', 'p', 'e', 'r', 't', 'y', 'V', 'a', 'l', 'u', 'e', 'R',
+    '\005', 'v', 'a', 'l', 'u', 'e', '\"', '\305', '\003', '\n', '\r', 'P',
+    'r', 'o', 'p', 'e', 'r', 't', 'y', 'V', 'a', 'l', 'u', 'e',
+    '\022', '9', '\n', '\013', 'e', 'm', 'p', 't', 'y', '_', 'v', 'a',
+    'l', 'u', 'e', '\030', '\001', ' ', '\001', '(', '\013', '2', '\026', '.',
+    'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o',
+    'b', 'u', 'f', '.', 'E', 'm', 'p', 't', 'y', 'H', '\000', 'R',
+    '\n', 'e', 'm', 'p', 't', 'y', 'V', 'a', 'l', 'u', 'e', '\022',
+    '3', '\n', '\t', 'a', 'n', 'y', '_', 'v', 'a', 'l', 'u', 'e',
+    '\030', '\002', ' ', '\001', '(', '\013', '2', '\024', '.', 'g', 'o', 'o',
+    'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f',
+    '.', 'A', 'n', 'y', 'H', '\000', 'R', '\010', 'a', 'n', 'y', 'V',
+    'a', 'l', 'u', 'e', '\022', '#', '\n', '\014', 's', 't', 'r', 'i',
+    'n', 'g', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\003', ' ', '\001',
+    '(', '\t', 'H', '\000', 'R', '\013', 's', 't', 'r', 'i', 'n', 'g',
+    'V', 'a', 'l', 'u', 'e', '\022', '!', '\n', '\013', 'i', 'n', 't',
+    '6', '4', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\004', ' ', '\001',
+    '(', '\003', 'H', '\000', 'R', '\n', 'i', 'n', 't', '6', '4', 'V',
+    'a', 'l', 'u', 'e', '\022', '#', '\n', '\014', 'u', 'i', 'n', 't',
+    '6', '4', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\005', ' ', '\001',
+    '(', '\004', 'H', '\000', 'R', '\013', 'u', 'i', 'n', 't', '6', '4',
+    'V', 'a', 'l', 'u', 'e', '\022', '#', '\n', '\014', 'd', 'o', 'u',
+    'b', 'l', 'e', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\006', ' ',
+    '\001', '(', '\001', 'H', '\000', 'R', '\013', 'd', 'o', 'u', 'b', 'l',
+    'e', 'V', 'a', 'l', 'u', 'e', '\022', '\037', '\n', '\n', 'b', 'o',
+    'o', 'l', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\007', ' ', '\001',
+    '(', '\010', 'H', '\000', 'R', '\t', 'b', 'o', 'o', 'l', 'V', 'a',
+    'l', 'u', 'e', '\022', 'E', '\n', '\017', 't', 'i', 'm', 'e', 's',
+    't', 'a', 'm', 'p', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\010',
+    ' ', '\001', '(', '\013', '2', '\032', '.', 'g', 'o', 'o', 'g', 'l',
+    'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'T',
+    'i', 'm', 'e', 's', 't', 'a', 'm', 'p', 'H', '\000', 'R', '\016',
+    't', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', 'V', 'a', 'l',
+    'u', 'e', '\022', 'B', '\n', '\016', 'd', 'u', 'r', 'a', 't', 'i',
+    'o', 'n', '_', 'v', 'a', 'l', 'u', 'e', '\030', '\t', ' ', '\001',
+    '(', '\013', '2', '\031', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.',
+    'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'D', 'u', 'r',
+    'a', 't', 'i', 'o', 'n', 'H', '\000', 'R', '\r', 'd', 'u', 'r',
+    'a', 't', 'i', 'o', 'n', 'V', 'a', 'l', 'u', 'e', 'B', '\006',
+    '\n', '\004', 'k', 'i', 'n', 'd', 'b', '\006', 'p', 'r', 'o', 't',
+    'o', '3',
+};
+
+static _upb_DefPool_Init *deps[5] = {
+    &google_protobuf_any_proto_upbdefinit,
+    &google_protobuf_empty_proto_upbdefinit,
+    &google_protobuf_timestamp_proto_upbdefinit,
+    &google_protobuf_duration_proto_upbdefinit,
+    NULL,
+};
+
+_upb_DefPool_Init src_proto_grpc_channelz_v2_property_list_proto_upbdefinit = {
+    deps,
+    &src_proto_grpc_channelz_v2_property_list_proto_upb_file_layout,
+    "src/proto/grpc/channelz/v2/property_list.proto",
+    UPB_STRINGVIEW_INIT(descriptor, sizeof(descriptor)),
+};

data/src/core/ext/upbdefs-gen/src/proto/grpc/channelz/v2/property_list.upbdefs.h

@@ -0,0 +1,67 @@
+/* This file was generated by upb_generator from the input file:
+ *
+ *     src/proto/grpc/channelz/v2/property_list.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated.
+ * NO CHECKED-IN PROTOBUF GENCODE */
+
+
+
+#ifndef SRC_PROTO_GRPC_CHANNELZ_V2_PROPERTY_LIST_PROTO_UPB_H__UPBDEFS_H_
+#define SRC_PROTO_GRPC_CHANNELZ_V2_PROPERTY_LIST_PROTO_UPB_H__UPBDEFS_H_
+
+#include "upb/reflection/def.h"
+#include "upb/reflection/internal/def_pool.h"
+
+#include "upb/port/def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern _upb_DefPool_Init src_proto_grpc_channelz_v2_property_list_proto_upbdefinit;
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyList_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyList");
+}
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyList_PropertiesEntry_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyList.PropertiesEntry");
+}
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyGrid_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyGrid");
+}
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyGrid_Row_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyGrid.Row");
+}
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyTable_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyTable");
+}
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyTable_Row_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyTable.Row");
+}
+
+UPB_INLINE const upb_MessageDef *grpc_channelz_v2_PropertyValue_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &src_proto_grpc_channelz_v2_property_list_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "grpc.channelz.v2.PropertyValue");
+}
+
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#include "upb/port/undef.inc"
+
+#endif  /* SRC_PROTO_GRPC_CHANNELZ_V2_PROPERTY_LIST_PROTO_UPB_H__UPBDEFS_H_ */

data/src/core/filter/auth/auth_filters.h

@@ -127,31 +127,6 @@ class ClientAuthFilter final : public ImplementChannelFilter<ClientAuthFilter> {
   grpc_call_credentials::GetRequestMetadataArgs args_;
 };
 
-class LegacyClientAuthFilter final : public ChannelFilter {
- public:
-  static const grpc_channel_filter kFilter;
-
-  static absl::string_view TypeName() { return "client-auth-filter"; }
-
-  LegacyClientAuthFilter(
-      RefCountedPtr<grpc_channel_security_connector> security_connector,
-      RefCountedPtr<grpc_auth_context> auth_context);
-
-  static absl::StatusOr<std::unique_ptr<ClientAuthFilter>> Create(
-      const ChannelArgs& args, ChannelFilter::Args);
-
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
-
- private:
-  ArenaPromise<absl::StatusOr<CallArgs>> GetCallCredsMetadata(
-      CallArgs call_args);
-
-  // Contains refs to security connector and auth context.
-  grpc_call_credentials::GetRequestMetadataArgs args_;
-};
-
 class ServerAuthFilter final : public ImplementChannelFilter<ServerAuthFilter> {
  private:
   class RunApplicationCode {

data/src/core/filter/auth/client_auth_filter.cc

@@ -189,122 +189,4 @@ absl::StatusOr<std::unique_ptr<ClientAuthFilter>> ClientAuthFilter::Create(
 const grpc_channel_filter ClientAuthFilter::kFilter =
     MakePromiseBasedFilter<ClientAuthFilter, FilterEndpoint::kClient>();
 
-// LegacyClientAuthFilter
-
-LegacyClientAuthFilter::LegacyClientAuthFilter(
-    RefCountedPtr<grpc_channel_security_connector> security_connector,
-    RefCountedPtr<grpc_auth_context> auth_context)
-    : args_{std::move(security_connector), std::move(auth_context)} {}
-
-ArenaPromise<absl::StatusOr<CallArgs>>
-LegacyClientAuthFilter::GetCallCredsMetadata(CallArgs call_args) {
-  auto* ctx = GetContext<grpc_client_security_context>();
-  grpc_call_credentials* channel_call_creds =
-      args_.security_connector->mutable_request_metadata_creds();
-  const bool call_creds_has_md = (ctx != nullptr) && (ctx->creds != nullptr);
-
-  if (channel_call_creds == nullptr && !call_creds_has_md) {
-    // Skip sending metadata altogether.
-    return Immediate(absl::StatusOr<CallArgs>(std::move(call_args)));
-  }
-
-  RefCountedPtr<grpc_call_credentials> creds;
-  if (channel_call_creds != nullptr && call_creds_has_md) {
-    creds = RefCountedPtr<grpc_call_credentials>(
-        grpc_composite_call_credentials_create(channel_call_creds,
-                                               ctx->creds.get(), nullptr));
-    if (creds == nullptr) {
-      return Immediate(absl::UnauthenticatedError(
-          "Incompatible credentials set on channel and call."));
-    }
-  } else if (call_creds_has_md) {
-    creds = ctx->creds->Ref();
-  } else {
-    creds = channel_call_creds->Ref();
-  }
-
-  // Check security level of call credential and channel, and do not send
-  // metadata if the check fails.
-  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
-      args_.auth_context.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME);
-  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
-  if (prop == nullptr) {
-    return Immediate(
-        absl::UnauthenticatedError("Established channel does not have an auth "
-                                   "property representing a security level."));
-  }
-  const grpc_security_level call_cred_security_level =
-      creds->min_security_level();
-  const bool is_security_level_ok = grpc_check_security_level(
-      convert_security_level_string_to_enum(prop->value),
-      call_cred_security_level);
-  if (!is_security_level_ok) {
-    return Immediate(absl::UnauthenticatedError(
-        "Established channel does not have a sufficient security level to "
-        "transfer call credential."));
-  }
-
-  auto client_initial_metadata = std::move(call_args.client_initial_metadata);
-  return TrySeq(
-      Seq(creds->GetRequestMetadata(std::move(client_initial_metadata), &args_),
-          [](absl::StatusOr<ClientMetadataHandle> new_metadata) mutable {
-            if (!new_metadata.ok()) {
-              return absl::StatusOr<ClientMetadataHandle>(
-                  MaybeRewriteIllegalStatusCode(new_metadata.status(),
-                                                "call credentials"));
-            }
-            return new_metadata;
-          }),
-      [call_args =
-           std::move(call_args)](ClientMetadataHandle new_metadata) mutable {
-        call_args.client_initial_metadata = std::move(new_metadata);
-        return Immediate<absl::StatusOr<CallArgs>>(
-            absl::StatusOr<CallArgs>(std::move(call_args)));
-      });
-}
-
-ArenaPromise<ServerMetadataHandle> LegacyClientAuthFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  auto* sec_ctx = MaybeGetContext<grpc_client_security_context>();
-  if (sec_ctx == nullptr) {
-    sec_ctx = grpc_client_security_context_create(GetContext<Arena>(),
-                                                  /*creds=*/nullptr);
-    SetContext<SecurityContext>(sec_ctx);
-  }
-  sec_ctx->auth_context = args_.auth_context;
-
-  auto* host =
-      call_args.client_initial_metadata->get_pointer(HttpAuthorityMetadata());
-  if (host == nullptr) {
-    return next_promise_factory(std::move(call_args));
-  }
-  return TrySeq(
-      args_.security_connector->CheckCallHost(host->as_string_view(),
-                                              args_.auth_context.get()),
-      [this, call_args = std::move(call_args)]() mutable {
-        return GetCallCredsMetadata(std::move(call_args));
-      },
-      next_promise_factory);
-}
-
-absl::StatusOr<std::unique_ptr<ClientAuthFilter>>
-LegacyClientAuthFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
-  auto* sc = args.GetObject<grpc_security_connector>();
-  if (sc == nullptr) {
-    return absl::InvalidArgumentError(
-        "Security connector missing from client auth filter args");
-  }
-  auto* auth_context = args.GetObject<grpc_auth_context>();
-  if (auth_context == nullptr) {
-    return absl::InvalidArgumentError(
-        "Auth context missing from client auth filter args");
-  }
-  return std::make_unique<ClientAuthFilter>(
-      sc->RefAsSubclass<grpc_channel_security_connector>(),
-      auth_context->Ref());
-}
-
-const grpc_channel_filter LegacyClientAuthFilter::kFilter =
-    MakePromiseBasedFilter<ClientAuthFilter, FilterEndpoint::kClient>();
-
 }  // namespace grpc_core

data/src/core/filter/filter_args.h

@@ -31,23 +31,18 @@ class FilterArgs {
              grpc_channel_element* channel_element,
              size_t (*channel_stack_filter_instance_number)(
                  grpc_channel_stack*, grpc_channel_element*),
-             const Blackboard* old_blackboard = nullptr,
-             Blackboard* new_blackboard = nullptr)
+             const Blackboard* blackboard = nullptr)
       : impl_(ChannelStackBased{channel_stack, channel_element,
                                 channel_stack_filter_instance_number}),
-        old_blackboard_(old_blackboard),
-        new_blackboard_(new_blackboard) {}
+        blackboard_(blackboard) {}
   // While we're moving to call-v3 we need to have access to
   // grpc_channel_stack & friends here. That means that we can't rely on this
   // type signature from interception_chain.h, which means that we need a way
   // of constructing this object without naming it ===> implicit construction.
   // TODO(ctiller): remove this once we're fully on call-v3
   // NOLINTNEXTLINE(google-explicit-constructor)
-  FilterArgs(size_t instance_id, const Blackboard* old_blackboard = nullptr,
-             Blackboard* new_blackboard = nullptr)
-      : impl_(V3Based{instance_id}),
-        old_blackboard_(old_blackboard),
-        new_blackboard_(new_blackboard) {}
+  FilterArgs(size_t instance_id, const Blackboard* blackboard = nullptr)
+      : impl_(V3Based{instance_id}), blackboard_(blackboard) {}
 
   ABSL_DEPRECATED("Direct access to channel stack is deprecated")
   grpc_channel_stack* channel_stack() const {
@@ -71,19 +66,11 @@ class FilterArgs {
         [](const V3Based& v3) { return v3.instance_id; });
   }
 
-  // If a filter state object of type T exists for key from a previous
-  // filter stack, retains it for the new filter stack we're constructing.
-  // Otherwise, invokes create_func() to create a new filter state
-  // object for the new filter stack.  Returns the new filter state object.
+  // Gets the filter state associated with a particular type and key.
   template <typename T>
-  RefCountedPtr<T> GetOrCreateState(
-      const std::string& key,
-      absl::FunctionRef<RefCountedPtr<T>()> create_func) {
-    RefCountedPtr<T> state;
-    if (old_blackboard_ != nullptr) state = old_blackboard_->Get<T>(key);
-    if (state == nullptr) state = create_func();
-    if (new_blackboard_ != nullptr) new_blackboard_->Set(key, state);
-    return state;
+  RefCountedPtr<T> GetState(const std::string& key) const {
+    if (blackboard_ == nullptr) return nullptr;
+    return blackboard_->Get<T>(key);
   }
 
  private:
@@ -103,8 +90,7 @@ class FilterArgs {
   using Impl = std::variant<ChannelStackBased, V3Based>;
   Impl impl_;
 
-  const Blackboard* old_blackboard_ = nullptr;
-  Blackboard* new_blackboard_ = nullptr;
+  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

data/src/core/handshaker/handshaker.cc

@@ -104,6 +104,16 @@ void HandshakeManager::DoHandshake(
   args_.args = channel_args;
   args_.event_engine = args_.args.GetObject<EventEngine>();
   args_.acceptor = acceptor;
+  // Add a channelz trace that we're performing a handshake.
+  // Note that we only commit this to the log if we see an error - otherwise
+  // it's ephemeral and is cleaned up when refs to it are released.
+  auto channelz_node = args_.args.GetObjectRef<channelz::BaseNode>();
+  args_.trace_node = channelz::TraceNode(
+      channelz_node.get() == nullptr
+          ? channelz::ChannelTrace::Node()
+          : channelz_node->NewTraceNode("Handshake connection"),
+      handshaker_trace,
+      [this]() { return absl::StrFormat("handshake manager %p: ", this); });
   if (acceptor != nullptr && acceptor->external_connection &&
       acceptor->pending_data != nullptr) {
     grpc_slice_buffer_swap(args_.read_buffer.c_slice_buffer(),
@@ -125,14 +135,12 @@ void HandshakeManager::DoHandshake(
 void HandshakeManager::Shutdown(absl::Status error) {
   MutexLock lock(&mu_);
   if (!is_shutdown_) {
-    GRPC_TRACE_LOG(handshaker, INFO)
-        << "handshake_manager " << this << ": Shutdown() called: " << error;
+    GRPC_CHANNELZ_LOG(args_.trace_node) << "Shutdown called: " << error;
     is_shutdown_ = true;
     // Shutdown the handshaker that's currently in progress, if any.
     if (index_ > 0) {
-      GRPC_TRACE_LOG(handshaker, INFO)
-          << "handshake_manager " << this
-          << ": shutting down handshaker at index " << index_ - 1;
+      GRPC_CHANNELZ_LOG(args_.trace_node)
+          << "Shutting down handshaker at index " << (index_ - 1);
       handshakers_[index_ - 1]->Shutdown(std::move(error));
     }
   }
@@ -140,7 +148,7 @@ void HandshakeManager::Shutdown(absl::Status error) {
 
 void HandshakeManager::CallNextHandshakerLocked(absl::Status error) {
   GRPC_TRACE_LOG(handshaker, INFO)
-      << "handshake_manager " << this << ": error=" << error
+      << "CallNextHandshakerLocked: error=" << error
       << " shutdown=" << is_shutdown_ << " index=" << index_
       << ", args=" << HandshakerArgsString(&args_);
   CHECK(index_ <= handshakers_.size());
@@ -153,10 +161,13 @@ void HandshakeManager::CallNextHandshakerLocked(absl::Status error) {
       error = GRPC_ERROR_CREATE("handshaker shutdown");
       args_.endpoint.reset();
     }
-    GRPC_TRACE_LOG(handshaker, INFO) << "handshake_manager " << this
-                                     << ": handshaking complete -- scheduling "
-                                        "on_handshake_done with error="
-                                     << error;
+    // Since there was a handshaking error, commit this node with the reason.
+    // This will make it available for inspection after the handshaker
+    // completes.
+    if (!error.ok()) {
+      GRPC_CHANNELZ_LOG(args_.trace_node) << "Failed with error: " << error;
+    }
+    args_.trace_node.Commit();
     // Cancel deadline timer, since we're invoking the on_handshake_done
     // callback now.
     args_.event_engine->Cancel(deadline_timer_handle_);
@@ -174,10 +185,8 @@ void HandshakeManager::CallNextHandshakerLocked(absl::Status error) {
   }
   // Call the next handshaker.
   auto handshaker = handshakers_[index_];
-  GRPC_TRACE_LOG(handshaker, INFO)
-      << "handshake_manager " << this << ": calling handshaker "
-      << handshaker->name() << " [" << handshaker.get() << "] at index "
-      << index_;
+  GRPC_CHANNELZ_LOG(args_.trace_node)
+      << " calling handshaker " << handshaker->name() << " at index " << index_;
   ++index_;
   handshaker->DoHandshake(&args_, [self = Ref()](absl::Status error) mutable {
     MutexLock lock(&self->mu_);

data/src/core/handshaker/handshaker.h

@@ -28,6 +28,7 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/inlined_vector.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -78,6 +79,8 @@ struct HandshakerArgs {
   // TODO(roth): Make this go away somehow as part of the EventEngine
   // migration?
   grpc_tcp_server_acceptor* acceptor = nullptr;
+  // Channelz trace node for the current handshaker
+  channelz::TraceNode trace_node;
 };
 
 ///

data/src/core/handshaker/http_connect/http_connect_handshaker.cc

@@ -318,12 +318,14 @@ void HttpConnectHandshaker::DoHandshake(
   gpr_free(header_strings);
   // Take a new ref to be held by the write callback.
   Ref().release();
+  grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs write_args;
+  write_args.set_max_frame_size(INT_MAX);
   grpc_endpoint_write(
       args->endpoint.get(), write_buffer_.c_slice_buffer(),
       GRPC_CLOSURE_INIT(&on_write_done_scheduler_,
                         &HttpConnectHandshaker::OnWriteDoneScheduler, this,
                         grpc_schedule_on_exec_ctx),
-      nullptr, /*max_frame_size=*/INT_MAX);
+      std::move(write_args));
 }
 
 HttpConnectHandshaker::HttpConnectHandshaker() {

data/src/core/handshaker/security/legacy_secure_endpoint.cc

@@ -397,8 +397,9 @@ static void on_write(void* user_data, grpc_error_handle error) {
   });
 }
 
-static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
-                           grpc_closure* cb, void* arg, int max_frame_size) {
+static void endpoint_write(
+    grpc_endpoint* secure_ep, grpc_slice_buffer* slices, grpc_closure* cb,
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args) {
   GRPC_LATENT_SEE_INNER_SCOPE("secure_endpoint write");
   unsigned i;
   tsi_result result = TSI_OK;
@@ -427,10 +428,10 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
       // tsi_zero_copy_grpc_protector_protect on each chunk. This ensures that
       // the protector cannot create frames larger than the specified
       // max_frame_size.
-      while (slices->length > static_cast<size_t>(max_frame_size) &&
+      while (slices->length > static_cast<size_t>(args.max_frame_size()) &&
              result == TSI_OK) {
         grpc_slice_buffer_move_first(slices,
-                                     static_cast<size_t>(max_frame_size),
+                                     static_cast<size_t>(args.max_frame_size()),
                                      &ep->protector_staging_buffer);
         result = tsi_zero_copy_grpc_protector_protect(
             ep->zero_copy_protector, &ep->protector_staging_buffer,
@@ -523,7 +524,7 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
   SECURE_ENDPOINT_REF(ep, "write");
   ep->write_cb = cb;
   grpc_endpoint_write(ep->wrapped_ep.get(), &ep->output_buffer, &ep->on_write,
-                      arg, max_frame_size);
+                      std::move(args));
 }
 
 static void endpoint_destroy(grpc_endpoint* secure_ep) {