grpc 1.61.0 → 1.62.0

data/src/core/lib/promise/party.h

@@ -53,6 +53,8 @@
 // There's a thought of fuzzing the two implementations against each other as
 // a correctness check of both, but that's not implemented yet.
 
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_party_state;
+
 #define GRPC_PARTY_SYNC_USING_ATOMICS
 // #define GRPC_PARTY_SYNC_USING_MUTEX
 
@@ -78,13 +80,17 @@ class PartySyncUsingAtomics {
       : state_(kOneRef * initial_refs) {}
 
   void IncrementRefCount() {
-    state_.fetch_add(kOneRef, std::memory_order_relaxed);
+    const uint64_t prev_state =
+        state_.fetch_add(kOneRef, std::memory_order_relaxed);
+    LogStateChange("IncrementRefCount", prev_state, prev_state + kOneRef);
   }
   GRPC_MUST_USE_RESULT bool RefIfNonZero();
   // Returns true if the ref count is now zero and the caller should call
   // PartyOver
   GRPC_MUST_USE_RESULT bool Unref() {
-    uint64_t prev_state = state_.fetch_sub(kOneRef, std::memory_order_acq_rel);
+    const uint64_t prev_state =
+        state_.fetch_sub(kOneRef, std::memory_order_acq_rel);
+    LogStateChange("Unref", prev_state, prev_state - kOneRef);
     if ((prev_state & kRefMask) == kOneRef) {
       return UnreffedLast();
     }
@@ -93,7 +99,9 @@ class PartySyncUsingAtomics {
   void ForceImmediateRepoll(WakeupMask mask) {
     // Or in the bit for the currently polling participant.
     // Will be grabbed next round to force a repoll of this promise.
-    state_.fetch_or(mask, std::memory_order_relaxed);
+    const uint64_t prev_state =
+        state_.fetch_or(mask, std::memory_order_relaxed);
+    LogStateChange("ForceImmediateRepoll", prev_state, prev_state | mask);
   }
 
   // Run the update loop: poll_one_participant is called with an integral index
@@ -107,6 +115,8 @@ class PartySyncUsingAtomics {
       // Grab the current state, and clear the wakeup bits & add flag.
       prev_state = state_.fetch_and(kRefMask | kLocked | kAllocatedMask,
                                     std::memory_order_acquire);
+      LogStateChange("Run", prev_state,
+                     prev_state & (kRefMask | kLocked | kAllocatedMask));
       GPR_ASSERT(prev_state & kLocked);
       if (prev_state & kDestroying) return true;
       // From the previous state, extract which participants we're to wakeup.
@@ -138,6 +148,8 @@ class PartySyncUsingAtomics {
         if (state_.compare_exchange_weak(
                 prev_state, (prev_state & (kRefMask | kAllocatedMask)),
                 std::memory_order_acq_rel, std::memory_order_acquire)) {
+          LogStateChange("Run:End", prev_state,
+                         prev_state & (kRefMask | kAllocatedMask));
           return false;
         }
       } else {
@@ -146,6 +158,8 @@ class PartySyncUsingAtomics {
                 (prev_state & (kRefMask | kAllocatedMask | kLocked)) |
                     wake_after_poll_,
                 std::memory_order_acq_rel, std::memory_order_acquire)) {
+          LogStateChange("Run:EndIteration", prev_state,
+                         prev_state & (kRefMask | kAllocatedMask));
           iteration_.fetch_add(1, std::memory_order_relaxed);
           wake_after_poll_ = 0;
         }
@@ -187,11 +201,14 @@ class PartySyncUsingAtomics {
     } while (!state_.compare_exchange_weak(
         state, (state | (allocated << kAllocatedShift)) + kOneRef,
         std::memory_order_acq_rel, std::memory_order_acquire));
+    LogStateChange("AddParticipantsAndRef", state,
+                   (state | (allocated << kAllocatedShift)) + kOneRef);
 
     store(slots);
 
     // Now we need to wake up the party.
     state = state_.fetch_or(wakeup_mask | kLocked, std::memory_order_release);
+    LogStateChange("AddParticipantsAndRef:Wakeup", state, state | kLocked);
 
     // If the party was already locked, we're done.
     return ((state & kLocked) == 0);
@@ -209,6 +226,15 @@ class PartySyncUsingAtomics {
  private:
   bool UnreffedLast();
 
+  void LogStateChange(const char* op, uint64_t prev_state, uint64_t new_state,
+                      DebugLocation loc = {}) {
+    if (grpc_trace_party_state.enabled()) {
+      gpr_log(loc.file(), loc.line(), GPR_LOG_SEVERITY_DEBUG,
+              "Party %p %30s: %016" PRIx64 " -> %016" PRIx64, this, op,
+              prev_state, new_state);
+    }
+  }
+
   // State bits:
   // The atomic state_ field is composed of the following:
   //   - 24 bits for ref counts
@@ -385,10 +411,10 @@ class Party : public Activity, private Wakeable {
   // This is useful for implementing batching and the like: we can hold some
   // action until the rest of the party resolves itself.
   auto AfterCurrentPoll() {
-    GPR_DEBUG_ASSERT(Activity::current() == this);
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == this);
     sync_.WakeAfterPoll(CurrentParticipant());
     return [this, iteration = sync_.iteration()]() -> Poll<Empty> {
-      GPR_DEBUG_ASSERT(Activity::current() == this);
+      GPR_DEBUG_ASSERT(GetContext<Activity>() == this);
       if (iteration == sync_.iteration()) return Pending{};
       return Empty{};
     };
@@ -561,7 +587,7 @@ class Party : public Activity, private Wakeable {
       GPR_NO_UNIQUE_ADDRESS Promise promise_;
       GPR_NO_UNIQUE_ADDRESS Result result_;
     };
-    Waker waiter_{Activity::current()->MakeOwningWaker()};
+    Waker waiter_{GetContext<Activity>()->MakeOwningWaker()};
     std::atomic<State> state_{State::kFactory};
   };
 
@@ -608,6 +634,11 @@ class Party : public Activity, private Wakeable {
   std::atomic<Participant*> participants_[party_detail::kMaxParticipants] = {};
 };
 
+template <>
+struct ContextSubclass<Party> {
+  using Base = Activity;
+};
+
 template <typename Factory, typename OnComplete>
 void Party::BulkSpawner::Spawn(absl::string_view name, Factory promise_factory,
                                OnComplete on_complete) {

data/src/core/lib/promise/pipe.h

@@ -374,7 +374,7 @@ class Center : public InterceptorList<T> {
   const T& value() const { return value_; }
 
   std::string DebugTag() {
-    if (auto* activity = Activity::current()) {
+    if (auto* activity = GetContext<Activity>()) {
       return absl::StrCat(activity->DebugTag(), " PIPE[0x", absl::Hex(this),
                           "]: ");
     } else {
@@ -638,11 +638,6 @@ class PipeReceiver {
   friend struct Pipe<T>;
   explicit PipeReceiver(pipe_detail::Center<T>* center) : center_(center) {}
   RefCountedPtr<pipe_detail::Center<T>> center_;
-
-  // Make failure to destruct show up in ASAN builds.
-#ifndef NDEBUG
-  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
-#endif
 };
 
 namespace pipe_detail {
@@ -661,7 +656,7 @@ class Push {
     if (center_ == nullptr) {
       if (grpc_trace_promise_primitives.enabled()) {
         gpr_log(GPR_DEBUG, "%s Pipe push has a null center",
-                Activity::current()->DebugTag().c_str());
+                GetContext<Activity>()->DebugTag().c_str());
       }
       return false;
     }

data/src/core/lib/promise/sleep.cc

@@ -54,7 +54,7 @@ Poll<absl::Status> Sleep::operator()() {
 }
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
-    : waker_(Activity::current()->MakeOwningWaker()),
+    : waker_(GetContext<Activity>()->MakeOwningWaker()),
       timer_handle_(GetContext<EventEngine>()->RunAfter(
           deadline - Timestamp::Now(), this)) {}
 

data/src/core/lib/promise/status_flag.h

@@ -27,8 +27,18 @@
 
 namespace grpc_core {
 
-struct Failure {};
-struct Success {};
+struct Failure {
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Failure) {
+    sink.Append("failed");
+  }
+};
+struct Success {
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Success) {
+    sink.Append("ok");
+  }
+};
 
 inline bool IsStatusOk(Failure) { return false; }
 inline bool IsStatusOk(Success) { return true; }
@@ -67,11 +77,31 @@ class StatusFlag {
   bool ok() const { return value_; }
 
   bool operator==(StatusFlag other) const { return value_ == other.value_; }
+  std::string ToString() const { return value_ ? "ok" : "failed"; }
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, StatusFlag flag) {
+    if (flag.ok()) {
+      sink.Append("ok");
+    } else {
+      sink.Append("failed");
+    }
+  }
 
  private:
   bool value_;
 };
 
+inline bool operator==(StatusFlag flag, Failure) { return !flag.ok(); }
+inline bool operator==(Failure, StatusFlag flag) { return !flag.ok(); }
+inline bool operator==(StatusFlag flag, Success) { return flag.ok(); }
+inline bool operator==(Success, StatusFlag flag) { return flag.ok(); }
+
+inline bool operator!=(StatusFlag flag, Failure) { return flag.ok(); }
+inline bool operator!=(Failure, StatusFlag flag) { return flag.ok(); }
+inline bool operator!=(StatusFlag flag, Success) { return !flag.ok(); }
+inline bool operator!=(Success, StatusFlag flag) { return !flag.ok(); }
+
 inline bool IsStatusOk(const StatusFlag& flag) { return flag.ok(); }
 
 template <>

data/src/core/lib/resource_quota/memory_quota.cc

@@ -232,10 +232,10 @@ Poll<RefCountedPtr<ReclaimerQueue::Handle>> ReclaimerQueue::PollNext() {
   if (!empty) {
     // If we don't, but the queue is probably not empty, schedule an immediate
     // repoll.
-    Activity::current()->ForceImmediateRepoll();
+    GetContext<Activity>()->ForceImmediateRepoll();
   } else {
     // Otherwise, schedule a wakeup for whenever something is pushed.
-    state_->waker = Activity::current()->MakeNonOwningWaker();
+    state_->waker = GetContext<Activity>()->MakeNonOwningWaker();
   }
   return Pending{};
 }
@@ -256,7 +256,7 @@ GrpcMemoryAllocatorImpl::~GrpcMemoryAllocatorImpl() {
   GPR_ASSERT(free_bytes_.load(std::memory_order_acquire) +
                  sizeof(GrpcMemoryAllocatorImpl) ==
              taken_bytes_.load(std::memory_order_relaxed));
-  memory_quota_->Return(taken_bytes_);
+  memory_quota_->Return(taken_bytes_.load(std::memory_order_relaxed));
 }
 
 void GrpcMemoryAllocatorImpl::Shutdown() {
@@ -465,7 +465,7 @@ void BasicMemoryQuota::Start() {
             self->reclamation_counter_.fetch_add(1, std::memory_order_relaxed) +
             1;
         reclaimer->Run(ReclamationSweep(
-            self, token, Activity::current()->MakeNonOwningWaker()));
+            self, token, GetContext<Activity>()->MakeNonOwningWaker()));
         // Return a promise that will wait for our barrier. This will be
         // awoken by the token above being destroyed. So, once that token is
         // destroyed, we'll be able to proceed.

data/src/core/lib/security/credentials/external/file_external_account_credentials.cc

@@ -27,7 +27,7 @@
 #include <grpc/slice.h>
 #include <grpc/support/json.h>
 
-#include "src/core/lib/iomgr/load_file.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_reader.h"
 #include "src/core/lib/slice/slice.h"
@@ -100,20 +100,14 @@ FileExternalAccountCredentials::FileExternalAccountCredentials(
 void FileExternalAccountCredentials::RetrieveSubjectToken(
     HTTPRequestContext* /*ctx*/, const Options& /*options*/,
     std::function<void(std::string, grpc_error_handle)> cb) {
-  struct SliceWrapper {
-    ~SliceWrapper() { CSliceUnref(slice); }
-    grpc_slice slice = grpc_empty_slice();
-  };
-  SliceWrapper content_slice;
   // To retrieve the subject token, we read the file every time we make a
   // request because it may have changed since the last request.
-  grpc_error_handle error =
-      grpc_load_file(file_.c_str(), 0, &content_slice.slice);
-  if (!error.ok()) {
-    cb("", error);
+  auto content_slice = LoadFile(file_, /*add_null_terminator=*/false);
+  if (!content_slice.ok()) {
+    cb("", content_slice.status());
     return;
   }
-  absl::string_view content = StringViewFromSlice(content_slice.slice);
+  absl::string_view content = content_slice->as_string_view();
   if (format_type_ == "json") {
     auto content_json = JsonParse(content);
     if (!content_json.ok() || content_json->type() != Json::Type::kObject) {

data/src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -38,11 +38,10 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.h"
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
@@ -54,7 +53,6 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/json/json.h"
@@ -70,6 +68,8 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/load_balancing/grpclb/grpclb.h"
+#include "src/core/load_balancing/xds/xds_channel_args.h"
 
 using grpc_core::Json;
 
@@ -260,18 +260,20 @@ static grpc_error_handle create_default_creds_from_path(
   grpc_auth_json_key key;
   grpc_auth_refresh_token token;
   grpc_core::RefCountedPtr<grpc_call_credentials> result;
-  grpc_slice creds_data = grpc_empty_slice();
+  absl::StatusOr<grpc_core::Slice> creds_data;
   grpc_error_handle error;
   Json json;
   if (creds_path.empty()) {
     error = GRPC_ERROR_CREATE("creds_path unset");
     goto end;
   }
-  error = grpc_load_file(creds_path.c_str(), 0, &creds_data);
-  if (!error.ok()) goto end;
+  creds_data = grpc_core::LoadFile(creds_path, /*add_null_terminator=*/false);
+  if (!creds_data.ok()) {
+    error = absl_status_to_grpc_error(creds_data.status());
+    goto end;
+  }
   {
-    auto json_or =
-        grpc_core::JsonParse(grpc_core::StringViewFromSlice(creds_data));
+    auto json_or = grpc_core::JsonParse(creds_data->as_string_view());
     if (!json_or.ok()) {
       error = absl_status_to_grpc_error(json_or.status());
       goto end;
@@ -281,7 +283,7 @@ static grpc_error_handle create_default_creds_from_path(
   if (json.type() != Json::Type::kObject) {
     error = grpc_error_set_str(GRPC_ERROR_CREATE("Failed to parse JSON"),
                                grpc_core::StatusStrProperty::kRawBytes,
-                               grpc_core::StringViewFromSlice(creds_data));
+                               creds_data->as_string_view());
     goto end;
   }
 
@@ -316,7 +318,6 @@ static grpc_error_handle create_default_creds_from_path(
 
 end:
   GPR_ASSERT((result == nullptr) + (error.ok()) == 1);
-  grpc_core::CSliceUnref(creds_data);
   *creds = result;
   return error;
 }

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc

@@ -45,12 +45,12 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/http/httpcli_ssl_credentials.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_reader.h"
@@ -314,7 +314,8 @@ grpc_oauth2_token_fetcher_credentials::GetRequestMetadata(
   auto pending_request =
       grpc_core::MakeRefCounted<grpc_oauth2_pending_get_request_metadata>();
   pending_request->pollent = grpc_core::GetContext<grpc_polling_entity>();
-  pending_request->waker = grpc_core::Activity::current()->MakeNonOwningWaker();
+  pending_request->waker =
+      grpc_core::GetContext<grpc_core::Activity>()->MakeNonOwningWaker();
   grpc_polling_entity_add_to_pollset_set(
       pending_request->pollent, grpc_polling_entity_pollset_set(&pollent_));
   pending_request->next = pending_requests_;
@@ -536,13 +537,14 @@ void MaybeAddToBody(const char* field_name, const char* field,
 }
 
 grpc_error_handle LoadTokenFile(const char* path, grpc_slice* token) {
-  grpc_error_handle err = grpc_load_file(path, 1, token);
-  if (!err.ok()) return err;
-  if (GRPC_SLICE_LENGTH(*token) == 0) {
+  auto slice = LoadFile(path, /*add_null_terminator=*/true);
+  if (!slice.ok()) return slice.status();
+  if (slice->length() == 0) {
     gpr_log(GPR_ERROR, "Token file %s is empty", path);
-    err = GRPC_ERROR_CREATE("Token file is empty.");
+    return GRPC_ERROR_CREATE("Token file is empty.");
   }
-  return err;
+  *token = slice->TakeCSlice();
+  return absl::OkStatus();
 }
 
 class StsTokenFetcherCredentials

data/src/core/lib/security/credentials/plugin/plugin_credentials.h

@@ -103,7 +103,7 @@ struct grpc_plugin_credentials final : public grpc_call_credentials {
    private:
     std::atomic<bool> ready_{false};
     grpc_core::Waker waker_{
-        grpc_core::Activity::current()->MakeNonOwningWaker()};
+        grpc_core::GetContext<grpc_core::Activity>()->MakeNonOwningWaker()};
     grpc_core::RefCountedPtr<grpc_plugin_credentials> call_creds_;
     grpc_auth_metadata_context context_;
     grpc_core::ClientMetadataHandle md_;

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -32,11 +32,11 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/gprpp/stat.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -280,17 +280,15 @@ absl::optional<std::string>
 FileWatcherCertificateProvider::ReadRootCertificatesFromFile(
     const std::string& root_cert_full_path) {
   // Read the root file.
-  grpc_slice root_slice = grpc_empty_slice();
-  grpc_error_handle root_error =
-      grpc_load_file(root_cert_full_path.c_str(), 0, &root_slice);
-  if (!root_error.ok()) {
+  auto root_slice =
+      LoadFile(root_cert_full_path, /*add_null_terminator=*/false);
+  if (!root_slice.ok()) {
     gpr_log(GPR_ERROR, "Reading file %s failed: %s",
-            root_cert_full_path.c_str(), StatusToString(root_error).c_str());
+            root_cert_full_path.c_str(),
+            root_slice.status().ToString().c_str());
     return absl::nullopt;
   }
-  std::string root_cert(StringViewFromSlice(root_slice));
-  CSliceUnref(root_slice);
-  return root_cert;
+  return std::string(root_slice->as_string_view());
 }
 
 namespace {
@@ -309,10 +307,6 @@ absl::optional<PemKeyCertPairList>
 FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
     const std::string& private_key_path,
     const std::string& identity_certificate_path) {
-  struct SliceWrapper {
-    grpc_slice slice = grpc_empty_slice();
-    ~SliceWrapper() { CSliceUnref(slice); }
-  };
   const int kNumRetryAttempts = 3;
   for (int i = 0; i < kNumRetryAttempts; ++i) {
     // TODO(ZhenLian): replace the timestamp approach with key-match approach
@@ -337,24 +331,22 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
       continue;
     }
     // Read the identity files.
-    SliceWrapper key_slice, cert_slice;
-    grpc_error_handle key_error =
-        grpc_load_file(private_key_path.c_str(), 0, &key_slice.slice);
-    if (!key_error.ok()) {
+    auto key_slice = LoadFile(private_key_path, /*add_null_terminator=*/false);
+    if (!key_slice.ok()) {
       gpr_log(GPR_ERROR, "Reading file %s failed: %s. Start retrying...",
-              private_key_path.c_str(), StatusToString(key_error).c_str());
+              private_key_path.c_str(), key_slice.status().ToString().c_str());
       continue;
     }
-    grpc_error_handle cert_error =
-        grpc_load_file(identity_certificate_path.c_str(), 0, &cert_slice.slice);
-    if (!cert_error.ok()) {
+    auto cert_slice =
+        LoadFile(identity_certificate_path, /*add_null_terminator=*/false);
+    if (!cert_slice.ok()) {
       gpr_log(GPR_ERROR, "Reading file %s failed: %s. Start retrying...",
               identity_certificate_path.c_str(),
-              StatusToString(cert_error).c_str());
+              cert_slice.status().ToString().c_str());
       continue;
     }
-    std::string private_key(StringViewFromSlice(key_slice.slice));
-    std::string cert_chain(StringViewFromSlice(cert_slice.slice));
+    std::string private_key(key_slice->as_string_view());
+    std::string cert_chain(cert_slice->as_string_view());
     PemKeyCertPairList identity_pairs;
     identity_pairs.emplace_back(private_key, cert_chain);
     // Checking the last modification of identity files before reading.

data/src/core/lib/security/credentials/xds/xds_credentials.cc

@@ -26,7 +26,6 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_certificate_provider.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
@@ -34,6 +33,7 @@
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
 #include "src/core/lib/security/credentials/tls/tls_credentials.h"
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
+#include "src/core/load_balancing/xds/xds_channel_args.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/security_connector/fake/fake_security_connector.cc

@@ -38,7 +38,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
@@ -58,6 +57,7 @@
 #include "src/core/lib/security/credentials/fake/fake_credentials.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
 #include "src/core/lib/transport/handshaker.h"
+#include "src/core/load_balancing/grpclb/grpclb.h"
 #include "src/core/tsi/fake_transport_security.h"
 #include "src/core/tsi/transport_security_interface.h"
 

data/src/core/lib/security/security_connector/load_system_roots_supported.cc

@@ -37,8 +37,8 @@
 
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 #include "src/core/lib/security/security_connector/load_system_roots_supported.h"
 
@@ -63,14 +63,10 @@ const char* kCertDirectories[] = {""};
 #endif                      // GPR_APPLE
 
 grpc_slice GetSystemRootCerts() {
-  grpc_slice valid_bundle_slice = grpc_empty_slice();
   size_t num_cert_files_ = GPR_ARRAY_SIZE(kCertFiles);
   for (size_t i = 0; i < num_cert_files_; i++) {
-    grpc_error_handle error =
-        grpc_load_file(kCertFiles[i], 1, &valid_bundle_slice);
-    if (error.ok()) {
-      return valid_bundle_slice;
-    }
+    auto slice = LoadFile(kCertFiles[i], /*add_null_terminator=*/true);
+    if (slice.ok()) return slice->TakeCSlice();
   }
   return grpc_empty_slice();
 }

data/src/core/lib/security/security_connector/local/local_security_connector.cc

@@ -37,7 +37,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/security/security_connector/ssl_utils.cc

@@ -44,8 +44,8 @@
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 #include "src/core/tsi/ssl_transport_security.h"
@@ -566,40 +566,49 @@ const char* DefaultSslRootStore::GetPemRootCerts() {
 }
 
 grpc_slice DefaultSslRootStore::ComputePemRootCerts() {
-  grpc_slice result = grpc_empty_slice();
+  Slice result;
   // First try to load the roots from the configuration.
-  auto default_root_certs_path = ConfigVars::Get().DefaultSslRootsFilePath();
+  std::string default_root_certs_path =
+      ConfigVars::Get().DefaultSslRootsFilePath();
   if (!default_root_certs_path.empty()) {
-    GRPC_LOG_IF_ERROR(
-        "load_file",
-        grpc_load_file(std::string(default_root_certs_path).c_str(), 1,
-                       &result));
+    auto slice =
+        LoadFile(default_root_certs_path, /*add_null_terminator=*/true);
+    if (!slice.ok()) {
+      gpr_log(GPR_ERROR, "error loading file %s: %s",
+              default_root_certs_path.c_str(),
+              slice.status().ToString().c_str());
+    } else {
+      result = std::move(*slice);
+    }
   }
   // Try overridden roots if needed.
   grpc_ssl_roots_override_result ovrd_res = GRPC_SSL_ROOTS_OVERRIDE_FAIL;
-  if (GRPC_SLICE_IS_EMPTY(result) && ssl_roots_override_cb != nullptr) {
+  if (result.empty() && ssl_roots_override_cb != nullptr) {
     char* pem_root_certs = nullptr;
     ovrd_res = ssl_roots_override_cb(&pem_root_certs);
     if (ovrd_res == GRPC_SSL_ROOTS_OVERRIDE_OK) {
       GPR_ASSERT(pem_root_certs != nullptr);
-      result = grpc_slice_from_copied_buffer(
+      result = Slice::FromCopiedBuffer(
           pem_root_certs,
           strlen(pem_root_certs) + 1);  // nullptr terminator.
     }
     gpr_free(pem_root_certs);
   }
   // Try loading roots from OS trust store if flag is enabled.
-  if (GRPC_SLICE_IS_EMPTY(result) &&
-      !ConfigVars::Get().NotUseSystemSslRoots()) {
-    result = LoadSystemRootCerts();
+  if (result.empty() && !ConfigVars::Get().NotUseSystemSslRoots()) {
+    result = Slice(LoadSystemRootCerts());
   }
   // Fallback to roots manually shipped with gRPC.
-  if (GRPC_SLICE_IS_EMPTY(result) &&
-      ovrd_res != GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY) {
-    GRPC_LOG_IF_ERROR("load_file",
-                      grpc_load_file(installed_roots_path, 1, &result));
+  if (result.empty() && ovrd_res != GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY) {
+    auto slice = LoadFile(installed_roots_path, /*add_null_terminator=*/true);
+    if (!slice.ok()) {
+      gpr_log(GPR_ERROR, "error loading file %s: %s", installed_roots_path,
+              slice.status().ToString().c_str());
+    } else {
+      result = std::move(*slice);
+    }
   }
-  return result;
+  return result.TakeCSlice();
 }
 
 void DefaultSslRootStore::InitRootStore() {