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

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -36,7 +36,7 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
@@ -59,8 +59,6 @@ class FakeResolver : public Resolver {
   friend class FakeResolverResponseGenerator;
   friend class FakeResolverResponseSetter;
 
-  ~FakeResolver() override;
-
   void ShutdownLocked() override;
 
   void MaybeSendResultLocked();
@@ -68,7 +66,7 @@ class FakeResolver : public Resolver {
   void ReturnReresolutionResult();
 
   // passed-in parameters
-  grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
@@ -94,21 +92,17 @@ FakeResolver::FakeResolver(ResolverArgs args)
     : work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       response_generator_(
-          FakeResolverResponseGenerator::GetFromArgs(args.args)) {
+          args.args.GetObjectRef<FakeResolverResponseGenerator>()) {
   // Channels sharing the same subchannels may have different resolver response
   // generators. If we don't remove this arg, subchannel pool will create new
   // subchannels for the same address instead of reusing existing ones because
   // of different values of this channel arg.
-  const char* args_to_remove[] = {GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR};
-  channel_args_ = grpc_channel_args_copy_and_remove(
-      args.args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove));
+  channel_args_ = args.args.Remove(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
   if (response_generator_ != nullptr) {
     response_generator_->SetFakeResolver(Ref());
   }
 }
 
-FakeResolver::~FakeResolver() { grpc_channel_args_destroy(channel_args_); }
-
 void FakeResolver::StartLocked() {
   started_ = true;
   MaybeSendResultLocked();
@@ -147,18 +141,14 @@ void FakeResolver::MaybeSendResultLocked() {
     Result result;
     result.addresses = absl::UnavailableError("Resolver transient failure");
     result.service_config = result.addresses.status();
-    result.args = grpc_channel_args_copy(channel_args_);
+    result.args = channel_args_;
     result_handler_->ReportResult(std::move(result));
     return_failure_ = false;
   } else if (has_next_result_) {
-    Result result;
-    result.addresses = std::move(next_result_.addresses);
-    result.service_config = std::move(next_result_.service_config);
     // When both next_results_ and channel_args_ contain an arg with the same
-    // name, only the one in next_results_ will be kept since next_results_ is
-    // before channel_args_.
-    result.args = grpc_channel_args_union(next_result_.args, channel_args_);
-    result_handler_->ReportResult(std::move(result));
+    // name, only the one in next_results_.
+    next_result_.args = next_result_.args.UnionWith(channel_args_);
+    result_handler_->ReportResult(std::move(next_result_));
     has_next_result_ = false;
   }
 }

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -20,9 +20,11 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -82,6 +84,15 @@ class FakeResolverResponseGenerator
   static RefCountedPtr<FakeResolverResponseGenerator> GetFromArgs(
       const grpc_channel_args* args);
 
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
+  }
+
+  static int ChannelArgsCompare(const FakeResolverResponseGenerator* a,
+                                const FakeResolverResponseGenerator* b) {
+    return QsortCompare(a, b);
+  }
+
  private:
   friend class FakeResolver;
   // Set the corresponding FakeResolver to this generator.

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -23,7 +23,6 @@
 #include <memory>
 #include <random>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/memory/memory.h"
@@ -40,7 +39,7 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/env.h"
@@ -49,18 +48,17 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/resolver_registry.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -216,7 +214,7 @@ void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
     grpc_error_handle error) {
   absl::StatusOr<std::string> zone;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     zone = absl::UnknownError(
         absl::StrCat("error fetching zone from metadata server: ",
                      grpc_error_std_string(error)));
@@ -257,11 +255,11 @@ GoogleCloud2ProdResolver::IPv6Query::IPv6Query(
 void GoogleCloud2ProdResolver::IPv6Query::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "error fetching IPv6 address from metadata server: %s",
             grpc_error_std_string(error).c_str());
   }
-  resolver->IPv6QueryDone(error == GRPC_ERROR_NONE && response->status == 200);
+  resolver->IPv6QueryDone(GRPC_ERROR_IS_NONE(error) && response->status == 200);
   GRPC_ERROR_UNREF(error);
 }
 
@@ -270,16 +268,17 @@ void GoogleCloud2ProdResolver::IPv6Query::OnDone(
 //
 
 GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
-    : resource_quota_(ResourceQuotaFromChannelArgs(args.args)),
+    : resource_quota_(args.args.GetObjectRef<ResourceQuota>()),
       work_serializer_(std::move(args.work_serializer)),
       pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)) {
   absl::string_view name_to_resolve = absl::StripPrefix(args.uri.path(), "/");
   // If we're not running on GCP, we can't use DirectPath, so delegate
   // to the DNS resolver.
-  bool test_only_pretend_running_on_gcp = grpc_channel_args_find_bool(
-      args.args, "grpc.testing.google_c2p_resolver_pretend_running_on_gcp",
-      false);
-  bool running_on_gcp =
+  const bool test_only_pretend_running_on_gcp =
+      args.args
+          .GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
+          .value_or(false);
+  const bool running_on_gcp =
       test_only_pretend_running_on_gcp || grpc_alts_is_running_on_gcp();
   if (!running_on_gcp ||
       // If the client is already using xDS, we can't use it here, because
@@ -297,13 +296,12 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
     return;
   }
   // Maybe override metadata server name for testing
-  const char* test_only_metadata_server_override =
-      grpc_channel_args_find_string(
-          args.args,
+  absl::optional<std::string> test_only_metadata_server_override =
+      args.args.GetOwnedString(
           "grpc.testing.google_c2p_resolver_metadata_server_override");
-  if (test_only_metadata_server_override != nullptr &&
-      strlen(test_only_metadata_server_override) > 0) {
-    metadata_server_name_ = std::string(test_only_metadata_server_override);
+  if (test_only_metadata_server_override.has_value() &&
+      !test_only_metadata_server_override->empty()) {
+    metadata_server_name_ = std::move(*test_only_metadata_server_override);
   }
   // Create xds resolver.
   child_resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(

data/src/core/ext/filters/client_channel/resolver/polling_resolver.cc

@@ -33,21 +33,21 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
 PollingResolver::PollingResolver(ResolverArgs args,
-                                 const grpc_channel_args* channel_args,
+                                 const ChannelArgs& channel_args,
                                  Duration min_time_between_resolutions,
                                  BackOff::Options backoff_options,
                                  TraceFlag* tracer)
     : authority_(args.uri.authority()),
       name_to_resolve_(absl::StripPrefix(args.uri.path(), "/")),
-      channel_args_(grpc_channel_args_copy(channel_args)),
+      channel_args_(channel_args),
       work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       tracer_(tracer),
@@ -63,7 +63,6 @@ PollingResolver::~PollingResolver() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     gpr_log(GPR_INFO, "[polling resolver %p] destroying", this);
   }
-  grpc_channel_args_destroy(channel_args_);
 }
 
 void PollingResolver::StartLocked() { MaybeStartResolvingLocked(); }
@@ -107,7 +106,7 @@ void PollingResolver::OnNextResolutionLocked(grpc_error_handle error) {
             this, grpc_error_std_string(error).c_str(), shutdown_);
   }
   have_next_resolution_timer_ = false;
-  if (error == GRPC_ERROR_NONE && !shutdown_) {
+  if (GRPC_ERROR_IS_NONE(error) && !shutdown_) {
     StartResolvingLocked();
   }
   Unref(DEBUG_LOCATION, "retry-timer");

data/src/core/ext/filters/client_channel/resolver/polling_resolver.h

@@ -24,17 +24,16 @@
 
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 
@@ -45,7 +44,7 @@ namespace grpc_core {
 // Implementations need only to implement StartRequest().
 class PollingResolver : public Resolver {
  public:
-  PollingResolver(ResolverArgs args, const grpc_channel_args* channel_args,
+  PollingResolver(ResolverArgs args, const ChannelArgs& channel_args,
                   Duration min_time_between_resolutions,
                   BackOff::Options backoff_options, TraceFlag* tracer);
   ~PollingResolver() override;
@@ -70,7 +69,7 @@ class PollingResolver : public Resolver {
   const std::string& authority() const { return authority_; }
   const std::string& name_to_resolve() const { return name_to_resolve_; }
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
-  const grpc_channel_args* channel_args() const { return channel_args_; }
+  const ChannelArgs& channel_args() const { return channel_args_; }
 
  private:
   void MaybeStartResolvingLocked();
@@ -86,7 +85,7 @@ class PollingResolver : public Resolver {
   /// name to resolve
   std::string name_to_resolve_;
   /// channel args
-  const grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
   TraceFlag* tracer_;

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -16,9 +16,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
 #include <memory>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/memory/memory.h"
@@ -26,7 +26,6 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
@@ -48,7 +47,6 @@ namespace {
 class SockaddrResolver : public Resolver {
  public:
   SockaddrResolver(ServerAddressList addresses, ResolverArgs args);
-  ~SockaddrResolver() override;
 
   void StartLocked() override;
 
@@ -57,25 +55,19 @@ class SockaddrResolver : public Resolver {
  private:
   std::unique_ptr<ResultHandler> result_handler_;
   ServerAddressList addresses_;
-  const grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
 };
 
 SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
                                    ResolverArgs args)
     : result_handler_(std::move(args.result_handler)),
       addresses_(std::move(addresses)),
-      channel_args_(grpc_channel_args_copy(args.args)) {}
-
-SockaddrResolver::~SockaddrResolver() {
-  grpc_channel_args_destroy(channel_args_);
-}
+      channel_args_(std::move(args.args)) {}
 
 void SockaddrResolver::StartLocked() {
   Result result;
   result.addresses = std::move(addresses_);
-  // TODO(roth): Use std::move() once channel args is converted to C++.
-  result.args = channel_args_;
-  channel_args_ = nullptr;
+  result.args = std::move(channel_args_);
   result_handler_->ReportResult(std::move(result));
 }
 
@@ -105,7 +97,7 @@ bool ParseUri(const URI& uri,
       break;
     }
     if (addresses != nullptr) {
-      addresses->emplace_back(addr, nullptr /* args */);
+      addresses->emplace_back(addr, ChannelArgs());
     }
   }
   return !errors_found;