grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/lib/gprpp/table.h

@@ -21,7 +21,6 @@
 
 #include <initializer_list>
 #include <new>
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"

data/src/core/lib/gprpp/time.cc

@@ -17,6 +17,7 @@
 #include "src/core/lib/gprpp/time.h"
 
 #include <atomic>
+#include <chrono>
 #include <cstdint>
 #include <limits>
 #include <string>
@@ -190,6 +191,13 @@ std::string Duration::ToJsonString() const {
   return absl::StrFormat("%d.%09ds", ts.tv_sec, ts.tv_nsec);
 }
 
+Duration::operator grpc_event_engine::experimental::EventEngine::Duration()
+    const {
+  return std::chrono::milliseconds(
+      Clamp(millis_, std::numeric_limits<int64_t>::min() / GPR_NS_PER_MS,
+            std::numeric_limits<int64_t>::max() / GPR_NS_PER_MS));
+}
+
 void TestOnlySetProcessEpoch(gpr_timespec epoch) {
   g_process_epoch_seconds.store(
       gpr_convert_clock_type(epoch, GPR_CLOCK_MONOTONIC).tv_sec);

data/src/core/lib/gprpp/time.h

@@ -23,6 +23,7 @@
 #include <ostream>
 #include <string>
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/time.h>
 
@@ -207,6 +208,9 @@ class Duration {
   constexpr int64_t millis() const { return millis_; }
   double seconds() const { return static_cast<double>(millis_) / 1000.0; }
 
+  // NOLINTNEXTLINE: google-explicit-constructor
+  operator grpc_event_engine::experimental::EventEngine::Duration() const;
+
   gpr_timespec as_timespec() const;
 
   std::string ToString() const;

data/src/core/lib/gprpp/time_averaged_stats.cc

@@ -0,0 +1,60 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/time_averaged_stats.h"
+
+namespace grpc_core {
+
+TimeAveragedStats::TimeAveragedStats(double init_avg, double regress_weight,
+                                     double persistence_factor)
+    : init_avg_(init_avg),
+      regress_weight_(regress_weight),
+      persistence_factor_(persistence_factor) {}
+
+void TimeAveragedStats::AddSample(double value) {
+  batch_total_value_ += value;
+  ++batch_num_samples_;
+}
+
+double TimeAveragedStats::UpdateAverage() {
+  /* Start with the current batch: */
+  double weighted_sum = batch_total_value_;
+  double total_weight = batch_num_samples_;
+  if (regress_weight_ > 0) {
+    /* Add in the regression towards init_avg_: */
+    weighted_sum += regress_weight_ * init_avg_;
+    total_weight += regress_weight_;
+  }
+  if (persistence_factor_ > 0) {
+    /* Add in the persistence: */
+    const double prev_sample_weight =
+        persistence_factor_ * aggregate_total_weight_;
+    weighted_sum += prev_sample_weight * aggregate_weighted_avg_;
+    total_weight += prev_sample_weight;
+  }
+  aggregate_weighted_avg_ =
+      (total_weight > 0) ? (weighted_sum / total_weight) : init_avg_;
+  aggregate_total_weight_ = total_weight;
+  batch_num_samples_ = 0;
+  batch_total_value_ = 0;
+  return aggregate_weighted_avg_;
+}
+
+}  // namespace grpc_core

data/src/core/lib/{iomgr → gprpp}/time_averaged_stats.h

@@ -16,26 +16,42 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_IOMGR_TIME_AVERAGED_STATS_H
-#define GRPC_CORE_LIB_IOMGR_TIME_AVERAGED_STATS_H
+#ifndef GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
+#define GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
+
+namespace grpc_core {
 
 /* This tracks a time-decaying weighted average.  It works by collecting
    batches of samples and then mixing their average into a time-decaying
    weighted mean.  It is designed for batch operations where we do many adds
    before updating the average. */
 
-struct grpc_time_averaged_stats {
+class TimeAveragedStats {
+ public:
+  TimeAveragedStats(double init_avg, double regress_weight,
+                    double persistence_factor);
+
+  /* Add a sample to the current batch. */
+  void AddSample(double value);
+  /* Complete a batch and compute the new estimate of the average sample
+     value. */
+  double UpdateAverage();
+
+  double aggregate_weighted_avg() const { return aggregate_weighted_avg_; }
+  double aggregate_total_weight() const { return aggregate_total_weight_; }
+
+ private:
   /* The initial average value.  This is the reported average until the first
      grpc_time_averaged_stats_update_average call.  If a positive regress_weight
      is used, we also regress towards this value on each update. */
-  double init_avg;
+  const double init_avg_;
   /* The sample weight of "init_avg" that is mixed in with each call to
      grpc_time_averaged_stats_update_average.  If the calls to
      grpc_time_averaged_stats_add_sample stop, this will cause the average to
      regress back to the mean.  This should be non-negative.  Set it to 0 to
      disable the bias.  A value of 1 has the effect of adding in 1 bonus sample
      with value init_avg to each sample period. */
-  double regress_weight;
+  const double regress_weight_;
   /* This determines the rate of decay of the time-averaging from one period
      to the next by scaling the aggregate_total_weight of samples from prior
      periods when combining with the latest period.  It should be in the range
@@ -43,30 +59,21 @@ struct grpc_time_averaged_stats {
      batches each have k samples, the samples_in_avg_ will grow to 2 k, so the
      weighting of the time average will eventually be 1/3 new batch and 2/3
      old average. */
-  double persistence_factor;
+  const double persistence_factor_;
 
   /* The total value of samples since the last UpdateAverage(). */
-  double batch_total_value;
+  double batch_total_value_ = 0;
   /* The number of samples since the last UpdateAverage(). */
-  double batch_num_samples;
+  double batch_num_samples_ = 0;
   /* The time-decayed sum of batch_num_samples_ over previous batches.  This is
      the "weight" of the old aggregate_weighted_avg_ when updating the
      average. */
-  double aggregate_total_weight;
+  double aggregate_total_weight_ = 0;
   /* A time-decayed average of the (batch_total_value_ / batch_num_samples_),
      computed by decaying the samples_in_avg_ weight in the weighted average. */
-  double aggregate_weighted_avg;
+  double aggregate_weighted_avg_ = init_avg_;
 };
-/* See the comments on the members above for an explanation of init_avg,
-   regress_weight, and persistence_factor. */
-void grpc_time_averaged_stats_init(grpc_time_averaged_stats* stats,
-                                   double init_avg, double regress_weight,
-                                   double persistence_factor);
-/* Add a sample to the current batch. */
-void grpc_time_averaged_stats_add_sample(grpc_time_averaged_stats* stats,
-                                         double value);
-/* Complete a batch and compute the new estimate of the average sample
-   value. */
-double grpc_time_averaged_stats_update_average(grpc_time_averaged_stats* stats);
 
-#endif /* GRPC_CORE_LIB_IOMGR_TIME_AVERAGED_STATS_H */
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H */

data/src/core/lib/{iomgr → gprpp}/work_serializer.cc

@@ -1,29 +1,45 @@
-/*
- *
- * Copyright 2019 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 2019 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/lib/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/work_serializer.h"
+
+#include <stdint.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/mpscq.h"
+#include "src/core/lib/gprpp/orphanable.h"
 
 namespace grpc_core {
 
 DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
 
+//
+// WorkSerializer::WorkSerializerImpl
+//
+
 class WorkSerializer::WorkSerializerImpl : public Orphanable {
  public:
   void Run(std::function<void()> callback, const DebugLocation& location);

data/src/core/lib/{iomgr → gprpp}/work_serializer.h

@@ -1,37 +1,30 @@
-/*
- *
- * Copyright 2019 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 2019 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_LIB_GPRPP_WORK_SERIALIZER_H
+#define GRPC_CORE_LIB_GPRPP_WORK_SERIALIZER_H
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
 #include <functional>
 
-#include "absl/synchronization/mutex.h"
+#include "absl/base/thread_annotations.h"
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
 
 namespace grpc_core {
 
@@ -88,6 +81,6 @@ class ABSL_LOCKABLE WorkSerializer {
   OrphanablePtr<WorkSerializerImpl> impl_;
 };
 
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H */
+#endif  // GRPC_CORE_LIB_GPRPP_WORK_SERIALIZER_H

data/src/core/lib/http/format_request.cc

@@ -20,20 +20,21 @@
 
 #include "src/core/lib/http/format_request.h"
 
-#include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <algorithm>
+#include <string>
 #include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/http/httpcli.h"
 
 static void fill_common_header(const grpc_http_request* request,
                                const char* host, const char* path,

data/src/core/lib/http/format_request.h

@@ -23,7 +23,7 @@
 
 #include <grpc/slice.h>
 
-#include "src/core/lib/http/httpcli.h"
+#include "src/core/lib/http/parser.h"
 
 grpc_slice grpc_httpcli_format_get_request(const grpc_http_request* request,
                                            const char* host, const char* path);

data/src/core/lib/http/httpcli.cc

@@ -21,32 +21,37 @@
 #include "src/core/lib/http/httpcli.h"
 
 #include <limits.h>
-#include <string.h>
 
 #include <string>
+#include <utility>
 
 #include "absl/functional/bind_front.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/http/format_request.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/handshaker_registry.h"
 #include "src/core/lib/transport/tcp_connect_handshaker.h"
 
 namespace grpc_core {
@@ -159,7 +164,8 @@ HttpRequest::HttpRequest(
       channel_args_(CoreConfiguration::Get()
                         .channel_args_preconditioning()
                         .PreconditionChannelArgs(channel_args)
-                        .ToC()),
+                        .ToC()
+                        .release()),
       channel_creds_(std::move(channel_creds)),
       on_done_(on_done),
       resource_quota_(ResourceQuotaFromChannelArgs(channel_args_)),
@@ -203,9 +209,10 @@ void HttpRequest::Start() {
     return;
   }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_handle_ = GetDNSResolver()->ResolveName(
-      uri_.authority(), uri_.scheme(), pollset_set_,
-      absl::bind_front(&HttpRequest::OnResolved, this));
+  dns_request_handle_ = GetDNSResolver()->LookupHostname(
+      absl::bind_front(&HttpRequest::OnResolved, this), uri_.authority(),
+      uri_.scheme(), kDefaultDNSRequestTimeout, pollset_set_,
+      /*name_server=*/"");
 }
 
 void HttpRequest::Orphan() {
@@ -234,7 +241,7 @@ void HttpRequest::Orphan() {
 }
 
 void HttpRequest::AppendError(grpc_error_handle error) {
-  if (overall_error_ == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(overall_error_)) {
     overall_error_ =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
@@ -253,7 +260,7 @@ void HttpRequest::OnReadInternal(grpc_error_handle error) {
       have_read_byte_ = 1;
       grpc_error_handle err =
           grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
-      if (err != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(err)) {
         Finish(err);
         return;
       }
@@ -262,7 +269,7 @@ void HttpRequest::OnReadInternal(grpc_error_handle error) {
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "HTTP1 request cancelled during read", &overall_error_, 1));
-  } else if (error == GRPC_ERROR_NONE) {
+  } else if (GRPC_ERROR_IS_NONE(error)) {
     DoRead();
   } else if (!have_read_byte_) {
     NextAddress(GRPC_ERROR_REF(error));
@@ -275,7 +282,7 @@ void HttpRequest::ContinueDoneWriteAfterScheduleOnExecCtx(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(arg));
   MutexLock lock(&req->mu_);
-  if (error == GRPC_ERROR_NONE && !req->cancelled_) {
+  if (GRPC_ERROR_IS_NONE(error) && !req->cancelled_) {
     req->OnWritten();
   } else {
     req->NextAddress(GRPC_ERROR_REF(error));
@@ -300,13 +307,12 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
   }
   MutexLock lock(&req->mu_);
   req->own_endpoint_ = true;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     req->handshake_mgr_.reset();
     req->NextAddress(GRPC_ERROR_REF(error));
     return;
   }
   // Handshake completed, so we own fields in args
-  grpc_channel_args_destroy(args->args);
   grpc_slice_buffer_destroy_internal(args->read_buffer);
   gpr_free(args->read_buffer);
   req->ep_ = args->endpoint;
@@ -321,11 +327,10 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
 
 void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
   // Create the security connector using the credentials and target name.
-  grpc_channel_args* new_args_from_connector = nullptr;
+  ChannelArgs args = ChannelArgs::FromC(channel_args_);
   RefCountedPtr<grpc_channel_security_connector> sc =
       channel_creds_->create_security_connector(
-          nullptr /*call_creds*/, uri_.authority().c_str(), channel_args_,
-          &new_args_from_connector);
+          nullptr /*call_creds*/, uri_.authority().c_str(), &args);
   if (sc == nullptr) {
     Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "failed to create security connector", &overall_error_, 1));
@@ -337,34 +342,23 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
         "Failed to extract URI from address", &overall_error_, 1));
     return;
   }
-  absl::InlinedVector<grpc_arg, 2> args_to_add = {
-      grpc_security_connector_to_arg(sc.get()),
-      grpc_channel_arg_string_create(
-          const_cast<char*>(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS),
-          const_cast<char*>(address.value().c_str())),
-  };
-  const grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
-      new_args_from_connector != nullptr ? new_args_from_connector
-                                         : channel_args_,
-      args_to_add.data(), args_to_add.size());
-  grpc_channel_args_destroy(new_args_from_connector);
+  args = args.SetObject(std::move(sc))
+             .Set(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS, address.value());
   // Start the handshake
   handshake_mgr_ = MakeRefCounted<HandshakeManager>();
   CoreConfiguration::Get().handshaker_registry().AddHandshakers(
-      HANDSHAKER_CLIENT, new_args, pollset_set_, handshake_mgr_.get());
+      HANDSHAKER_CLIENT, args, pollset_set_, handshake_mgr_.get());
   Ref().release();  // ref held by pending handshake
   grpc_endpoint* ep = ep_;
   ep_ = nullptr;
   own_endpoint_ = false;
-  handshake_mgr_->DoHandshake(ep, new_args, deadline_,
+  handshake_mgr_->DoHandshake(ep, args, deadline_,
                               /*acceptor=*/nullptr, OnHandshakeDone,
                               /*user_data=*/this);
-  sc.reset(DEBUG_LOCATION, "httpcli");
-  grpc_channel_args_destroy(new_args);
 }
 
 void HttpRequest::NextAddress(grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     AppendError(error);
   }
   if (cancelled_) {

data/src/core/lib/http/httpcli.h

@@ -23,17 +23,33 @@
 
 #include <stddef.h>
 
-#include <grpc/support/time.h>
+#include <functional>
+#include <vector>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/http/parser.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#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/iomgr_internal.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
-#include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/uri/uri_parser.h"
 

data/src/core/lib/http/httpcli_security_connector.cc

@@ -20,24 +20,38 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#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/promise/arena_promise.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/handshaker.h"
 #include "src/core/tsi/ssl_transport_security.h"
+#include "src/core/tsi/transport_security_interface.h"
 
 namespace grpc_core {
 
@@ -71,7 +85,7 @@ class grpc_httpcli_ssl_channel_security_connector final
         &options, &handshaker_factory_);
   }
 
-  void add_handshakers(const grpc_channel_args* args,
+  void add_handshakers(const ChannelArgs& args,
                        grpc_pollset_set* /*interested_parties*/,
                        HandshakeManager* handshake_mgr) override {
     tsi_handshaker* handshaker = nullptr;
@@ -92,6 +106,7 @@ class grpc_httpcli_ssl_channel_security_connector final
   }
 
   void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
+                  const ChannelArgs& /*args*/,
                   RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
     grpc_error_handle error = GRPC_ERROR_NONE;
@@ -155,8 +170,7 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
  public:
   RefCountedPtr<grpc_channel_security_connector> create_security_connector(
       RefCountedPtr<grpc_call_credentials> /*call_creds*/, const char* target,
-      const grpc_channel_args* args,
-      grpc_channel_args** /*new_args*/) override {
+      ChannelArgs* args) override {
     const char* pem_root_certs = DefaultSslRootStore::GetPemRootCerts();
     const tsi_ssl_root_certs_store* root_store =
         DefaultSslRootStore::GetRootStore();
@@ -164,13 +178,11 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
       gpr_log(GPR_ERROR, "Could not get default pem root certs.");
       return nullptr;
     }
-    const char* ssl_host_override =
-        grpc_channel_args_find_string(args, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
-    if (ssl_host_override != nullptr) {
-      target = ssl_host_override;
-    }
-    return httpcli_ssl_channel_security_connector_create(pem_root_certs,
-                                                         root_store, target);
+    absl::optional<std::string> target_string =
+        args->GetOwnedString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)
+            .value_or(target);
+    return httpcli_ssl_channel_security_connector_create(
+        pem_root_certs, root_store, target_string->c_str());
   }
 
   RefCountedPtr<grpc_channel_credentials> duplicate_without_call_credentials()