grpc 1.60.0 → 1.62.0

data/src/core/lib/transport/metadata.h

@@ -0,0 +1,78 @@
+// Copyright 2024 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_SRC_CORE_LIB_TRANSPORT_METADATA_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+// Server metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ServerMetadata = grpc_metadata_batch;
+using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
+
+// Client initial metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ClientMetadata = grpc_metadata_batch;
+using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
+
+// Ok/not-ok check for trailing metadata, so that it can be used as result types
+// for TrySeq.
+inline bool IsStatusOk(const ServerMetadataHandle& m) {
+  return m->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
+         GRPC_STATUS_OK;
+}
+
+ServerMetadataHandle ServerMetadataFromStatus(
+    const absl::Status& status, Arena* arena = GetContext<Arena>());
+
+template <>
+struct StatusCastImpl<ServerMetadataHandle, absl::Status> {
+  static ServerMetadataHandle Cast(const absl::Status& m) {
+    return ServerMetadataFromStatus(m);
+  }
+};
+
+template <>
+struct StatusCastImpl<ServerMetadataHandle, const absl::Status&> {
+  static ServerMetadataHandle Cast(const absl::Status& m) {
+    return ServerMetadataFromStatus(m);
+  }
+};
+
+template <>
+struct StatusCastImpl<ServerMetadataHandle, absl::Status&> {
+  static ServerMetadataHandle Cast(const absl::Status& m) {
+    return ServerMetadataFromStatus(m);
+  }
+};
+
+// Anything that can be first cast to absl::Status can then be cast to
+// ServerMetadataHandle.
+template <typename T>
+struct StatusCastImpl<
+    ServerMetadataHandle, T,
+    absl::void_t<decltype(&StatusCastImpl<absl::Status, T>::Cast)>> {
+  static ServerMetadataHandle Cast(const T& m) {
+    return ServerMetadataFromStatus(StatusCast<absl::Status>(m));
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_H

data/src/core/lib/transport/metadata_batch.cc

@@ -64,7 +64,7 @@ absl::optional<absl::string_view> UnknownMap::GetStringValue(
 }  // namespace metadata_detail
 
 ContentTypeMetadata::MementoType ContentTypeMetadata::ParseMemento(
-    Slice value, bool, MetadataParseErrorFn on_error) {
+    Slice value, bool, MetadataParseErrorFn /*on_error*/) {
   auto out = kInvalid;
   auto value_string = value.as_string_view();
   if (value_string == "application/grpc") {
@@ -76,7 +76,9 @@ ContentTypeMetadata::MementoType ContentTypeMetadata::ParseMemento(
   } else if (value_string.empty()) {
     out = kEmpty;
   } else {
-    on_error("invalid value", value);
+    // We are intentionally not invoking on_error here since the spec is not
+    // clear on what the behavior should be here, so to avoid breaking anyone,
+    // we should continue to accept this.
   }
   return out;
 }

data/src/core/lib/transport/metadata_batch.h

@@ -410,7 +410,8 @@ struct GrpcLbClientStatsMetadata {
   static const char* DisplayMemento(MementoType) {
     return "<internal-lb-stats>";
   }
-  static MementoType ParseMemento(Slice, bool, MetadataParseErrorFn) {
+  static MementoType ParseMemento(Slice, bool, MetadataParseErrorFn error) {
+    error("not a valid value for grpclb_client_stats", Slice());
     return nullptr;
   }
 };
@@ -649,9 +650,8 @@ class ParseHelper {
     return ParsedMetadata<Container>(
         typename ParsedMetadata<Container>::FromSlicePair{},
         Slice::FromCopiedString(key),
-        IsUniquelyUnownedEnabled() && will_keep_past_request_lifetime_
-            ? value_.TakeUniquelyOwned()
-            : std::move(value_),
+        will_keep_past_request_lifetime_ ? value_.TakeUniquelyOwned()
+                                         : std::move(value_),
         transport_size_);
   }
 
@@ -1050,7 +1050,7 @@ class UnknownMap {
  public:
   explicit UnknownMap(Arena* arena) : unknown_(arena) {}
 
-  using BackingType = ChunkedVector<std::pair<Slice, Slice>, 10>;
+  using BackingType = ChunkedVector<std::pair<Slice, Slice>, 5>;
 
   void Append(absl::string_view key, Slice value);
   void Remove(absl::string_view key);
@@ -1067,7 +1067,7 @@ class UnknownMap {
 
  private:
   // Backing store for added metadata.
-  ChunkedVector<std::pair<Slice, Slice>, 10> unknown_;
+  BackingType unknown_;
 };
 
 // Given a factory template Factory, construct a type that derives from

data/src/core/lib/transport/transport.cc

@@ -35,6 +35,9 @@
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/for_each.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/error_utils.h"
 
@@ -83,25 +86,6 @@ void grpc_stream_ref_init(grpc_stream_refcount* refcount, int /*initial_refs*/,
                                                              : nullptr);
 }
 
-static void move64bits(uint64_t* from, uint64_t* to) {
-  *to += *from;
-  *from = 0;
-}
-
-void grpc_transport_move_one_way_stats(grpc_transport_one_way_stats* from,
-                                       grpc_transport_one_way_stats* to) {
-  move64bits(&from->framing_bytes, &to->framing_bytes);
-  move64bits(&from->data_bytes, &to->data_bytes);
-  move64bits(&from->header_bytes, &to->header_bytes);
-}
-
-void grpc_transport_move_stats(grpc_transport_stream_stats* from,
-                               grpc_transport_stream_stats* to) {
-  grpc_transport_move_one_way_stats(&from->incoming, &to->incoming);
-  grpc_transport_move_one_way_stats(&from->outgoing, &to->outgoing);
-  to->latency = std::exchange(from->latency, gpr_inf_future(GPR_TIMESPAN));
-}
-
 namespace grpc_core {
 void Transport::SetPollingEntity(grpc_stream* stream,
                                  grpc_polling_entity* pollset_or_pollset_set) {
@@ -231,41 +215,3 @@ grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
   op->op.on_complete = &op->outer_on_complete;
   return &op->op;
 }
-
-namespace grpc_core {
-
-ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
-                                              Arena* arena) {
-  auto hdl = arena->MakePooled<ServerMetadata>(arena);
-  grpc_status_code code;
-  std::string message;
-  grpc_error_get_status(status, Timestamp::InfFuture(), &code, &message,
-                        nullptr, nullptr);
-  hdl->Set(GrpcStatusMetadata(), code);
-  if (!status.ok()) {
-    hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
-  }
-  return hdl;
-}
-
-std::string Message::DebugString() const {
-  std::string out = absl::StrCat(payload_.Length(), "b");
-  auto flags = flags_;
-  auto explain = [&flags, &out](uint32_t flag, absl::string_view name) {
-    if (flags & flag) {
-      flags &= ~flag;
-      absl::StrAppend(&out, ":", name);
-    }
-  };
-  explain(GRPC_WRITE_BUFFER_HINT, "write_buffer");
-  explain(GRPC_WRITE_NO_COMPRESS, "no_compress");
-  explain(GRPC_WRITE_THROUGH, "write_through");
-  explain(GRPC_WRITE_INTERNAL_COMPRESS, "compress");
-  explain(GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED, "was_compressed");
-  if (flags != 0) {
-    absl::StrAppend(&out, ":huh=0x", absl::Hex(flags));
-  }
-  return out;
-}
-
-}  // namespace grpc_core

data/src/core/lib/transport/transport.h

@@ -42,7 +42,6 @@
 
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/call_combiner.h"
@@ -53,12 +52,15 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/call_final_info.h"
+#include "src/core/lib/transport/call_spine.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/message.h"
+#include "src/core/lib/transport/metadata.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport_fwd.h"
 
@@ -70,83 +72,8 @@
 
 #define GRPC_ARG_TRANSPORT "grpc.internal.transport"
 
-/// Internal bit flag for grpc_begin_message's \a flags signaling the use of
-/// compression for the message. (Does not apply for stream compression.)
-#define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
-/// Internal bit flag for determining whether the message was compressed and had
-/// to be decompressed by the message_decompress filter. (Does not apply for
-/// stream compression.)
-#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
-/// Mask of all valid internal flags.
-#define GRPC_WRITE_INTERNAL_USED_MASK \
-  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
-
 namespace grpc_core {
 
-// Server metadata type
-// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using ServerMetadata = grpc_metadata_batch;
-using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
-
-// Client initial metadata type
-// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using ClientMetadata = grpc_metadata_batch;
-using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
-
-class Message {
- public:
-  Message() = default;
-  ~Message() = default;
-  Message(SliceBuffer payload, uint32_t flags)
-      : payload_(std::move(payload)), flags_(flags) {}
-  Message(const Message&) = delete;
-  Message& operator=(const Message&) = delete;
-
-  uint32_t flags() const { return flags_; }
-  uint32_t& mutable_flags() { return flags_; }
-  SliceBuffer* payload() { return &payload_; }
-  const SliceBuffer* payload() const { return &payload_; }
-
-  std::string DebugString() const;
-
- private:
-  SliceBuffer payload_;
-  uint32_t flags_ = 0;
-};
-
-using MessageHandle = Arena::PoolPtr<Message>;
-
-// Ok/not-ok check for trailing metadata, so that it can be used as result types
-// for TrySeq.
-inline bool IsStatusOk(const ServerMetadataHandle& m) {
-  return m->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
-         GRPC_STATUS_OK;
-}
-
-ServerMetadataHandle ServerMetadataFromStatus(
-    const absl::Status& status, Arena* arena = GetContext<Arena>());
-
-template <>
-struct StatusCastImpl<ServerMetadataHandle, absl::Status> {
-  static ServerMetadataHandle Cast(const absl::Status& m) {
-    return ServerMetadataFromStatus(m);
-  }
-};
-
-template <>
-struct StatusCastImpl<ServerMetadataHandle, const absl::Status&> {
-  static ServerMetadataHandle Cast(const absl::Status& m) {
-    return ServerMetadataFromStatus(m);
-  }
-};
-
-template <>
-struct StatusCastImpl<ServerMetadataHandle, absl::Status&> {
-  static ServerMetadataHandle Cast(const absl::Status& m) {
-    return ServerMetadataFromStatus(m);
-  }
-};
-
 // Move only type that tracks call startup.
 // Allows observation of when client_initial_metadata has been processed by the
 // end of the local call stack.
@@ -304,24 +231,6 @@ inline void grpc_stream_unref(grpc_stream_refcount* refcount) {
 grpc_slice grpc_slice_from_stream_owned_buffer(grpc_stream_refcount* refcount,
                                                void* buffer, size_t length);
 
-struct grpc_transport_one_way_stats {
-  uint64_t framing_bytes = 0;
-  uint64_t data_bytes = 0;
-  uint64_t header_bytes = 0;
-};
-
-struct grpc_transport_stream_stats {
-  grpc_transport_one_way_stats incoming;
-  grpc_transport_one_way_stats outgoing;
-  gpr_timespec latency = gpr_inf_future(GPR_TIMESPAN);
-};
-
-void grpc_transport_move_one_way_stats(grpc_transport_one_way_stats* from,
-                                       grpc_transport_one_way_stats* to);
-
-void grpc_transport_move_stats(grpc_transport_stream_stats* from,
-                               grpc_transport_stream_stats* to);
-
 // This struct (which is present in both grpc_transport_stream_op_batch
 // and grpc_transport_op_batch) is a convenience to allow filters or
 // transports to schedule a closure related to a particular batch without
@@ -633,9 +542,7 @@ class FilterStackTransport {
 
 class ClientTransport {
  public:
-  // Create a promise to execute one client call.
-  virtual ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args) = 0;
+  virtual void StartCall(CallHandler call_handler) = 0;
 
  protected:
   ~ClientTransport() = default;
@@ -643,10 +550,24 @@ class ClientTransport {
 
 class ServerTransport {
  public:
-  // Register the factory function for the filter stack part of a call
-  // promise.
-  void SetCallPromiseFactory(
-      absl::AnyInvocable<ArenaPromise<ServerMetadataHandle>(CallArgs) const>);
+  // Acceptor helps transports create calls.
+  class Acceptor {
+   public:
+    // Returns an arena that can be used to allocate memory for initial metadata
+    // parsing, and later passed to CreateCall() as the underlying arena for
+    // that call.
+    virtual Arena* CreateArena() = 0;
+    // Create a call at the server (or fail)
+    // arena must have been previously allocated by CreateArena()
+    virtual absl::StatusOr<CallInitiator> CreateCall(
+        ClientMetadata& client_initial_metadata, Arena* arena) = 0;
+
+   protected:
+    ~Acceptor() = default;
+  };
+
+  // Called once slightly after transport setup to register the accept function.
+  virtual void SetAcceptor(Acceptor* acceptor) = 0;
 
  protected:
   ~ServerTransport() = default;

data/src/core/load_balancing/address_filtering.cc

@@ -0,0 +1,108 @@
+//
+// Copyright 2020 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>
+
+#include "src/core/load_balancing/address_filtering.h"
+
+#include <stddef.h>
+
+#include <utility>
+
+#include "absl/functional/function_ref.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_core {
+
+absl::string_view HierarchicalPathArg::ChannelArgName() {
+  return GRPC_ARG_NO_SUBCHANNEL_PREFIX "address.hierarchical_path";
+}
+
+int HierarchicalPathArg::ChannelArgsCompare(const HierarchicalPathArg* a,
+                                            const HierarchicalPathArg* b) {
+  for (size_t i = 0; i < a->path_.size(); ++i) {
+    if (b->path_.size() == i) return 1;
+    int r = a->path_[i].as_string_view().compare(b->path_[i].as_string_view());
+    if (r != 0) return r;
+  }
+  if (b->path_.size() > a->path_.size()) return -1;
+  return 0;
+}
+
+namespace {
+
+class HierarchicalAddressIterator : public EndpointAddressesIterator {
+ public:
+  HierarchicalAddressIterator(
+      std::shared_ptr<EndpointAddressesIterator> parent_it,
+      RefCountedStringValue child_name)
+      : parent_it_(std::move(parent_it)), child_name_(std::move(child_name)) {}
+
+  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
+      const override {
+    RefCountedPtr<HierarchicalPathArg> remaining_path_attr;
+    parent_it_->ForEach([&](const EndpointAddresses& endpoint) {
+      const auto* path_arg = endpoint.args().GetObject<HierarchicalPathArg>();
+      if (path_arg == nullptr) return;
+      const std::vector<RefCountedStringValue>& path = path_arg->path();
+      auto it = path.begin();
+      if (it == path.end()) return;
+      if (*it != child_name_) return;
+      ChannelArgs args = endpoint.args();
+      ++it;
+      if (it != path.end()) {
+        std::vector<RefCountedStringValue> remaining_path(it, path.end());
+        if (remaining_path_attr == nullptr ||
+            remaining_path_attr->path() != remaining_path) {
+          remaining_path_attr =
+              MakeRefCounted<HierarchicalPathArg>(std::move(remaining_path));
+        }
+        args = args.SetObject(remaining_path_attr);
+      }
+      callback(EndpointAddresses(endpoint.addresses(), args));
+    });
+  }
+
+ private:
+  std::shared_ptr<EndpointAddressesIterator> parent_it_;
+  RefCountedStringValue child_name_;
+};
+
+}  // namespace
+
+absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses) {
+  if (!addresses.ok()) return addresses.status();
+  HierarchicalAddressMap result;
+  (*addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+    const auto* path_arg = endpoint.args().GetObject<HierarchicalPathArg>();
+    if (path_arg == nullptr) return;
+    const std::vector<RefCountedStringValue>& path = path_arg->path();
+    auto it = path.begin();
+    if (it == path.end()) return;
+    auto& target_list = result[*it];
+    if (target_list == nullptr) {
+      target_list =
+          std::make_shared<HierarchicalAddressIterator>(*addresses, *it);
+    }
+  });
+  return result;
+}
+
+}  // namespace grpc_core

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/address_filtering.h

@@ -14,12 +14,13 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_ADDRESS_FILTERING_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_ADDRESS_FILTERING_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_ADDRESS_FILTERING_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_ADDRESS_FILTERING_H
 
 #include <grpc/support/port_platform.h>
 
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -28,7 +29,7 @@
 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_string.h"
-#include "src/core/lib/resolver/endpoint_addresses.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 // The resolver returns a flat list of addresses.  When a hierarchy of
 // LB policies is in use, each leaf of the hierarchy will need a
@@ -105,13 +106,13 @@ class HierarchicalPathArg : public RefCounted<HierarchicalPathArg> {
 // A map from the next path element to the endpoint addresses that fall
 // under that path element.
 using HierarchicalAddressMap =
-    std::map<RefCountedStringValue, EndpointAddressesList,
+    std::map<RefCountedStringValue, std::shared_ptr<EndpointAddressesIterator>,
              RefCountedStringValueLessThan>;
 
 // Splits up the addresses into a separate list for each child.
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
-    const absl::StatusOr<EndpointAddressesList>& addresses);
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_ADDRESS_FILTERING_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_ADDRESS_FILTERING_H

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/backend_metric_data.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_BACKEND_METRIC_DATA_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_BACKEND_METRIC_DATA_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_BACKEND_METRIC_DATA_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_BACKEND_METRIC_DATA_H
 
 #include <grpc/support/port_platform.h>
 
@@ -54,4 +54,4 @@ struct BackendMetricData {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_BACKEND_METRIC_DATA_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_BACKEND_METRIC_DATA_H

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/child_policy_handler.cc

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
+#include "src/core/load_balancing/child_policy_handler.h"
 
 #include <memory>
 #include <string>
@@ -33,9 +33,9 @@
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/load_balancing/delegating_helper.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/load_balancing/delegating_helper.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
 namespace grpc_core {
@@ -272,7 +272,8 @@ void ChildPolicyHandler::ResetBackoffLocked() {
 
 OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
     absl::string_view child_policy_name, const ChannelArgs& args) {
-  Helper* helper = new Helper(Ref(DEBUG_LOCATION, "Helper"));
+  Helper* helper =
+      new Helper(RefAsSubclass<ChildPolicyHandler>(DEBUG_LOCATION, "Helper"));
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.channel_control_helper =

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/child_policy_handler.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_CHILD_POLICY_HANDLER_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_CHILD_POLICY_HANDLER_H
 #include <grpc/support/port_platform.h>
 
 #include <utility>
@@ -27,7 +27,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/load_balancing/lb_policy.h"
 
 namespace grpc_core {
 
@@ -85,4 +85,4 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_CHILD_POLICY_HANDLER_H

data/src/core/{lib/load_balancing → load_balancing}/delegating_helper.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
-#define GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_DELEGATING_HELPER_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_DELEGATING_HELPER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -32,8 +32,8 @@
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/load_balancing/lb_policy.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/lib/security/credentials/credentials.h"
 
 namespace grpc_core {
@@ -113,4 +113,4 @@ class LoadBalancingPolicy::ParentOwningDelegatingChannelControlHelper
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_DELEGATING_HELPER_H