grpc 1.23.0 → 1.24.0

data/src/core/ext/filters/client_channel/client_channel_factory.h

@@ -36,10 +36,6 @@ class ClientChannelFactory {
   virtual Subchannel* CreateSubchannel(const grpc_channel_args* args)
       GRPC_ABSTRACT;
 
-  // Creates a channel for the specified target with the specified args.
-  virtual grpc_channel* CreateChannel(
-      const char* target, const grpc_channel_args* args) GRPC_ABSTRACT;
-
   // Returns a channel arg containing the specified factory.
   static grpc_arg CreateChannelArg(ClientChannelFactory* factory);
 

data/src/core/ext/filters/client_channel/health/health_check_client.cc

@@ -23,14 +23,12 @@
 
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
 
-#include "pb_decode.h"
-#include "pb_encode.h"
-#include "src/core/ext/filters/client_channel/health/health.pb.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/status_metadata.h"
+#include "src/proto/grpc/health/v1/health.upb.h"
 
 #define HEALTH_CHECK_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define HEALTH_CHECK_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -202,19 +200,16 @@ namespace {
 
 void EncodeRequest(const char* service_name,
                    ManualConstructor<SliceBufferByteStream>* send_message) {
-  grpc_health_v1_HealthCheckRequest request_struct;
-  request_struct.has_service = true;
-  snprintf(request_struct.service, sizeof(request_struct.service), "%s",
-           service_name);
-  pb_ostream_t ostream;
-  memset(&ostream, 0, sizeof(ostream));
-  pb_encode(&ostream, grpc_health_v1_HealthCheckRequest_fields,
-            &request_struct);
-  grpc_slice request_slice = GRPC_SLICE_MALLOC(ostream.bytes_written);
-  ostream = pb_ostream_from_buffer(GRPC_SLICE_START_PTR(request_slice),
-                                   GRPC_SLICE_LENGTH(request_slice));
-  GPR_ASSERT(pb_encode(&ostream, grpc_health_v1_HealthCheckRequest_fields,
-                       &request_struct) != 0);
+  upb::Arena arena;
+  grpc_health_v1_HealthCheckRequest* request_struct =
+      grpc_health_v1_HealthCheckRequest_new(arena.ptr());
+  grpc_health_v1_HealthCheckRequest_set_service(
+      request_struct, upb_strview_makez(service_name));
+  size_t buf_length;
+  char* buf = grpc_health_v1_HealthCheckRequest_serialize(
+      request_struct, arena.ptr(), &buf_length);
+  grpc_slice request_slice = GRPC_SLICE_MALLOC(buf_length);
+  memcpy(GRPC_SLICE_START_PTR(request_slice), buf, buf_length);
   grpc_slice_buffer slice_buffer;
   grpc_slice_buffer_init(&slice_buffer);
   grpc_slice_buffer_add(&slice_buffer, request_slice);
@@ -248,24 +243,19 @@ bool DecodeResponse(grpc_slice_buffer* slice_buffer, grpc_error** error) {
     }
   }
   // Deserialize message.
-  grpc_health_v1_HealthCheckResponse response_struct;
-  pb_istream_t istream =
-      pb_istream_from_buffer(recv_message, slice_buffer->length);
-  if (!pb_decode(&istream, grpc_health_v1_HealthCheckResponse_fields,
-                 &response_struct)) {
+  upb::Arena arena;
+  grpc_health_v1_HealthCheckResponse* response_struct =
+      grpc_health_v1_HealthCheckResponse_parse(
+          reinterpret_cast<char*>(recv_message), slice_buffer->length,
+          arena.ptr());
+  if (response_struct == nullptr) {
     // Can't parse message; assume unhealthy.
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "cannot parse health check response");
     return false;
   }
-  if (!response_struct.has_status) {
-    // Field not present; assume unhealthy.
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "status field not present in health check response");
-    return false;
-  }
-  return response_struct.status ==
-         grpc_health_v1_HealthCheckResponse_ServingStatus_SERVING;
+  int32_t status = grpc_health_v1_HealthCheckResponse_status(response_struct);
+  return status == grpc_health_v1_HealthCheckResponse_SERVING;
 }
 
 }  // namespace
@@ -314,8 +304,8 @@ void HealthCheckClient::CallState::StartCall() {
       health_check_client_->connected_subchannel_,
       &pollent_,
       GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH,
-      gpr_now(GPR_CLOCK_MONOTONIC),  // start_time
-      GRPC_MILLIS_INF_FUTURE,        // deadline
+      gpr_get_cycle_counter(),  // start_time
+      GRPC_MILLIS_INF_FUTURE,   // deadline
       arena_,
       context_,
       &call_combiner_,
@@ -356,7 +346,8 @@ void HealthCheckClient::CallState::StartCall() {
       &send_initial_metadata_, &path_metadata_storage_,
       grpc_mdelem_from_slices(
           GRPC_MDSTR_PATH,
-          GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH));
+          GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH),
+      GRPC_BATCH_PATH);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;

data/src/core/ext/filters/client_channel/http_proxy.cc

@@ -47,10 +47,12 @@ static char* get_http_proxy_server(char** user_cred) {
   char* proxy_name = nullptr;
   char** authority_strs = nullptr;
   size_t authority_nstrs;
-  /* Prefer using 'https_proxy'. Fallback on 'http_proxy' if it is not set. The
+  /* Prefer using 'grpc_proxy'. Fallback on 'http_proxy' if it is not set.
+   * Also prefer using 'https_proxy' with fallback on 'http_proxy'. The
    * fallback behavior can be removed if there's a demand for it.
    */
-  char* uri_str = gpr_getenv("https_proxy");
+  char* uri_str = gpr_getenv("grpc_proxy");
+  if (uri_str == nullptr) uri_str = gpr_getenv("https_proxy");
   if (uri_str == nullptr) uri_str = gpr_getenv("http_proxy");
   if (uri_str == nullptr) return nullptr;
   grpc_uri* uri = grpc_uri_parse(uri_str, false /* suppress_errors */);
@@ -122,7 +124,9 @@ static bool proxy_mapper_map_name(grpc_proxy_mapper* mapper,
             server_uri);
     goto no_use_proxy;
   }
-  no_proxy_str = gpr_getenv("no_proxy");
+  /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
+  no_proxy_str = gpr_getenv("no_grpc_proxy");
+  if (no_proxy_str == nullptr) no_proxy_str = gpr_getenv("no_proxy");
   if (no_proxy_str != nullptr) {
     static const char* NO_PROXY_SEPARATOR = ",";
     bool use_proxy = true;

data/src/core/ext/filters/client_channel/lb_policy.cc

@@ -129,7 +129,7 @@ void LoadBalancingPolicy::QueuePicker::CallExitIdle(void* arg,
 LoadBalancingPolicy::PickResult
 LoadBalancingPolicy::TransientFailurePicker::Pick(PickArgs args) {
   PickResult result;
-  result.type = PickResult::PICK_TRANSIENT_FAILURE;
+  result.type = PickResult::PICK_FAILED;
   result.error = GRPC_ERROR_REF(error_);
   return result;
 }

data/src/core/ext/filters/client_channel/lb_policy.h

@@ -25,6 +25,7 @@
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/subchannel_interface.h"
 #include "src/core/lib/gprpp/abstract.h"
+#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/string_view.h"
@@ -42,15 +43,15 @@ extern DebugOnlyTraceFlag grpc_trace_lb_policy_refcount;
 ///
 /// Channel: An abstraction that manages connections to backend servers
 ///   on behalf of a client application.  The application creates a channel
-///   for a given server name and then sends RPCs on it, and the channel
-///   figures out which backend server to send each RPC to.  A channel
+///   for a given server name and then sends calls (RPCs) on it, and the
+///   channel figures out which backend server to send each call to.  A channel
 ///   contains a resolver, a load balancing policy (or a tree of LB policies),
 ///   and a set of one or more subchannels.
 ///
 /// Subchannel: A subchannel represents a connection to one backend server.
 ///   The LB policy decides which subchannels to create, manages the
 ///   connectivity state of those subchannels, and decides which subchannel
-///   to send any given RPC to.
+///   to send any given call to.
 ///
 /// Resolver: A plugin that takes a gRPC server URI and resolves it to a
 ///   list of one or more addresses and a service config, as described
@@ -59,12 +60,12 @@ extern DebugOnlyTraceFlag grpc_trace_lb_policy_refcount;
 ///
 /// Load Balancing (LB) Policy: A plugin that takes a list of addresses
 ///   from the resolver, maintains and manages a subchannel for each
-///   backend address, and decides which subchannel to send each RPC on.
+///   backend address, and decides which subchannel to send each call on.
 ///   An LB policy has two parts:
 ///   - A LoadBalancingPolicy, which deals with the control plane work of
 ///     managing subchannels.
 ///   - A SubchannelPicker, which handles the data plane work of
-///     determining which subchannel a given RPC should be sent on.
+///     determining which subchannel a given call should be sent on.
 
 /// LoadBalacingPolicy API.
 ///
@@ -77,7 +78,28 @@ extern DebugOnlyTraceFlag grpc_trace_lb_policy_refcount;
 // interested_parties() hooks from the API.
 class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
  public:
+  // Represents backend metrics reported by the backend to the client.
+  struct BackendMetricData {
+    /// CPU utilization expressed as a fraction of available CPU resources.
+    double cpu_utilization;
+    /// Memory utilization expressed as a fraction of available memory
+    /// resources.
+    double mem_utilization;
+    /// Total requests per second being served by the backend.  This
+    /// should include all services that a backend is responsible for.
+    uint64_t requests_per_second;
+    /// Application-specific requests cost metrics.  Metric names are
+    /// determined by the application.  Each value is an absolute cost
+    /// (e.g. 3487 bytes of storage) associated with the request.
+    Map<StringView, double, StringLess> request_cost;
+    /// Application-specific resource utilization metrics.  Metric names
+    /// are determined by the application.  Each value is expressed as a
+    /// fraction of total resources available.
+    Map<StringView, double, StringLess> utilization;
+  };
+
   /// Interface for accessing per-call state.
+  /// Implemented by the client channel and used by the SubchannelPicker.
   class CallState {
    public:
     CallState() = default;
@@ -89,10 +111,15 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// for allocations that need to be made on a per-call basis.
     virtual void* Alloc(size_t size) GRPC_ABSTRACT;
 
+    /// Returns the backend metric data returned by the server for the call,
+    /// or null if no backend metric data was returned.
+    virtual const BackendMetricData* GetBackendMetricData() GRPC_ABSTRACT;
+
     GRPC_ABSTRACT_BASE_CLASS
   };
 
   /// Interface for accessing metadata.
+  /// Implemented by the client channel and used by the SubchannelPicker.
   class MetadataInterface {
    public:
     // Implementations whose iterators fit in intptr_t may internally
@@ -123,7 +150,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     GRPC_ABSTRACT_BASE_CLASS
   };
 
-  /// Arguments used when picking a subchannel for an RPC.
+  /// Arguments used when picking a subchannel for a call.
   struct PickArgs {
     /// Initial metadata associated with the picking call.
     /// The LB policy may use the existing metadata to influence its routing
@@ -135,24 +162,23 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     CallState* call_state;
   };
 
-  /// The result of picking a subchannel for an RPC.
+  /// The result of picking a subchannel for a call.
   struct PickResult {
     enum ResultType {
-      /// Pick complete.  If connected_subchannel is non-null, client channel
-      /// can immediately proceed with the call on connected_subchannel;
-      /// otherwise, call should be dropped.
+      /// Pick complete.  If \a subchannel is non-null, the client channel
+      /// will immediately proceed with the call on that subchannel;
+      /// otherwise, it will drop the call.
       PICK_COMPLETE,
       /// Pick cannot be completed until something changes on the control
-      /// plane.  Client channel will queue the pick and try again the
+      /// plane.  The client channel will queue the pick and try again the
       /// next time the picker is updated.
       PICK_QUEUE,
-      /// LB policy is in transient failure.  If the pick is wait_for_ready,
-      /// client channel will wait for the next picker and try again;
-      /// otherwise, the call will be failed immediately (although it may
-      /// be retried if the client channel is configured to do so).
-      /// The Pick() method will set its error parameter if this value is
-      /// returned.
-      PICK_TRANSIENT_FAILURE,
+      /// Pick failed.  If the call is wait_for_ready, the client channel
+      /// will wait for the next picker and try again; otherwise, it
+      /// will immediately fail the call with the status indicated via
+      /// \a error (although the call may be retried if the client channel
+      /// is configured to do so).
+      PICK_FAILED,
     };
     ResultType type;
 
@@ -160,32 +186,37 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// subchannel, or nullptr if the LB policy decides to drop the call.
     RefCountedPtr<SubchannelInterface> subchannel;
 
-    /// Used only if type is PICK_TRANSIENT_FAILURE.
-    /// Error to be set when returning a transient failure.
+    /// Used only if type is PICK_FAILED.
+    /// Error to be set when returning a failure.
     // TODO(roth): Replace this with something similar to grpc::Status,
     // so that we don't expose grpc_error to this API.
     grpc_error* error = GRPC_ERROR_NONE;
 
     /// Used only if type is PICK_COMPLETE.
-    /// Callback set by lb policy to be notified of trailing metadata.
+    /// Callback set by LB policy to be notified of trailing metadata.
     /// The user_data argument will be set to the
     /// recv_trailing_metadata_ready_user_data field.
     /// recv_trailing_metadata will be set to the metadata, which may be
     /// modified by the callback.  The callback does not take ownership,
     /// however, so any data that needs to be used after returning must
     /// be copied.
+    /// call_state can be used to obtain backend metric data.
+    // TODO(roth): Replace grpc_error with something better before we allow
+    // people outside of gRPC team to use this API.
     void (*recv_trailing_metadata_ready)(
-        void* user_data, MetadataInterface* recv_trailing_metadata,
+        void* user_data, grpc_error* error,
+        MetadataInterface* recv_trailing_metadata,
         CallState* call_state) = nullptr;
     void* recv_trailing_metadata_ready_user_data = nullptr;
   };
 
   /// A subchannel picker is the object used to pick the subchannel to
-  /// use for a given RPC.
+  /// use for a given call.  This is implemented by the LB policy and
+  /// used by the client channel to perform picks.
   ///
   /// Pickers are intended to encapsulate all of the state and logic
   /// needed on the data plane (i.e., to actually process picks for
-  /// individual RPCs sent on the channel) while excluding all of the
+  /// individual calls sent on the channel) while excluding all of the
   /// state and logic needed on the control plane (i.e., resolver
   /// updates, connectivity state notifications, etc); the latter should
   /// live in the LB policy object itself.
@@ -203,8 +234,8 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     GRPC_ABSTRACT_BASE_CLASS
   };
 
-  /// A proxy object used by the LB policy to communicate with the client
-  /// channel.
+  /// A proxy object implemented by the client channel and used by the
+  /// LB policy to communicate with the channel.
   // TODO(juanlishen): Consider adding a mid-layer subclass that helps handle
   // things like swapping in pending policy when it's ready. Currently, we are
   // duplicating the logic in many subclasses.
@@ -217,12 +248,6 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
         const grpc_channel_args& args) GRPC_ABSTRACT;
 
-    /// Creates a channel with the specified target and channel args.
-    /// This can be used in cases where the LB policy needs to create a
-    /// channel for its own use (e.g., to talk to an external load balancer).
-    virtual grpc_channel* CreateChannel(
-        const char* target, const grpc_channel_args& args) GRPC_ABSTRACT;
-
     /// Sets the connectivity state and returns a new picker to be used
     /// by the client channel.
     virtual void UpdateState(grpc_connectivity_state state,
@@ -232,10 +257,9 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     virtual void RequestReresolution() GRPC_ABSTRACT;
 
     /// Adds a trace message associated with the channel.
-    /// Does NOT take ownership of \a message.
     enum TraceSeverity { TRACE_INFO, TRACE_WARNING, TRACE_ERROR };
     virtual void AddTraceEvent(TraceSeverity severity,
-                               const char* message) GRPC_ABSTRACT;
+                               StringView message) GRPC_ABSTRACT;
 
     GRPC_ABSTRACT_BASE_CLASS
   };

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -293,12 +293,10 @@ class GrpcLb : public LoadBalancingPolicy {
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         const grpc_channel_args& args) override;
-    grpc_channel* CreateChannel(const char* target,
-                                const grpc_channel_args& args) override;
     void UpdateState(grpc_connectivity_state state,
                      UniquePtr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
-    void AddTraceEvent(TraceSeverity severity, const char* message) override;
+    void AddTraceEvent(TraceSeverity severity, StringView message) override;
 
     void set_child(LoadBalancingPolicy* child) { child_ = child; }
 
@@ -409,18 +407,18 @@ void ParseServer(const grpc_grpclb_server* server,
   const uint16_t netorder_port = grpc_htons((uint16_t)server->port);
   /* the addresses are given in binary format (a in(6)_addr struct) in
    * server->ip_address.bytes. */
-  const grpc_grpclb_ip_address* ip = &server->ip_address;
-  if (ip->size == 4) {
+  const grpc_grpclb_server_ip_address& ip = server->ip_address;
+  if (ip.size == 4) {
     addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
     grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(&addr->addr);
     addr4->sin_family = GRPC_AF_INET;
-    memcpy(&addr4->sin_addr, ip->bytes, ip->size);
+    memcpy(&addr4->sin_addr, ip.data, ip.size);
     addr4->sin_port = netorder_port;
-  } else if (ip->size == 16) {
+  } else if (ip.size == 16) {
     addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
     grpc_sockaddr_in6* addr6 = (grpc_sockaddr_in6*)&addr->addr;
     addr6->sin6_family = GRPC_AF_INET6;
-    memcpy(&addr6->sin6_addr, ip->bytes, ip->size);
+    memcpy(&addr6->sin6_addr, ip.data, ip.size);
     addr6->sin6_port = netorder_port;
   }
 }
@@ -490,7 +488,7 @@ const grpc_arg_pointer_vtable client_stats_arg_vtable = {
 
 bool IsServerValid(const grpc_grpclb_server* server, size_t idx, bool log) {
   if (server->drop) return false;
-  const grpc_grpclb_ip_address* ip = &server->ip_address;
+  const grpc_grpclb_server_ip_address& ip = server->ip_address;
   if (GPR_UNLIKELY(server->port >> 16 != 0)) {
     if (log) {
       gpr_log(GPR_ERROR,
@@ -499,12 +497,12 @@ bool IsServerValid(const grpc_grpclb_server* server, size_t idx, bool log) {
     }
     return false;
   }
-  if (GPR_UNLIKELY(ip->size != 4 && ip->size != 16)) {
+  if (GPR_UNLIKELY(ip.size != 4 && ip.size != 16)) {
     if (log) {
       gpr_log(GPR_ERROR,
               "Expected IP to be 4 or 16 bytes, got %d at index %lu of "
               "serverlist. Ignoring",
-              ip->size, (unsigned long)idx);
+              ip.size, (unsigned long)idx);
     }
     return false;
   }
@@ -523,7 +521,7 @@ ServerAddressList GrpcLb::Serverlist::GetServerAddressList(
     ParseServer(server, &addr);
     // LB token processing.
     char lb_token[GPR_ARRAY_SIZE(server->load_balance_token) + 1];
-    if (server->has_load_balance_token) {
+    if (server->load_balance_token[0] != 0) {
       const size_t lb_token_max_length =
           GPR_ARRAY_SIZE(server->load_balance_token);
       const size_t lb_token_length =
@@ -652,15 +650,6 @@ RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
   return parent_->channel_control_helper()->CreateSubchannel(args);
 }
 
-grpc_channel* GrpcLb::Helper::CreateChannel(const char* target,
-                                            const grpc_channel_args& args) {
-  if (parent_->shutting_down_ ||
-      (!CalledByPendingChild() && !CalledByCurrentChild())) {
-    return nullptr;
-  }
-  return parent_->channel_control_helper()->CreateChannel(target, args);
-}
-
 void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
                                  UniquePtr<SubchannelPicker> picker) {
   if (parent_->shutting_down_) return;
@@ -756,8 +745,7 @@ void GrpcLb::Helper::RequestReresolution() {
   }
 }
 
-void GrpcLb::Helper::AddTraceEvent(TraceSeverity severity,
-                                   const char* message) {
+void GrpcLb::Helper::AddTraceEvent(TraceSeverity severity, StringView message) {
   if (parent_->shutting_down_ ||
       (!CalledByPendingChild() && !CalledByCurrentChild())) {
     return;
@@ -790,13 +778,14 @@ GrpcLb::BalancerCallState::BalancerCallState(
       GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD,
       nullptr, deadline, nullptr);
   // Init the LB call request payload.
+  upb::Arena arena;
   grpc_grpclb_request* request =
-      grpc_grpclb_request_create(grpclb_policy()->server_name_);
-  grpc_slice request_payload_slice = grpc_grpclb_request_encode(request);
+      grpc_grpclb_request_create(grpclb_policy()->server_name_, arena.ptr());
+  grpc_slice request_payload_slice =
+      grpc_grpclb_request_encode(request, arena.ptr());
   send_message_payload_ =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_slice_unref_internal(request_payload_slice);
-  grpc_grpclb_request_destroy(request);
   // Init other data associated with the LB call.
   grpc_metadata_array_init(&lb_initial_metadata_recv_);
   grpc_metadata_array_init(&lb_trailing_metadata_recv_);
@@ -940,27 +929,32 @@ void GrpcLb::BalancerCallState::MaybeSendClientLoadReportLocked(
 
 bool GrpcLb::BalancerCallState::LoadReportCountersAreZero(
     grpc_grpclb_request* request) {
-  GrpcLbClientStats::DroppedCallCounts* drop_entries =
-      static_cast<GrpcLbClientStats::DroppedCallCounts*>(
-          request->client_stats.calls_finished_with_drop.arg);
-  return request->client_stats.num_calls_started == 0 &&
-         request->client_stats.num_calls_finished == 0 &&
-         request->client_stats.num_calls_finished_with_client_failed_to_send ==
+  const grpc_lb_v1_ClientStats* cstats =
+      grpc_lb_v1_LoadBalanceRequest_client_stats(request);
+  if (cstats == nullptr) {
+    return true;
+  }
+  size_t drop_count;
+  grpc_lb_v1_ClientStats_calls_finished_with_drop(cstats, &drop_count);
+  return grpc_lb_v1_ClientStats_num_calls_started(cstats) == 0 &&
+         grpc_lb_v1_ClientStats_num_calls_finished(cstats) == 0 &&
+         grpc_lb_v1_ClientStats_num_calls_finished_with_client_failed_to_send(
+             cstats) == 0 &&
+         grpc_lb_v1_ClientStats_num_calls_finished_known_received(cstats) ==
              0 &&
-         request->client_stats.num_calls_finished_known_received == 0 &&
-         (drop_entries == nullptr || drop_entries->size() == 0);
+         drop_count == 0;
 }
 
 void GrpcLb::BalancerCallState::SendClientLoadReportLocked() {
   // Construct message payload.
   GPR_ASSERT(send_message_payload_ == nullptr);
+  upb::Arena arena;
   grpc_grpclb_request* request =
-      grpc_grpclb_load_report_request_create(client_stats_.get());
+      grpc_grpclb_load_report_request_create(client_stats_.get(), arena.ptr());
   // Skip client load report if the counters were all zero in the last
   // report and they are still zero in this one.
   if (LoadReportCountersAreZero(request)) {
     if (last_client_load_report_counters_were_zero_) {
-      grpc_grpclb_request_destroy(request);
       ScheduleNextClientLoadReportLocked();
       return;
     }
@@ -968,11 +962,11 @@ void GrpcLb::BalancerCallState::SendClientLoadReportLocked() {
   } else {
     last_client_load_report_counters_were_zero_ = false;
   }
-  grpc_slice request_payload_slice = grpc_grpclb_request_encode(request);
+  grpc_slice request_payload_slice =
+      grpc_grpclb_request_encode(request, arena.ptr());
   send_message_payload_ =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
   grpc_slice_unref_internal(request_payload_slice);
-  grpc_grpclb_request_destroy(request);
   // Send the report.
   grpc_op op;
   memset(&op, 0, sizeof(op));
@@ -1034,16 +1028,20 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked(
   grpc_byte_buffer_reader_destroy(&bbr);
   grpc_byte_buffer_destroy(lb_calld->recv_message_payload_);
   lb_calld->recv_message_payload_ = nullptr;
-  grpc_grpclb_initial_response* initial_response;
+  const grpc_grpclb_initial_response* initial_response;
   grpc_grpclb_serverlist* serverlist;
+  upb::Arena arena;
   if (!lb_calld->seen_initial_response_ &&
-      (initial_response = grpc_grpclb_initial_response_parse(response_slice)) !=
-          nullptr) {
+      (initial_response = grpc_grpclb_initial_response_parse(
+           response_slice, arena.ptr())) != nullptr) {
     // Have NOT seen initial response, look for initial response.
-    if (initial_response->has_client_stats_report_interval) {
-      lb_calld->client_stats_report_interval_ = GPR_MAX(
-          GPR_MS_PER_SEC, grpc_grpclb_duration_to_millis(
-                              &initial_response->client_stats_report_interval));
+    const google_protobuf_Duration* client_stats_report_interval =
+        grpc_lb_v1_InitialLoadBalanceResponse_client_stats_report_interval(
+            initial_response);
+    if (client_stats_report_interval != nullptr) {
+      lb_calld->client_stats_report_interval_ =
+          GPR_MAX(GPR_MS_PER_SEC,
+                  grpc_grpclb_duration_to_millis(client_stats_report_interval));
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
         gpr_log(GPR_INFO,
                 "[grpclb %p] lb_calld=%p: Received initial LB response "
@@ -1058,7 +1056,6 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked(
               "client load reporting NOT enabled",
               grpclb_policy, lb_calld);
     }
-    grpc_grpclb_initial_response_destroy(initial_response);
     lb_calld->seen_initial_response_ = true;
   } else if ((serverlist = grpc_grpclb_response_parse_serverlist(
                   response_slice)) != nullptr) {
@@ -1267,7 +1264,7 @@ grpc_channel_args* BuildBalancerChannelArgs(
       // the LB channel.
       GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR,
       // The LB channel should use the authority indicated by the target
-      // authority table (see \a grpc_lb_policy_grpclb_modify_lb_channel_args),
+      // authority table (see \a ModifyGrpclbBalancerChannelArgs),
       // as opposed to the authority from the parent channel.
       GRPC_ARG_DEFAULT_AUTHORITY,
       // Just as for \a GRPC_ARG_DEFAULT_AUTHORITY, the LB channel should be
@@ -1303,7 +1300,7 @@ grpc_channel_args* BuildBalancerChannelArgs(
       args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), args_to_add.data(),
       args_to_add.size());
   // Make any necessary modifications for security.
-  return grpc_lb_policy_grpclb_modify_lb_channel_args(addresses, new_args);
+  return ModifyGrpclbBalancerChannelArgs(addresses, new_args);
 }
 
 //
@@ -1479,8 +1476,7 @@ void GrpcLb::ProcessAddressesAndChannelArgsLocked(
   if (lb_channel_ == nullptr) {
     char* uri_str;
     gpr_asprintf(&uri_str, "fake:///%s", server_name_);
-    lb_channel_ =
-        channel_control_helper()->CreateChannel(uri_str, *lb_channel_args);
+    lb_channel_ = CreateGrpclbBalancerChannel(uri_str, *lb_channel_args);
     GPR_ASSERT(lb_channel_ != nullptr);
     gpr_free(uri_str);
   }