grpc 1.50.0 → 1.52.0.pre2

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

@@ -24,15 +24,17 @@
 #include <string>
 #include <utility>
 
-#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 
 // Conversion between call and call stack.
@@ -54,19 +56,19 @@ DynamicFilters::Call::Call(Args args, grpc_error_handle* error)
     : channel_stack_(std::move(args.channel_stack)) {
   grpc_call_stack* call_stack = CALL_TO_CALL_STACK(this);
   const grpc_call_element_args call_args = {
-      call_stack,        /* call_stack */
-      nullptr,           /* server_transport_data */
-      args.context,      /* context */
-      args.path,         /* path */
-      args.start_time,   /* start_time */
-      args.deadline,     /* deadline */
-      args.arena,        /* arena */
-      args.call_combiner /* call_combiner */
+      call_stack,         // call_stack
+      nullptr,            // server_transport_data
+      args.context,       // context
+      args.path,          // path
+      args.start_time,    // start_time
+      args.deadline,      // deadline
+      args.arena,         // arena
+      args.call_combiner  // call_combiner
   };
-  *error = grpc_call_stack_init(channel_stack_->channel_stack_, 1, Destroy,
-                                this, &call_args);
-  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(*error))) {
-    gpr_log(GPR_ERROR, "error: %s", grpc_error_std_string(*error).c_str());
+  *error = grpc_call_stack_init(channel_stack_->channel_stack_.get(), 1,
+                                Destroy, this, &call_args);
+  if (GPR_UNLIKELY(!error->ok())) {
+    gpr_log(GPR_ERROR, "error: %s", StatusToString(*error).c_str());
     return;
   }
   grpc_call_stack_set_pollset_or_pollset_set(call_stack, args.pollent);
@@ -136,58 +138,29 @@ void DynamicFilters::Call::IncrementRefCount(const DebugLocation& /*location*/,
 
 namespace {
 
-void DestroyChannelStack(void* arg, grpc_error_handle /*error*/) {
-  grpc_channel_stack* channel_stack = static_cast<grpc_channel_stack*>(arg);
-  grpc_channel_stack_destroy(channel_stack);
-  gpr_free(channel_stack);
-}
-
-std::pair<grpc_channel_stack*, grpc_error_handle> CreateChannelStack(
-    const grpc_channel_args* args,
-    std::vector<const grpc_channel_filter*> filters) {
-  // Allocate memory for channel stack.
-  const size_t channel_stack_size =
-      grpc_channel_stack_size(filters.data(), filters.size());
-  grpc_channel_stack* channel_stack =
-      reinterpret_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
-  // Initialize stack.
-  grpc_error_handle error = grpc_channel_stack_init(
-      /*initial_refs=*/1, DestroyChannelStack, channel_stack, filters.data(),
-      filters.size(), args, "DynamicFilters", channel_stack);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    gpr_log(GPR_ERROR, "error initializing client internal stack: %s",
-            grpc_error_std_string(error).c_str());
-    grpc_channel_stack_destroy(channel_stack);
-    gpr_free(channel_stack);
-    return {nullptr, error};
+absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
+    const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters) {
+  ChannelStackBuilderImpl builder("DynamicFilters", GRPC_CLIENT_DYNAMIC, args);
+  for (auto filter : filters) {
+    builder.AppendFilter(filter);
   }
-  return {channel_stack, GRPC_ERROR_NONE};
+  return builder.Build();
 }
 
 }  // namespace
 
 RefCountedPtr<DynamicFilters> DynamicFilters::Create(
-    const grpc_channel_args* args,
-    std::vector<const grpc_channel_filter*> filters) {
+    const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters) {
   // Attempt to create channel stack from requested filters.
   auto p = CreateChannelStack(args, std::move(filters));
-  if (!GRPC_ERROR_IS_NONE(p.second)) {
+  if (!p.ok()) {
     // Channel stack creation failed with requested filters.
     // Create with lame filter instead.
-    grpc_error_handle error = p.second;
-    grpc_arg error_arg = MakeLameClientErrorArg(&error);
-    grpc_channel_args* new_args =
-        grpc_channel_args_copy_and_add(args, &error_arg, 1);
-    GRPC_ERROR_UNREF(error);
-    p = CreateChannelStack(new_args, {&LameClientFilter::kFilter});
-    GPR_ASSERT(GRPC_ERROR_IS_NONE(p.second));
-    grpc_channel_args_destroy(new_args);
+    auto error = p.status();
+    p = CreateChannelStack(args.Set(MakeLameClientErrorArg(&error)),
+                           {&LameClientFilter::kFilter});
   }
-  return MakeRefCounted<DynamicFilters>(p.first);
-}
-
-DynamicFilters::~DynamicFilters() {
-  GRPC_CHANNEL_STACK_UNREF(channel_stack_, "~DynamicFilters");
+  return MakeRefCounted<DynamicFilters>(std::move(p.value()));
 }
 
 RefCountedPtr<DynamicFilters::Call> DynamicFilters::CreateCall(

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

@@ -19,12 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <utility>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -90,18 +92,15 @@ class DynamicFilters : public RefCounted<DynamicFilters> {
   };
 
   static RefCountedPtr<DynamicFilters> Create(
-      const grpc_channel_args* args,
-      std::vector<const grpc_channel_filter*> filters);
+      const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters);
 
-  explicit DynamicFilters(grpc_channel_stack* channel_stack)
-      : channel_stack_(channel_stack) {}
-
-  ~DynamicFilters() override;
+  explicit DynamicFilters(RefCountedPtr<grpc_channel_stack> channel_stack)
+      : channel_stack_(std::move(channel_stack)) {}
 
   RefCountedPtr<Call> CreateCall(Call::Args args, grpc_error_handle* error);
 
  private:
-  grpc_channel_stack* channel_stack_;
+  RefCountedPtr<grpc_channel_stack> channel_stack_;
 };
 
 }  // namespace grpc_core

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H
@@ -60,4 +60,4 @@ class GlobalSubchannelPool final : public SubchannelPoolInterface {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H

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

@@ -25,14 +25,13 @@
 #include <memory>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "upb/upb.h"
 #include "upb/upb.hpp"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
@@ -165,9 +164,9 @@ OrphanablePtr<SubchannelStreamClient> MakeHealthCheckClient(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
   return MakeOrphanable<SubchannelStreamClient>(
       std::move(connected_subchannel), interested_parties,
-      absl::make_unique<HealthStreamEventHandler>(std::move(service_name),
-                                                  std::move(channelz_node),
-                                                  std::move(watcher)),
+      std::make_unique<HealthStreamEventHandler>(std::move(service_name),
+                                                 std::move(channelz_node),
+                                                 std::move(watcher)),
       GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)
           ? "HealthCheckClient"
           : nullptr);

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -35,7 +35,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -44,7 +44,6 @@
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/transport/http_connect_handshaker.h"
@@ -53,24 +52,24 @@
 namespace grpc_core {
 namespace {
 
-/**
- * Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
- * proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
- * credentials if present in the 'http_proxy' env var, otherwise leaves it
- * unchanged.
- */
+///
+/// Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
+/// proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
+/// credentials if present in the 'http_proxy' env var, otherwise leaves it
+/// unchanged.
+///
 absl::optional<std::string> GetHttpProxyServer(
     const ChannelArgs& args, absl::optional<std::string>* user_cred) {
   GPR_ASSERT(user_cred != nullptr);
   absl::StatusOr<URI> uri;
-  /* We check the following places to determine the HTTP proxy to use, stopping
-   * at the first one that is set:
-   * 1. GRPC_ARG_HTTP_PROXY channel arg
-   * 2. grpc_proxy environment variable
-   * 3. https_proxy environment variable
-   * 4. http_proxy environment variable
-   * If none of the above are set, then no HTTP proxy will be used.
-   */
+  // We check the following places to determine the HTTP proxy to use, stopping
+  // at the first one that is set:
+  // 1. GRPC_ARG_HTTP_PROXY channel arg
+  // 2. grpc_proxy environment variable
+  // 3. https_proxy environment variable
+  // 4. http_proxy environment variable
+  // If none of the above are set, then no HTTP proxy will be used.
+  //
   absl::optional<std::string> uri_str =
       args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
   if (!uri_str.has_value()) uri_str = GetEnv("grpc_proxy");
@@ -90,23 +89,23 @@ absl::optional<std::string> GetHttpProxyServer(
             uri->scheme().c_str());
     return absl::nullopt;
   }
-  /* Split on '@' to separate user credentials from host */
+  // Split on '@' to separate user credentials from host
   char** authority_strs = nullptr;
   size_t authority_nstrs;
   gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
                    &authority_nstrs);
-  GPR_ASSERT(authority_nstrs != 0); /* should have at least 1 string */
+  GPR_ASSERT(authority_nstrs != 0);  // should have at least 1 string
   absl::optional<std::string> proxy_name;
   if (authority_nstrs == 1) {
-    /* User cred not present in authority */
+    // User cred not present in authority
     proxy_name = authority_strs[0];
   } else if (authority_nstrs == 2) {
-    /* User cred found */
+    // User cred found
     *user_cred = authority_strs[0];
     proxy_name = authority_strs[1];
     gpr_log(GPR_DEBUG, "userinfo found in proxy URI");
   } else {
-    /* Bad authority */
+    // Bad authority
     proxy_name = absl::nullopt;
   }
   for (size_t i = 0; i < authority_nstrs; i++) {
@@ -150,7 +149,7 @@ absl::optional<std::string> HttpProxyMapper::MapName(
             std::string(server_uri).c_str());
     return absl::nullopt;
   }
-  /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
+  // Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set.
   auto no_proxy_str = GetEnv("no_grpc_proxy");
   if (!no_proxy_str.has_value()) {
     no_proxy_str = GetEnv("no_proxy");
@@ -182,7 +181,7 @@ absl::optional<std::string> HttpProxyMapper::MapName(
   *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER,
                     MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")));
   if (user_cred.has_value()) {
-    /* Use base64 encoding for user credentials as stated in RFC 7617 */
+    // Use base64 encoding for user credentials as stated in RFC 7617
     auto encoded_user_cred = UniquePtr<char>(
         grpc_base64_encode(user_cred->data(), user_cred->length(), 0, 0));
     *args = args->Set(

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
@@ -49,4 +49,4 @@ void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H

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

@@ -0,0 +1,39 @@
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_CALL_STATE_INTERNAL_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_CALL_STATE_INTERNAL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+
+namespace grpc_core {
+
+//
+// LbCallStateInternal
+//
+class LbCallStateInternal : public LoadBalancingPolicy::CallState {
+ public:
+  virtual absl::string_view GetCallAttribute(UniqueTypeName type) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_CALL_STATE_INTERNAL_H

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

@@ -23,7 +23,6 @@
 #include <algorithm>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 
@@ -41,7 +40,7 @@ class HierarchicalPathAttribute : public ServerAddress::AttributeInterface {
       : path_(std::move(path)) {}
 
   std::unique_ptr<AttributeInterface> Copy() const override {
-    return absl::make_unique<HierarchicalPathAttribute>(path_);
+    return std::make_unique<HierarchicalPathAttribute>(path_);
   }
 
   int Cmp(const AttributeInterface* other) const override {
@@ -70,7 +69,7 @@ class HierarchicalPathAttribute : public ServerAddress::AttributeInterface {
 
 std::unique_ptr<ServerAddress::AttributeInterface>
 MakeHierarchicalPathAttribute(std::vector<std::string> path) {
-  return absl::make_unique<HierarchicalPathAttribute>(std::move(path));
+  return std::make_unique<HierarchicalPathAttribute>(std::move(path));
 }
 
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
@@ -89,7 +88,7 @@ absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
     ++it;
     if (it != path.end()) {
       std::vector<std::string> remaining_path(it, path.end());
-      new_attribute = absl::make_unique<HierarchicalPathAttribute>(
+      new_attribute = std::make_unique<HierarchicalPathAttribute>(
           std::move(remaining_path));
     }
     target_list.emplace_back(address.WithAttribute(

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

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2022 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_BACKEND_METRIC_DATA_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_BACKEND_METRIC_DATA_H
@@ -34,6 +32,8 @@ struct BackendMetricData {
   /// Memory utilization expressed as a fraction of available memory
   /// resources.
   double mem_utilization = -1;
+  /// Total QPS being served by the backend across all services.
+  double qps = -1;
   /// 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.

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

@@ -25,7 +25,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -60,7 +61,7 @@ class ChildPolicyHandler::Helper
   }
 
   void UpdateState(grpc_connectivity_state state, const absl::Status& status,
-                   std::unique_ptr<SubchannelPicker> picker) override {
+                   RefCountedPtr<SubchannelPicker> picker) override {
     if (parent_->shutting_down_) return;
     // If this request is from the pending child policy, ignore it until
     // it reports something other than CONNECTING, at which point we swap it
@@ -107,6 +108,10 @@ class ChildPolicyHandler::Helper
     return parent_->channel_control_helper()->GetAuthority();
   }
 
+  grpc_event_engine::experimental::EventEngine* GetEventEngine() override {
+    return parent_->channel_control_helper()->GetEventEngine();
+  }
+
   void AddTraceEvent(TraceSeverity severity,
                      absl::string_view message) override {
     if (parent_->shutting_down_) return;

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

@@ -85,5 +85,4 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H \
-        */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H