grpc 1.59.5 → 1.60.0.pre1

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

@@ -22,10 +22,9 @@
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 
 #include <memory>
+#include <type_traits>
 #include <utility>
 
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/log.h>
@@ -37,8 +36,6 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
-#include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -55,47 +52,38 @@ class FakeResolver : public Resolver {
 
  private:
   friend class FakeResolverResponseGenerator;
-  friend class FakeResolverResponseSetter;
 
   void ShutdownLocked() override;
 
   void MaybeSendResultLocked();
 
-  void ReturnReresolutionResult();
-
   // passed-in parameters
-  ChannelArgs channel_args_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
+  ChannelArgs channel_args_;
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
-  // If has_next_result_ is true, next_result_ is the next resolution result
-  // to be returned.
-  bool has_next_result_ = false;
-  Result next_result_;
-  // Result to use for the pretended re-resolution in
-  // RequestReresolutionLocked().
-  bool has_reresolution_result_ = false;
-  Result reresolution_result_;
+  // The next resolution result to be returned, if any.  Present when we
+  // get a result before the resolver is started.
+  absl::optional<Result> next_result_;
   // True after the call to StartLocked().
   bool started_ = false;
   // True after the call to ShutdownLocked().
   bool shutdown_ = false;
-  // if true, return failure
-  bool return_failure_ = false;
-  // pending re-resolution
-  bool reresolution_closure_pending_ = false;
 };
 
 FakeResolver::FakeResolver(ResolverArgs args)
     : work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
+      channel_args_(
+          // 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. Can't just use GRPC_ARG_NO_SUBCHANNEL_PREFIX, since
+          // that can't be passed into the channel from test code.
+          args.args.Remove(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR)),
       response_generator_(
           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.
-  channel_args_ = args.args.Remove(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
   if (response_generator_ != nullptr) {
     response_generator_->SetFakeResolver(Ref());
   }
@@ -107,19 +95,9 @@ void FakeResolver::StartLocked() {
 }
 
 void FakeResolver::RequestReresolutionLocked() {
-  if (has_reresolution_result_ || return_failure_) {
-    next_result_ = reresolution_result_;
-    has_next_result_ = true;
-    // Return the result in a different closure, so that we don't call
-    // back into the LB policy while it's still processing the previous
-    // update.
-    if (!reresolution_closure_pending_) {
-      reresolution_closure_pending_ = true;
-      Ref().release();  // ref held by closure
-      work_serializer_->Run([this]() { ReturnReresolutionResult(); },
-                            DEBUG_LOCATION);
-    }
-  }
+  // Re-resolution can't happen until after we return an initial result.
+  GPR_ASSERT(response_generator_ != nullptr);
+  response_generator_->ReresolutionRequested();
 }
 
 void FakeResolver::ShutdownLocked() {
@@ -132,80 +110,15 @@ void FakeResolver::ShutdownLocked() {
 
 void FakeResolver::MaybeSendResultLocked() {
   if (!started_ || shutdown_) return;
-  if (return_failure_) {
-    // TODO(roth): Change resolver result generator to be able to inject
-    // the error to be returned and to be able to independently set errors
-    // for addresses and service config.
-    Result result;
-    result.addresses = absl::UnavailableError("Resolver transient failure");
-    result.service_config = result.addresses.status();
-    result.args = channel_args_;
-    result_handler_->ReportResult(std::move(result));
-    return_failure_ = false;
-  } else if (has_next_result_) {
+  if (next_result_.has_value()) {
     // When both next_results_ and channel_args_ contain an arg with the same
-    // 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;
+    // name, use the one in next_results_.
+    next_result_->args = next_result_->args.UnionWith(channel_args_);
+    result_handler_->ReportResult(std::move(*next_result_));
+    next_result_.reset();
   }
 }
 
-void FakeResolver::ReturnReresolutionResult() {
-  reresolution_closure_pending_ = false;
-  MaybeSendResultLocked();
-  Unref();
-}
-
-class FakeResolverResponseSetter {
- public:
-  explicit FakeResolverResponseSetter(RefCountedPtr<FakeResolver> resolver,
-                                      Resolver::Result result,
-                                      bool has_result = false,
-                                      bool immediate = true)
-      : resolver_(std::move(resolver)),
-        result_(std::move(result)),
-        has_result_(has_result),
-        immediate_(immediate) {}
-  void SetResponseLocked();
-  void SetReresolutionResponseLocked();
-  void SetFailureLocked();
-
- private:
-  RefCountedPtr<FakeResolver> resolver_;
-  Resolver::Result result_;
-  bool has_result_;
-  bool immediate_;
-};
-
-// Deletes object when done
-void FakeResolverResponseSetter::SetReresolutionResponseLocked() {
-  if (!resolver_->shutdown_) {
-    resolver_->reresolution_result_ = std::move(result_);
-    resolver_->has_reresolution_result_ = has_result_;
-  }
-  delete this;
-}
-
-// Deletes object when done
-void FakeResolverResponseSetter::SetResponseLocked() {
-  if (!resolver_->shutdown_) {
-    resolver_->next_result_ = std::move(result_);
-    resolver_->has_next_result_ = true;
-    resolver_->MaybeSendResultLocked();
-  }
-  delete this;
-}
-
-// Deletes object when done
-void FakeResolverResponseSetter::SetFailureLocked() {
-  if (!resolver_->shutdown_) {
-    resolver_->return_failure_ = true;
-    if (immediate_) resolver_->MaybeSendResultLocked();
-  }
-  delete this;
-}
-
 //
 // FakeResolverResponseGenerator
 //
@@ -220,101 +133,73 @@ void FakeResolverResponseGenerator::SetResponseAndNotify(
   {
     MutexLock lock(&mu_);
     if (resolver_ == nullptr) {
-      has_result_ = true;
       result_ = std::move(result);
       if (notify_when_set != nullptr) notify_when_set->Notify();
       return;
     }
     resolver = resolver_->Ref();
   }
-  FakeResolverResponseSetter* arg =
-      new FakeResolverResponseSetter(resolver, std::move(result));
-  resolver->work_serializer_->Run(
-      [arg, notify_when_set]() {
-        arg->SetResponseLocked();
-        if (notify_when_set != nullptr) notify_when_set->Notify();
-      },
-      DEBUG_LOCATION);
+  SendResultToResolver(std::move(resolver), std::move(result), notify_when_set);
 }
 
-void FakeResolverResponseGenerator::SetReresolutionResponseAndNotify(
-    Resolver::Result result, Notification* notify_when_set) {
-  RefCountedPtr<FakeResolver> resolver;
+void FakeResolverResponseGenerator::SetFakeResolver(
+    RefCountedPtr<FakeResolver> resolver) {
+  Resolver::Result result;
   {
     MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
+    resolver_ = resolver;
+    if (resolver_set_cv_ != nullptr) resolver_set_cv_->SignalAll();
+    if (resolver == nullptr) return;
+    if (!result_.has_value()) return;
+    result = std::move(*result_);
+    result_.reset();
   }
-  FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
-      resolver, std::move(result), true /* has_result */);
-  resolver->work_serializer_->Run(
-      [arg, notify_when_set]() {
-        arg->SetReresolutionResponseLocked();
+  SendResultToResolver(std::move(resolver), std::move(result), nullptr);
+}
+
+void FakeResolverResponseGenerator::SendResultToResolver(
+    RefCountedPtr<FakeResolver> resolver, Resolver::Result result,
+    Notification* notify_when_set) {
+  auto* resolver_ptr = resolver.get();
+  resolver_ptr->work_serializer_->Run(
+      [resolver = std::move(resolver), result = std::move(result),
+       notify_when_set]() mutable {
+        if (!resolver->shutdown_) {
+          resolver->next_result_ = std::move(result);
+          resolver->MaybeSendResultLocked();
+        }
         if (notify_when_set != nullptr) notify_when_set->Notify();
       },
       DEBUG_LOCATION);
 }
 
-void FakeResolverResponseGenerator::UnsetReresolutionResponse() {
-  RefCountedPtr<FakeResolver> resolver;
-  {
-    MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
-  }
-  FakeResolverResponseSetter* arg =
-      new FakeResolverResponseSetter(resolver, Resolver::Result());
-  resolver->work_serializer_->Run(
-      [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
-}
-
-void FakeResolverResponseGenerator::SetFailure() {
-  RefCountedPtr<FakeResolver> resolver;
-  {
-    MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
-  }
-  FakeResolverResponseSetter* arg =
-      new FakeResolverResponseSetter(resolver, Resolver::Result());
-  resolver->work_serializer_->Run([arg]() { arg->SetFailureLocked(); },
-                                  DEBUG_LOCATION);
-}
-
-void FakeResolverResponseGenerator::SetFailureOnReresolution() {
-  RefCountedPtr<FakeResolver> resolver;
-  {
-    MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
+bool FakeResolverResponseGenerator::WaitForResolverSet(absl::Duration timeout) {
+  MutexLock lock(&mu_);
+  if (resolver_ == nullptr) {
+    CondVar condition;
+    resolver_set_cv_ = &condition;
+    condition.WaitWithTimeout(&mu_, timeout);
+    resolver_set_cv_ = nullptr;
   }
-  FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
-      resolver, Resolver::Result(), false /* has_result */,
-      false /* immediate */);
-  resolver->work_serializer_->Run([arg]() { arg->SetFailureLocked(); },
-                                  DEBUG_LOCATION);
+  return resolver_ != nullptr;
 }
 
-void FakeResolverResponseGenerator::SetFakeResolver(
-    RefCountedPtr<FakeResolver> resolver) {
-  MutexLock lock(&mu_);
-  resolver_ = std::move(resolver);
-  cv_.SignalAll();
-  if (resolver_ == nullptr) return;
-  if (has_result_) {
-    FakeResolverResponseSetter* arg =
-        new FakeResolverResponseSetter(resolver_, std::move(result_));
-    resolver_->work_serializer_->Run([arg]() { arg->SetResponseLocked(); },
-                                     DEBUG_LOCATION);
-    has_result_ = false;
+bool FakeResolverResponseGenerator::WaitForReresolutionRequest(
+    absl::Duration timeout) {
+  MutexLock lock(&reresolution_mu_);
+  if (!reresolution_requested_) {
+    CondVar condition;
+    reresolution_cv_ = &condition;
+    condition.WaitWithTimeout(&reresolution_mu_, timeout);
+    reresolution_cv_ = nullptr;
   }
+  return std::exchange(reresolution_requested_, false);
 }
 
-void FakeResolverResponseGenerator::WaitForResolverSet() {
-  MutexLock lock(&mu_);
-  while (resolver_ == nullptr) {
-    cv_.Wait(&mu_);
-  }
+void FakeResolverResponseGenerator::ReresolutionRequested() {
+  MutexLock lock(&reresolution_mu_);
+  reresolution_requested_ = true;
+  if (reresolution_cv_ != nullptr) reresolution_cv_->SignalAll();
 }
 
 namespace {
@@ -341,22 +226,6 @@ const grpc_arg_pointer_vtable
         ResponseGeneratorChannelArgCopy, ResponseGeneratorChannelArgDestroy,
         ResponseGeneratorChannelArgCmp};
 
-grpc_arg FakeResolverResponseGenerator::MakeChannelArg(
-    FakeResolverResponseGenerator* generator) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR), generator,
-      &kChannelArgPointerVtable);
-}
-
-RefCountedPtr<FakeResolverResponseGenerator>
-FakeResolverResponseGenerator::GetFromArgs(const grpc_channel_args* args) {
-  auto* response_generator =
-      grpc_channel_args_find_pointer<FakeResolverResponseGenerator>(
-          args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
-  if (response_generator == nullptr) return nullptr;
-  return response_generator->Ref();
-}
-
 //
 // Factory
 //

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

@@ -23,6 +23,8 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
 
@@ -42,8 +44,7 @@ class FakeResolver;
 
 /// A mechanism for generating responses for the fake resolver.
 /// An instance of this class is passed to the fake resolver via a channel
-/// argument (see \a MakeChannelArg()) and used to inject and trigger custom
-/// resolutions.
+/// argument and used to inject and trigger custom resolutions.
 // TODO(roth): I would ideally like this to be InternallyRefCounted
 // instead of RefCounted, but external refs are currently needed to
 // encode this in channel args.  Once channel_args are converted to C++,
@@ -77,50 +78,20 @@ class FakeResolverResponseGenerator
     n.WaitForNotification();
   }
 
-  // Sets the re-resolution response, which is returned by the fake resolver
-  // when re-resolution is requested (via \a RequestReresolutionLocked()).
-  // The new re-resolution response replaces any previous re-resolution
-  // response that may have been set by a previous call.
-  // notify_when_set is an optional notification to signal when the response has
-  // been set.
-  void SetReresolutionResponseAndNotify(Resolver::Result result,
-                                        Notification* notify_when_set);
-  void SetReresolutionResponseAsync(Resolver::Result result) {
-    SetReresolutionResponseAndNotify(std::move(result), nullptr);
-  }
-  void SetReresolutionResponseSynchronously(Resolver::Result result) {
-    Notification n;
-    SetReresolutionResponseAndNotify(std::move(result), &n);
-    n.WaitForNotification();
-  }
-
-  // Unsets the re-resolution response.  After this, the fake resolver will
-  // not return anything when \a RequestReresolutionLocked() is called.
-  void UnsetReresolutionResponse();
-
-  // Tells the resolver to return a transient failure.
-  void SetFailure();
-
-  // Same as SetFailure(), but instead of returning the error
-  // immediately, waits for the next call to RequestReresolutionLocked().
-  void SetFailureOnReresolution();
-
-  // Returns a channel arg containing \a generator.
-  // TODO(roth): When we have time, make this a non-static method.
-  static grpc_arg MakeChannelArg(FakeResolverResponseGenerator* generator);
+  // Waits up to timeout for a re-resolution request.  Returns true if a
+  // re-resolution request is seen, or false if timeout occurs.  Returns
+  // true immediately if there was a re-resolution request since the
+  // last time this method was called.
+  bool WaitForReresolutionRequest(absl::Duration timeout);
 
-  // Returns the response generator in \a args, or null if not found.
-  static RefCountedPtr<FakeResolverResponseGenerator> GetFromArgs(
-      const grpc_channel_args* args);
+  // Wait for a resolver to be set (setting may be happening asynchronously, so
+  // this may block - consider it test only).
+  bool WaitForResolverSet(absl::Duration timeout);
 
   static absl::string_view ChannelArgName() {
     return GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
   }
 
-  // Wait for a resolver to be set (setting may be happening asynchronously, so
-  // this may block - consider it test only).
-  void WaitForResolverSet();
-
   static int ChannelArgsCompare(const FakeResolverResponseGenerator* a,
                                 const FakeResolverResponseGenerator* b) {
     return QsortCompare(a, b);
@@ -128,15 +99,29 @@ class FakeResolverResponseGenerator
 
  private:
   friend class FakeResolver;
+
   // Set the corresponding FakeResolver to this generator.
   void SetFakeResolver(RefCountedPtr<FakeResolver> resolver);
 
+  // Called by FakeResolver when re-resolution is requested.
+  void ReresolutionRequested();
+
+  // Helper function to send a result to the resolver.
+  static void SendResultToResolver(RefCountedPtr<FakeResolver> resolver,
+                                   Resolver::Result result,
+                                   Notification* notify_when_set);
+
   // Mutex protecting the members below.
   Mutex mu_;
-  CondVar cv_;
+  CondVar* resolver_set_cv_ ABSL_GUARDED_BY(mu_) = nullptr;
   RefCountedPtr<FakeResolver> resolver_ ABSL_GUARDED_BY(mu_);
-  Resolver::Result result_ ABSL_GUARDED_BY(mu_);
-  bool has_result_ ABSL_GUARDED_BY(mu_) = false;
+  // Temporarily stores the result when it gets set before the response
+  // generator is seen by the FakeResolver.
+  absl::optional<Resolver::Result> result_ ABSL_GUARDED_BY(mu_);
+
+  Mutex reresolution_mu_;
+  CondVar* reresolution_cv_ ABSL_GUARDED_BY(reresolution_mu_) = nullptr;
+  bool reresolution_requested_ ABSL_GUARDED_BY(reresolution_mu_) = false;
 };
 
 }  // namespace grpc_core

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

@@ -28,7 +28,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
 #include <grpc/support/log.h>
@@ -39,6 +38,7 @@
 #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/resolver/endpoint_addresses.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/uri/uri_parser.h"
 

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

@@ -33,9 +33,9 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -44,7 +44,7 @@ namespace {
 
 class SockaddrResolver : public Resolver {
  public:
-  SockaddrResolver(ServerAddressList addresses, ResolverArgs args);
+  SockaddrResolver(EndpointAddressesList addresses, ResolverArgs args);
 
   void StartLocked() override;
 
@@ -52,11 +52,11 @@ class SockaddrResolver : public Resolver {
 
  private:
   std::unique_ptr<ResultHandler> result_handler_;
-  ServerAddressList addresses_;
+  EndpointAddressesList addresses_;
   ChannelArgs channel_args_;
 };
 
-SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
+SockaddrResolver::SockaddrResolver(EndpointAddressesList addresses,
                                    ResolverArgs args)
     : result_handler_(std::move(args.result_handler)),
       addresses_(std::move(addresses)),
@@ -75,7 +75,7 @@ void SockaddrResolver::StartLocked() {
 
 bool ParseUri(const URI& uri,
               bool parse(const URI& uri, grpc_resolved_address* dst),
-              ServerAddressList* addresses) {
+              EndpointAddressesList* addresses) {
   if (!uri.authority().empty()) {
     gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme",
             uri.scheme().c_str());
@@ -103,7 +103,7 @@ bool ParseUri(const URI& uri,
 
 OrphanablePtr<Resolver> CreateSockaddrResolver(
     ResolverArgs args, bool parse(const URI& uri, grpc_resolved_address* dst)) {
-  ServerAddressList addresses;
+  EndpointAddressesList addresses;
   if (!ParseUri(args.uri, parse, &addresses)) return nullptr;
   // Instantiate resolver.
   return MakeOrphanable<SockaddrResolver>(std::move(addresses),

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -16,12 +16,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h"
+
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
 #include <functional>
-#include <initializer_list>
 #include <map>
 #include <memory>
 #include <string>
@@ -45,12 +46,6 @@
 #include "re2/re2.h"
 
 #include <grpc/impl/channel_arg_names.h>
-
-#include "src/core/lib/slice/slice.h"
-
-#define XXH_INLINE_ALL
-#include "xxhash.h"
-
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
@@ -58,7 +53,6 @@
 #include "src/core/ext/filters/client_channel/client_channel_internal.h"
 #include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
-#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
@@ -83,16 +77,18 @@
 #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/gprpp/xxhash_inline.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/uri/uri_parser.h"
@@ -812,8 +808,8 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
       // Rotating the old value prevents duplicate hash rules from cancelling
       // each other out and preserves all of the entropy
       const uint64_t old_value =
-          hash.has_value() ? ((hash.value() << 1) | (hash.value() >> 63)) : 0;
-      hash = old_value ^ new_hash.value();
+          hash.has_value() ? ((*hash << 1) | (*hash >> 63)) : 0;
+      hash = old_value ^ *new_hash;
     }
     // If the policy is a terminal policy and a hash has been generated,
     // ignore the rest of the hash policies.
@@ -833,13 +829,8 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
   }
   args.service_config_call_data->SetCallAttribute(
       args.arena->New<XdsClusterAttribute>(cluster->cluster_name()));
-  std::string hash_string = absl::StrCat(hash.value());
-  char* hash_value =
-      static_cast<char*>(args.arena->Alloc(hash_string.size() + 1));
-  memcpy(hash_value, hash_string.c_str(), hash_string.size());
-  hash_value[hash_string.size()] = '\0';
   args.service_config_call_data->SetCallAttribute(
-      args.arena->New<RequestHashAttribute>(hash_value));
+      args.arena->New<RequestHashAttribute>(*hash));
   args.service_config_call_data->SetCallAttribute(
       args.arena->ManagedNew<XdsRouteStateAttributeImpl>(route_config_data_,
                                                          entry));

data/src/core/ext/filters/client_channel/retry_filter.cc

@@ -21,7 +21,6 @@
 #include <string>
 
 #include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 

data/src/core/ext/filters/client_channel/retry_filter_legacy_call_data.cc

@@ -20,7 +20,6 @@
 
 #include <memory>
 #include <new>
-#include <string>
 
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"