grpc 1.48.0-x86_64-linux → 1.49.1-x86_64-linux

data/src/core/lib/gpr/useful.h

@@ -23,6 +23,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+
 /** useful utilities that don't belong anywhere else */
 
 namespace grpc_core {
@@ -98,6 +101,32 @@ int QsortCompare(const T& a, const T& b) {
   return 0;
 }
 
+template <typename... X>
+int QsortCompare(const absl::variant<X...>& a, const absl::variant<X...>& b) {
+  const int index = QsortCompare(a.index(), b.index());
+  if (index != 0) return index;
+  return absl::visit(
+      [&](const auto& x) {
+        return QsortCompare(x, absl::get<absl::remove_cvref_t<decltype(x)>>(b));
+      },
+      a);
+}
+
+inline int QsortCompare(absl::string_view a, absl::string_view b) {
+  return a.compare(b);
+}
+
+inline int QsortCompare(const std::string& a, const std::string& b) {
+  return a.compare(b);
+}
+
+template <typename A, typename B>
+int QsortCompare(const std::pair<A, B>& a, const std::pair<A, B>& b) {
+  const int first = QsortCompare(a.first, b.first);
+  if (first != 0) return first;
+  return QsortCompare(a.second, b.second);
+}
+
 template <typename T>
 constexpr size_t HashPointer(T* p, size_t range) {
   return (((reinterpret_cast<size_t>(p)) >> 4) ^

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

@@ -24,12 +24,6 @@
 
 #include "src/core/lib/gpr/useful.h"
 
-#if __cplusplus > 201103l
-#define GRPC_BITSET_CONSTEXPR_MUTATOR constexpr
-#else
-#define GRPC_BITSET_CONSTEXPR_MUTATOR
-#endif
-
 namespace grpc_core {
 
 // Given a bit count as an integer, vend as member type `Type` a type with
@@ -90,12 +84,10 @@ class BitSet {
   constexpr BitSet() : units_{} {}
 
   // Set bit i to true
-  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i) {
-    units_[unit_for(i)] |= mask_for(i);
-  }
+  constexpr void set(int i) { units_[unit_for(i)] |= mask_for(i); }
 
   // Set bit i to is_set
-  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i, bool is_set) {
+  constexpr void set(int i, bool is_set) {
     if (is_set) {
       set(i);
     } else {
@@ -104,9 +96,7 @@ class BitSet {
   }
 
   // Set bit i to false
-  GRPC_BITSET_CONSTEXPR_MUTATOR void clear(int i) {
-    units_[unit_for(i)] &= ~mask_for(i);
-  }
+  constexpr void clear(int i) { units_[unit_for(i)] &= ~mask_for(i); }
 
   // Return true if bit i is set
   constexpr bool is_set(int i) const {

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

@@ -19,8 +19,39 @@
 #ifndef GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 #define GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_FILE)
+#define GRPC_DEFAULT_FILE __builtin_FILE()
+#endif
+#endif
+#ifndef GRPC_DEFAULT_FILE
+#define GRPC_DEFAULT_FILE "<unknown>"
+#endif
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_LINE)
+#define GRPC_DEFAULT_LINE __builtin_LINE()
+#endif
+#endif
+#ifndef GRPC_DEFAULT_LINE
+#define GRPC_DEFAULT_LINE -1
+#endif
+
 namespace grpc_core {
 
+class SourceLocation {
+ public:
+  // NOLINTNEXTLINE
+  SourceLocation(const char* file = GRPC_DEFAULT_FILE,
+                 int line = GRPC_DEFAULT_LINE)
+      : file_(file), line_(line) {}
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ private:
+  const char* file_;
+  int line_;
+};
+
 // Used for tracking file and line where a call is made for debug builds.
 // No-op for non-debug builds.
 // Callers can use the DEBUG_LOCATION macro in either case.
@@ -30,15 +61,15 @@ namespace grpc_core {
 // callers don't need to explicitly pass DEBUG_LOCATION anywhere.
 class DebugLocation {
  public:
-  DebugLocation(const char* file, int line) : file_(file), line_(line) {}
-  const char* file() const { return file_; }
-  int line() const { return line_; }
+  DebugLocation(const char* file = GRPC_DEFAULT_FILE,
+                int line = GRPC_DEFAULT_LINE)
+      : location_(file, line) {}
+  const char* file() const { return location_.file(); }
+  int line() const { return location_.line(); }
 
  private:
-  const char* file_;
-  const int line_;
+  SourceLocation location_;
 };
-#define DEBUG_LOCATION ::grpc_core::DebugLocation(__FILE__, __LINE__)
 #else
 class DebugLocation {
  public:
@@ -47,9 +78,10 @@ class DebugLocation {
   const char* file() const { return nullptr; }
   int line() const { return -1; }
 };
-#define DEBUG_LOCATION ::grpc_core::DebugLocation()
 #endif
 
+#define DEBUG_LOCATION ::grpc_core::DebugLocation(__FILE__, __LINE__)
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H */

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

@@ -25,7 +25,6 @@
 
 #include <stddef.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gprpp/construct_destruct.h"

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

@@ -0,0 +1,94 @@
+// 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_LIB_GPRPP_NO_DESTRUCT_H
+#define GRPC_CORE_LIB_GPRPP_NO_DESTRUCT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "src/core/lib/gprpp/construct_destruct.h"
+
+namespace grpc_core {
+
+// NoDestruct<T> is a wrapper around an object of type T that:
+// - stores the value inline - no heap allocation
+// - is non-copyable
+// - is eagerly constructed (i.e. the constructor is called when NoDestruct is
+//   constructed)
+// - *NEVER* calls ~T()
+// It's useful in cases where no ordering can be assumed between destructors of
+// objects that need to refer to each other - such as at program destruction
+// time.
+// Examples:
+//  // globally available object:
+//  static NoDestruct<Foo> g_foo(1, "foo", 2.0);
+//  // used as:
+//  g_foo->DoSomething();
+//  // singleton function:
+//  Bar* BarSingleton() {
+//   static NoDestruct<Bar> bar(1, "bar", 2.0);
+//   return &*bar;
+//  }
+// The globally available version is constructed at program startup, and the
+// singleton version is constructed at the first call to BarSingleton().
+// Neither Foo nor Bar instance will be destructed.
+template <typename T>
+class NoDestruct {
+ public:
+  template <typename... Args>
+  explicit NoDestruct(Args&&... args) {
+    static_assert(std::is_trivially_destructible<NoDestruct<T>>::value,
+                  "NoDestruct must be trivially destructible");
+    Construct(reinterpret_cast<T*>(&space_), std::forward<Args>(args)...);
+  }
+  NoDestruct(const NoDestruct&) = delete;
+  NoDestruct& operator=(const NoDestruct&) = delete;
+  ~NoDestruct() = default;
+
+  T* operator->() { return get(); }
+  const T* operator->() const { return get(); }
+  T& operator*() { return *get(); }
+  const T& operator*() const { return *get(); }
+
+  T* get() { return reinterpret_cast<T*>(&space_); }
+  const T* get() const { return reinterpret_cast<const T*>(&space_); }
+
+ private:
+  typename std::aligned_storage<sizeof(T), alignof(T)>::type space_;
+};
+
+// Helper for when a program desires a single *process wide* instance of a
+// default constructed T to be always available.
+// The instance is constructed eagerly at program startup, so it's essentially
+// free to load the pointer to the instance.
+template <typename T>
+class NoDestructSingleton {
+ public:
+  static T* Get() { return &*value_; }
+
+ private:
+  NoDestructSingleton() = delete;
+  ~NoDestructSingleton() = delete;
+
+  static NoDestruct<T> value_;
+};
+
+template <typename T>
+NoDestruct<T> NoDestructSingleton<T>::value_;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_NO_DESTRUCT_H

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <iosfwd>
-#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gprpp/debug_location.h"

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

@@ -34,6 +34,7 @@
 #include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
+#include "upb/arena.h"
 #include "upb/upb.h"
 #include "upb/upb.hpp"
 

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/{event_engine/iomgr_engine → gprpp}/time_averaged_stats.cc

@@ -18,10 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/time_averaged_stats.h"
+#include "src/core/lib/gprpp/time_averaged_stats.h"
 
-namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace grpc_core {
 
 TimeAveragedStats::TimeAveragedStats(double init_avg, double regress_weight,
                                      double persistence_factor)
@@ -58,5 +57,4 @@ double TimeAveragedStats::UpdateAverage() {
   return aggregate_weighted_avg_;
 }
 
-}  // namespace iomgr_engine
-}  // namespace grpc_event_engine
+}  // namespace grpc_core

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

@@ -16,11 +16,10 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H
+#ifndef GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
+#define GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
 
-namespace grpc_event_engine {
-namespace iomgr_engine {
+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
@@ -75,7 +74,6 @@ class TimeAveragedStats {
   double aggregate_weighted_avg_ = init_avg_;
 };
 
-}  // namespace iomgr_engine
-}  // namespace grpc_event_engine
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H */
+#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,36 +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
 
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_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"
 
 namespace grpc_core {
 
@@ -87,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/httpcli.cc

@@ -25,7 +25,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/functional/bind_front.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
@@ -165,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_)),
@@ -209,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() {
@@ -312,7 +313,6 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle 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;
@@ -327,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));
@@ -343,30 +342,19 @@ 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) {

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

@@ -20,9 +20,12 @@
 
 #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>
@@ -41,7 +44,6 @@
 #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/poll.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"
@@ -83,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;
@@ -104,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;
@@ -167,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();
@@ -176,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()