grpc 1.48.0 → 1.49.1

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -59,14 +59,6 @@
 
 // IWYU pragma: no_include <type_traits>
 
-#if __cplusplus > 201103L
-#define GRPC_HPACK_CONSTEXPR_FN constexpr
-#define GRPC_HPACK_CONSTEXPR_VALUE constexpr
-#else
-#define GRPC_HPACK_CONSTEXPR_FN
-#define GRPC_HPACK_CONSTEXPR_VALUE const
-#endif
-
 namespace grpc_core {
 
 TraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
@@ -454,7 +446,7 @@ constexpr char kBase64Alphabet[] =
 // any complicated runtime logic.
 struct Base64InverseTable {
   uint8_t table[256]{};
-  GRPC_HPACK_CONSTEXPR_FN Base64InverseTable() {
+  constexpr Base64InverseTable() {
     for (int i = 0; i < 256; i++) {
       table[i] = 255;
     }
@@ -466,7 +458,7 @@ struct Base64InverseTable {
   }
 };
 
-GRPC_HPACK_CONSTEXPR_VALUE Base64InverseTable kBase64InverseTable;
+constexpr Base64InverseTable kBase64InverseTable;
 }  // namespace
 
 // Input tracks the current byte through the input data and provides it

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -44,6 +44,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/stream_map.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/bitset.h"
@@ -236,7 +237,7 @@ typedef enum {
 } grpc_chttp2_keepalive_state;
 
 struct grpc_chttp2_transport {
-  grpc_chttp2_transport(const grpc_channel_args* channel_args,
+  grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
                         grpc_endpoint* ep, bool is_client);
   ~grpc_chttp2_transport();
 

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -46,7 +46,6 @@
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.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/time.h"
@@ -84,8 +83,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error);
 void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                   bool is_initial);
 void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
-                      uint32_t flags, grpc_metadata_batch* out_md,
-                      uint32_t* outflags, bool* markfilled);
+                      grpc_metadata_batch* out_md, bool* markfilled);
 
 void ResetSendMessage(grpc_transport_stream_op_batch* batch) {
   absl::exchange(batch->payload->send_message.send_message, nullptr)->Clear();
@@ -195,18 +193,15 @@ struct inproc_stream {
       // Now transfer from the other side's write_buffer if any to the to_read
       // buffer
       if (cs->write_buffer_initial_md_filled) {
-        (void)fill_in_metadata(this, &cs->write_buffer_initial_md,
-                               cs->write_buffer_initial_md_flags,
-                               &to_read_initial_md, &to_read_initial_md_flags,
-                               &to_read_initial_md_filled);
+        fill_in_metadata(this, &cs->write_buffer_initial_md,
+                         &to_read_initial_md, &to_read_initial_md_filled);
         deadline = std::min(deadline, cs->write_buffer_deadline);
         cs->write_buffer_initial_md.Clear();
         cs->write_buffer_initial_md_filled = false;
       }
       if (cs->write_buffer_trailing_md_filled) {
-        (void)fill_in_metadata(this, &cs->write_buffer_trailing_md, 0,
-                               &to_read_trailing_md, nullptr,
-                               &to_read_trailing_md_filled);
+        fill_in_metadata(this, &cs->write_buffer_trailing_md,
+                         &to_read_trailing_md, &to_read_trailing_md_filled);
         cs->write_buffer_trailing_md.Clear();
         cs->write_buffer_trailing_md_filled = false;
       }
@@ -252,7 +247,6 @@ struct inproc_stream {
   grpc_core::Arena* arena;
 
   grpc_metadata_batch to_read_initial_md{arena};
-  uint32_t to_read_initial_md_flags = 0;
   bool to_read_initial_md_filled = false;
   grpc_metadata_batch to_read_trailing_md{arena};
   bool to_read_trailing_md_filled = false;
@@ -261,7 +255,6 @@ struct inproc_stream {
   // stream is set up but server side stream is not yet set up
   grpc_metadata_batch write_buffer_initial_md{arena};
   bool write_buffer_initial_md_filled = false;
-  uint32_t write_buffer_initial_md_flags = 0;
   grpc_core::Timestamp write_buffer_deadline =
       grpc_core::Timestamp::InfFuture();
   grpc_metadata_batch write_buffer_trailing_md{arena};
@@ -337,15 +330,12 @@ class CopySink {
 }  // namespace
 
 void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
-                      uint32_t flags, grpc_metadata_batch* out_md,
-                      uint32_t* outflags, bool* markfilled) {
+                      grpc_metadata_batch* out_md, bool* markfilled) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
-    log_metadata(metadata, s->t->is_client, outflags != nullptr);
+    log_metadata(metadata, s->t->is_client,
+                 metadata->get_pointer(grpc_core::WaitForReady()) != nullptr);
   }
 
-  if (outflags != nullptr) {
-    *outflags = flags;
-  }
   if (markfilled != nullptr) {
     *markfilled = true;
   }
@@ -454,7 +444,7 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    (void)fill_in_metadata(s, &fake_md, 0, dest, nullptr, destfilled);
+    fill_in_metadata(s, &fake_md, dest, destfilled);
 
     if (other != nullptr) {
       if (GRPC_ERROR_IS_NONE(other->cancel_other_error)) {
@@ -476,12 +466,10 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
       fake_md.Set(grpc_core::HttpAuthorityMetadata(),
                   grpc_core::Slice::FromStaticString("inproc-fail"));
 
-      (void)fill_in_metadata(
-          s, &fake_md, 0,
-          s->recv_initial_md_op->payload->recv_initial_metadata
-              .recv_initial_metadata,
-          s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
-          nullptr);
+      fill_in_metadata(s, &fake_md,
+                       s->recv_initial_md_op->payload->recv_initial_metadata
+                           .recv_initial_metadata,
+                       nullptr);
       err = GRPC_ERROR_NONE;
     } else {
       err = GRPC_ERROR_REF(error);
@@ -655,11 +643,10 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
       goto done;
     } else {
       if (!other || !other->closed) {
-        (void)fill_in_metadata(
-            s,
-            s->send_trailing_md_op->payload->send_trailing_metadata
-                .send_trailing_metadata,
-            0, dest, nullptr, destfilled);
+        fill_in_metadata(s,
+                         s->send_trailing_md_op->payload->send_trailing_metadata
+                             .send_trailing_metadata,
+                         dest, destfilled);
       }
       s->trailing_md_sent = true;
       if (s->send_trailing_md_op->payload->send_trailing_metadata.sent) {
@@ -703,12 +690,10 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
 
     if (s->to_read_initial_md_filled) {
       s->initial_md_recvd = true;
-      fill_in_metadata(
-          s, &s->to_read_initial_md, s->to_read_initial_md_flags,
-          s->recv_initial_md_op->payload->recv_initial_metadata
-              .recv_initial_metadata,
-          s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
-          nullptr);
+      fill_in_metadata(s, &s->to_read_initial_md,
+                       s->recv_initial_md_op->payload->recv_initial_metadata
+                           .recv_initial_metadata,
+                       nullptr);
       if (s->deadline != grpc_core::Timestamp::InfFuture()) {
         s->recv_initial_md_op->payload->recv_initial_metadata
             .recv_initial_metadata->Set(grpc_core::GrpcTimeoutMetadata(),
@@ -788,10 +773,10 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     if (s->recv_trailing_md_op != nullptr) {
       // We wanted trailing metadata and we got it
       s->trailing_md_recvd = true;
-      fill_in_metadata(s, &s->to_read_trailing_md, 0,
+      fill_in_metadata(s, &s->to_read_trailing_md,
                        s->recv_trailing_md_op->payload->recv_trailing_metadata
                            .recv_trailing_metadata,
-                       nullptr, nullptr);
+                       nullptr);
       s->to_read_trailing_md.Clear();
       s->to_read_trailing_md_filled = false;
 
@@ -902,7 +887,7 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    (void)fill_in_metadata(s, &cancel_md, 0, dest, nullptr, destfilled);
+    fill_in_metadata(s, &cancel_md, dest, destfilled);
 
     if (other != nullptr) {
       if (GRPC_ERROR_IS_NONE(other->cancel_other_error)) {
@@ -996,9 +981,6 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
       grpc_metadata_batch* dest = (other == nullptr)
                                       ? &s->write_buffer_initial_md
                                       : &other->to_read_initial_md;
-      uint32_t* destflags = (other == nullptr)
-                                ? &s->write_buffer_initial_md_flags
-                                : &other->to_read_initial_md_flags;
       bool* destfilled = (other == nullptr) ? &s->write_buffer_initial_md_filled
                                             : &other->to_read_initial_md_filled;
       if (*destfilled || s->initial_md_sent) {
@@ -1007,10 +989,9 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Extra initial metadata");
       } else {
         if (!s->other_side_closed) {
-          (void)fill_in_metadata(
-              s, op->payload->send_initial_metadata.send_initial_metadata,
-              op->payload->send_initial_metadata.send_initial_metadata_flags,
-              dest, destflags, destfilled);
+          fill_in_metadata(
+              s, op->payload->send_initial_metadata.send_initial_metadata, dest,
+              destfilled);
         }
         if (s->t->is_client) {
           grpc_core::Timestamp* dl =
@@ -1228,9 +1209,7 @@ const grpc_transport_vtable inproc_vtable = {
  * Main inproc transport functions
  */
 void inproc_transports_create(grpc_transport** server_transport,
-                              const grpc_channel_args* /*server_args*/,
-                              grpc_transport** client_transport,
-                              const grpc_channel_args* /*client_args*/) {
+                              grpc_transport** client_transport) {
   INPROC_LOG(GPR_INFO, "inproc_transports_create");
   shared_mu* mu = new (gpr_malloc(sizeof(*mu))) shared_mu();
   inproc_transport* st = new (gpr_malloc(sizeof(*st)))
@@ -1255,26 +1234,20 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   grpc_core::Server* core_server = grpc_core::Server::FromC(server);
   // Remove max_connection_idle and max_connection_age channel arguments since
   // those do not apply to inproc transports.
-  const char* args_to_remove[] = {GRPC_ARG_MAX_CONNECTION_IDLE_MS,
-                                  GRPC_ARG_MAX_CONNECTION_AGE_MS};
-  const grpc_channel_args* server_args = grpc_channel_args_copy_and_remove(
-      core_server->channel_args(), args_to_remove,
-      GPR_ARRAY_SIZE(args_to_remove));
+  grpc_core::ChannelArgs server_args =
+      core_server->channel_args()
+          .Remove(GRPC_ARG_MAX_CONNECTION_IDLE_MS)
+          .Remove(GRPC_ARG_MAX_CONNECTION_AGE_MS);
+
   // Add a default authority channel argument for the client
-  grpc_arg default_authority_arg;
-  default_authority_arg.type = GRPC_ARG_STRING;
-  default_authority_arg.key = const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY);
-  default_authority_arg.value.string = const_cast<char*>("inproc.authority");
-  args = grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
-  const grpc_channel_args* client_args = grpc_core::CoreConfiguration::Get()
-                                             .channel_args_preconditioning()
-                                             .PreconditionChannelArgs(args)
-                                             .ToC();
-  grpc_channel_args_destroy(args);
+  grpc_core::ChannelArgs client_args =
+      grpc_core::CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(args)
+          .Set(GRPC_ARG_DEFAULT_AUTHORITY, "inproc.authority");
   grpc_transport* server_transport;
   grpc_transport* client_transport;
-  inproc_transports_create(&server_transport, server_args, &client_transport,
-                           client_args);
+  inproc_transports_create(&server_transport, &client_transport);
 
   // TODO(ncteisen): design and support channelz GetSocket for inproc.
   grpc_error_handle error = core_server->SetupTransport(
@@ -1282,8 +1255,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   grpc_channel* channel = nullptr;
   if (GRPC_ERROR_IS_NONE(error)) {
     auto new_channel = grpc_core::Channel::Create(
-        "inproc", grpc_core::ChannelArgs::FromC(client_args),
-        GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
+        "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
     if (!new_channel.ok()) {
       GPR_ASSERT(!channel);
       gpr_log(GPR_ERROR, "Failed to create client channel: %s",
@@ -1318,11 +1290,5 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
         nullptr, status, "Failed to create server channel");
   }
 
-  // Free up created channel args
-  grpc_channel_args_destroy(server_args);
-  grpc_channel_args_destroy(client_args);
-
-  // Now finish scheduled operations
-
   return channel;
 }

data/src/core/ext/upb-generated/envoy/admin/v3/certs.upb.c

@@ -26,7 +26,7 @@ static const upb_MiniTable_Field envoy_admin_v3_Certificates__fields[1] = {
 const upb_MiniTable envoy_admin_v3_Certificates_msginit = {
   &envoy_admin_v3_Certificates_submsgs[0],
   &envoy_admin_v3_Certificates__fields[0],
-  UPB_SIZE(4, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+  UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
 };
 
 static const upb_MiniTable_Sub envoy_admin_v3_Certificate_submsgs[2] = {
@@ -42,7 +42,7 @@ static const upb_MiniTable_Field envoy_admin_v3_Certificate__fields[2] = {
 const upb_MiniTable envoy_admin_v3_Certificate_msginit = {
   &envoy_admin_v3_Certificate_submsgs[0],
   &envoy_admin_v3_Certificate__fields[0],
-  UPB_SIZE(8, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+  UPB_SIZE(8, 16), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
 };
 
 static const upb_MiniTable_Sub envoy_admin_v3_CertificateDetails_submsgs[4] = {
@@ -65,7 +65,7 @@ static const upb_MiniTable_Field envoy_admin_v3_CertificateDetails__fields[7] =
 const upb_MiniTable envoy_admin_v3_CertificateDetails_msginit = {
   &envoy_admin_v3_CertificateDetails_submsgs[0],
   &envoy_admin_v3_CertificateDetails__fields[0],
-  UPB_SIZE(48, 88), 7, kUpb_ExtMode_NonExtendable, 7, 255, 0,
+  UPB_SIZE(48, 80), 7, kUpb_ExtMode_NonExtendable, 7, 255, 0,
 };
 
 static const upb_MiniTable_Sub envoy_admin_v3_CertificateDetails_OcspDetails_submsgs[2] = {
@@ -81,7 +81,7 @@ static const upb_MiniTable_Field envoy_admin_v3_CertificateDetails_OcspDetails__
 const upb_MiniTable envoy_admin_v3_CertificateDetails_OcspDetails_msginit = {
   &envoy_admin_v3_CertificateDetails_OcspDetails_submsgs[0],
   &envoy_admin_v3_CertificateDetails_OcspDetails__fields[0],
-  UPB_SIZE(12, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+  UPB_SIZE(16, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
 };
 
 static const upb_MiniTable_Field envoy_admin_v3_SubjectAlternateName__fields[3] = {
@@ -93,7 +93,7 @@ static const upb_MiniTable_Field envoy_admin_v3_SubjectAlternateName__fields[3]
 const upb_MiniTable envoy_admin_v3_SubjectAlternateName_msginit = {
   NULL,
   &envoy_admin_v3_SubjectAlternateName__fields[0],
-  UPB_SIZE(12, 24), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
+  UPB_SIZE(16, 24), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
 };
 
 static const upb_MiniTable *messages_layout[5] = {

data/src/core/ext/upb-generated/envoy/admin/v3/certs.upb.h

@@ -65,11 +65,15 @@ UPB_INLINE envoy_admin_v3_Certificates* envoy_admin_v3_Certificates_parse_ex(con
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_Certificates_serialize(const envoy_admin_v3_Certificates* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_Certificates_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_Certificates_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_Certificates_serialize_ex(const envoy_admin_v3_Certificates* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_Certificates_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_Certificates_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool envoy_admin_v3_Certificates_has_certificates(const envoy_admin_v3_Certificates* msg) {
   return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
@@ -119,11 +123,15 @@ UPB_INLINE envoy_admin_v3_Certificate* envoy_admin_v3_Certificate_parse_ex(const
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_Certificate_serialize(const envoy_admin_v3_Certificate* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_Certificate_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_Certificate_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_Certificate_serialize_ex(const envoy_admin_v3_Certificate* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_Certificate_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_Certificate_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool envoy_admin_v3_Certificate_has_ca_cert(const envoy_admin_v3_Certificate* msg) {
   return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
@@ -194,11 +202,15 @@ UPB_INLINE envoy_admin_v3_CertificateDetails* envoy_admin_v3_CertificateDetails_
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_CertificateDetails_serialize(const envoy_admin_v3_CertificateDetails* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_CertificateDetails_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_CertificateDetails_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_CertificateDetails_serialize_ex(const envoy_admin_v3_CertificateDetails* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_CertificateDetails_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_CertificateDetails_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void envoy_admin_v3_CertificateDetails_clear_path(const envoy_admin_v3_CertificateDetails* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
@@ -341,11 +353,15 @@ UPB_INLINE envoy_admin_v3_CertificateDetails_OcspDetails* envoy_admin_v3_Certifi
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_CertificateDetails_OcspDetails_serialize(const envoy_admin_v3_CertificateDetails_OcspDetails* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_CertificateDetails_OcspDetails_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_CertificateDetails_OcspDetails_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_CertificateDetails_OcspDetails_serialize_ex(const envoy_admin_v3_CertificateDetails_OcspDetails* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_CertificateDetails_OcspDetails_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_CertificateDetails_OcspDetails_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool envoy_admin_v3_CertificateDetails_OcspDetails_has_valid_from(const envoy_admin_v3_CertificateDetails_OcspDetails* msg) {
   return _upb_hasbit(msg, 1);
@@ -418,11 +434,15 @@ UPB_INLINE envoy_admin_v3_SubjectAlternateName* envoy_admin_v3_SubjectAlternateN
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_SubjectAlternateName_serialize(const envoy_admin_v3_SubjectAlternateName* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_SubjectAlternateName_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_SubjectAlternateName_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_SubjectAlternateName_serialize_ex(const envoy_admin_v3_SubjectAlternateName* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_SubjectAlternateName_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_SubjectAlternateName_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 typedef enum {
   envoy_admin_v3_SubjectAlternateName_name_dns = 1,

data/src/core/ext/upb-generated/envoy/admin/v3/clusters.upb.c

@@ -31,7 +31,7 @@ static const upb_MiniTable_Field envoy_admin_v3_Clusters__fields[1] = {
 const upb_MiniTable envoy_admin_v3_Clusters_msginit = {
   &envoy_admin_v3_Clusters_submsgs[0],
   &envoy_admin_v3_Clusters__fields[0],
-  UPB_SIZE(4, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+  UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
 };
 
 static const upb_MiniTable_Sub envoy_admin_v3_ClusterStatus_submsgs[4] = {
@@ -54,7 +54,7 @@ static const upb_MiniTable_Field envoy_admin_v3_ClusterStatus__fields[7] = {
 const upb_MiniTable envoy_admin_v3_ClusterStatus_msginit = {
   &envoy_admin_v3_ClusterStatus_submsgs[0],
   &envoy_admin_v3_ClusterStatus__fields[0],
-  UPB_SIZE(36, 72), 7, kUpb_ExtMode_NonExtendable, 7, 255, 0,
+  UPB_SIZE(40, 72), 7, kUpb_ExtMode_NonExtendable, 7, 255, 0,
 };
 
 static const upb_MiniTable_Sub envoy_admin_v3_HostStatus_submsgs[6] = {
@@ -81,7 +81,7 @@ static const upb_MiniTable_Field envoy_admin_v3_HostStatus__fields[9] = {
 const upb_MiniTable envoy_admin_v3_HostStatus_msginit = {
   &envoy_admin_v3_HostStatus_submsgs[0],
   &envoy_admin_v3_HostStatus__fields[0],
-  UPB_SIZE(44, 88), 9, kUpb_ExtMode_NonExtendable, 9, 255, 0,
+  UPB_SIZE(48, 80), 9, kUpb_ExtMode_NonExtendable, 9, 255, 0,
 };
 
 static const upb_MiniTable_Field envoy_admin_v3_HostHealthStatus__fields[8] = {
@@ -98,7 +98,7 @@ static const upb_MiniTable_Field envoy_admin_v3_HostHealthStatus__fields[8] = {
 const upb_MiniTable envoy_admin_v3_HostHealthStatus_msginit = {
   NULL,
   &envoy_admin_v3_HostHealthStatus__fields[0],
-  UPB_SIZE(13, 24), 8, kUpb_ExtMode_NonExtendable, 8, 255, 0,
+  UPB_SIZE(16, 16), 8, kUpb_ExtMode_NonExtendable, 8, 255, 0,
 };
 
 static const upb_MiniTable *messages_layout[4] = {

data/src/core/ext/upb-generated/envoy/admin/v3/clusters.upb.h

@@ -70,11 +70,15 @@ UPB_INLINE envoy_admin_v3_Clusters* envoy_admin_v3_Clusters_parse_ex(const char*
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_Clusters_serialize(const envoy_admin_v3_Clusters* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_Clusters_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_Clusters_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_Clusters_serialize_ex(const envoy_admin_v3_Clusters* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_Clusters_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_Clusters_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool envoy_admin_v3_Clusters_has_cluster_statuses(const envoy_admin_v3_Clusters* msg) {
   return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
@@ -124,11 +128,15 @@ UPB_INLINE envoy_admin_v3_ClusterStatus* envoy_admin_v3_ClusterStatus_parse_ex(c
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_ClusterStatus_serialize(const envoy_admin_v3_ClusterStatus* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_ClusterStatus_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_ClusterStatus_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_ClusterStatus_serialize_ex(const envoy_admin_v3_ClusterStatus* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_ClusterStatus_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_ClusterStatus_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void envoy_admin_v3_ClusterStatus_clear_name(const envoy_admin_v3_ClusterStatus* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
@@ -271,11 +279,15 @@ UPB_INLINE envoy_admin_v3_HostStatus* envoy_admin_v3_HostStatus_parse_ex(const c
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_HostStatus_serialize(const envoy_admin_v3_HostStatus* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_HostStatus_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_HostStatus_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_HostStatus_serialize_ex(const envoy_admin_v3_HostStatus* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_HostStatus_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_HostStatus_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool envoy_admin_v3_HostStatus_has_address(const envoy_admin_v3_HostStatus* msg) {
   return _upb_hasbit(msg, 1);
@@ -462,11 +474,15 @@ UPB_INLINE envoy_admin_v3_HostHealthStatus* envoy_admin_v3_HostHealthStatus_pars
   return ret;
 }
 UPB_INLINE char* envoy_admin_v3_HostHealthStatus_serialize(const envoy_admin_v3_HostHealthStatus* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_HostHealthStatus_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_HostHealthStatus_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* envoy_admin_v3_HostHealthStatus_serialize_ex(const envoy_admin_v3_HostHealthStatus* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &envoy_admin_v3_HostHealthStatus_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_admin_v3_HostHealthStatus_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void envoy_admin_v3_HostHealthStatus_clear_failed_active_health_check(const envoy_admin_v3_HostHealthStatus* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(0, 0), bool) = 0;