grpc 1.43.1 → 1.48.0

data/src/core/lib/address_utils/parse_address.cc

@@ -21,25 +21,23 @@
 #include "src/core/lib/address_utils/parse_address.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #include <sys/un.h>
 #endif
-#ifdef GRPC_POSIX_SOCKET
-#include <errno.h>
-#include <net/if.h>
-#endif
+#include <string>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.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/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 
@@ -54,7 +52,7 @@ bool grpc_parse_unix(const grpc_core::URI& uri,
   }
   grpc_error_handle error =
       grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;
@@ -71,7 +69,7 @@ bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
   }
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;
@@ -318,3 +316,22 @@ uint16_t grpc_strhtons(const char* port) {
   }
   return htons(static_cast<unsigned short>(atoi(port)));
 }
+
+grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
+                                          const char* addr, int port) {
+  memset(out, 0, sizeof(grpc_resolved_address));
+  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
+  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
+  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
+    addr6->sin6_family = GRPC_AF_INET6;
+    out->len = sizeof(grpc_sockaddr_in6);
+  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
+    addr4->sin_family = GRPC_AF_INET;
+    out->len = sizeof(grpc_sockaddr_in);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
+  }
+  grpc_sockaddr_set_port(out, port);
+  return GRPC_ERROR_NONE;
+}

data/src/core/lib/address_utils/parse_address.h

@@ -21,11 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
+#include <stdint.h>
 
 #include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 /** Populate \a resolved_addr from \a uri, whose path is expected to contain a
@@ -61,6 +62,11 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
 /* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */
 uint16_t grpc_strhtons(const char* port);
 
+// Newer form of grpc_string_to_sockaddr which returns an error instead of
+// crashing if \a addr is not IPv6/IPv6
+grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
+                                          const char* addr, int port);
+
 namespace grpc_core {
 
 /** Populate \a resolved_addr to be a unix socket at |path| */

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -25,20 +25,55 @@
 #include <string.h>
 
 #include <string>
+#include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+#ifdef GRPC_HAVE_UNIX_SOCKET
+#include <sys/un.h>
+#endif
+
+#ifdef GRPC_HAVE_UNIX_SOCKET
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family != AF_UNIX) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Socket family is not AF_UNIX: ", addr->sa_family));
+  }
+  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  std::string scheme, path;
+  if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
+    scheme = "unix-abstract";
+    path = std::string(unix_addr->sun_path + 1,
+                       resolved_addr->len - sizeof(unix_addr->sun_family) - 1);
+  } else {
+    scheme = "unix";
+    path = unix_addr->sun_path;
+  }
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      std::move(scheme), /*authority=*/"", std::move(path),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  if (!uri.ok()) return uri.status();
+  return uri->ToString();
+}
+#else
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* /* addr */) {
+  return absl::InvalidArgumentError("Unix socket is not supported.");
+}
+#endif
 
 static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
                                           0, 0, 0, 0, 0xff, 0xff};
@@ -156,8 +191,8 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
 }
 
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
-                                    bool normalize) {
+absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* resolved_addr, bool normalize) {
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
@@ -165,6 +200,28 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   }
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  std::string out;
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  if (addr->sa_family == GRPC_AF_UNIX) {
+    const sockaddr_un* addr_un = reinterpret_cast<const sockaddr_un*>(addr);
+    bool abstract = addr_un->sun_path[0] == '\0';
+    if (abstract) {
+      int len = resolved_addr->len - sizeof(addr->sa_family);
+      if (len <= 0) {
+        return absl::InvalidArgumentError("empty UDS abstract path");
+      }
+      out = std::string(addr_un->sun_path, len);
+    } else {
+      size_t maxlen = sizeof(addr_un->sun_path);
+      if (strnlen(addr_un->sun_path, maxlen) == maxlen) {
+        return absl::InvalidArgumentError("UDS path is not null-terminated");
+      }
+      out = std::string(addr_un->sun_path);
+    }
+    return out;
+  }
+#endif
+
   const void* ip = nullptr;
   int port = 0;
   uint32_t sin6_scope_id = 0;
@@ -181,46 +238,30 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
     sin6_scope_id = addr6->sin6_scope_id;
   }
   char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  std::string out;
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
       // Enclose sin6_scope_id with the format defined in RFC 6874 section 2.
       std::string host_with_scope =
-          absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
+          absl::StrFormat("%s%%%" PRIu32, ntop_buf, sin6_scope_id);
       out = grpc_core::JoinHostPort(host_with_scope, port);
     } else {
       out = grpc_core::JoinHostPort(ntop_buf, port);
     }
   } else {
-    out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
+    return absl::InvalidArgumentError(
+        absl::StrCat("Unknown sockaddr family: ", addr->sa_family));
   }
   /* This is probably redundant, but we wouldn't want to log the wrong error. */
   errno = save_errno;
   return out;
 }
 
-grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
-                                          const char* addr, int port) {
-  memset(out, 0, sizeof(grpc_resolved_address));
-  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
-  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
-  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
-    addr6->sin6_family = GRPC_AF_INET6;
-    out->len = sizeof(grpc_sockaddr_in6);
-  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
-    addr4->sin_family = GRPC_AF_INET;
-    out->len = sizeof(grpc_sockaddr_in);
-  } else {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("Failed to parse address:", addr));
+absl::StatusOr<std::string> grpc_sockaddr_to_uri(
+    const grpc_resolved_address* resolved_addr) {
+  if (resolved_addr->len == 0) {
+    return absl::InvalidArgumentError("Empty address");
   }
-  grpc_sockaddr_set_port(out, port);
-  return GRPC_ERROR_NONE;
-}
-
-std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
-  if (resolved_addr->len == 0) return "";
   grpc_resolved_address addr_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
@@ -229,13 +270,13 @@ std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  std::string path =
-      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
-  std::string uri_str;
-  if (scheme != nullptr) {
-    uri_str = absl::StrCat(scheme, ":", path);
-  }
-  return uri_str;
+  auto path = grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
+  if (!path.ok()) return path;
+  absl::StatusOr<grpc_core::URI> uri =
+      grpc_core::URI::Create(scheme, /*authority=*/"", std::move(path.value()),
+                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  if (!uri.ok()) return uri.status();
+  return uri->ToString();
 }
 
 const char* grpc_sockaddr_get_uri_scheme(
@@ -269,10 +310,11 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
     case GRPC_AF_INET6:
       return grpc_ntohs(
           (reinterpret_cast<const grpc_sockaddr_in6*>(addr))->sin6_port);
+#ifdef GRPC_HAVE_UNIX_SOCKET
+    case AF_UNIX:
+      return 1;
+#endif
     default:
-      if (grpc_is_unix_socket(resolved_addr)) {
-        return 1;
-      }
       gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
               addr->sa_family);
       return 0;
@@ -399,14 +441,3 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
   }
   return false;
 }
-
-namespace grpc_event_engine {
-namespace experimental {
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
-  auto gra = CreateGRPCResolvedAddress(addr);
-  return grpc_sockaddr_to_uri(&gra);
-}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -21,11 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <string>
 
-#include <grpc/event_engine/event_engine.h>
+#include "absl/status/statusor.h"
 
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
    ::ffff:0.0.0.0/96 range, or false otherwise.
@@ -62,19 +64,15 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 
 // Converts a sockaddr into a newly-allocated human-readable string.
 //
-// Currently, only the AF_INET and AF_INET6 families are recognized.
+// Currently, only the AF_INET, AF_INET6, and AF_UNIX families are recognized.
 // If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
 // displayed as plain IPv4.
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
-                                    bool normalize) GRPC_MUST_USE_RESULT;
-
-// Newer form of grpc_string_to_sockaddr which returns an error instead of
-// crashing if \a addr is not IPv6/IPv6
-grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
-                                          const char* addr, int port);
+absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* addr, bool normalize) GRPC_MUST_USE_RESULT;
 
 /* Returns the URI string corresponding to \a addr */
-std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
+absl::StatusOr<std::string> grpc_sockaddr_to_uri(
+    const grpc_resolved_address* addr);
 
 /* Returns the URI scheme corresponding to \a addr */
 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
@@ -99,12 +97,4 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
                                 const grpc_resolved_address* subnet_address,
                                 uint32_t mask_bits);
 
-namespace grpc_event_engine {
-namespace experimental {
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
-
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
 #endif /* GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H */

data/src/core/lib/avl/avl.h

@@ -19,8 +19,10 @@
 
 #include <stdlib.h>
 
-#include <algorithm>
+#include <algorithm>  // IWYU pragma: keep
 #include <memory>
+#include <utility>
+#include <vector>
 
 namespace grpc_core {
 
@@ -32,8 +34,12 @@ class AVL {
   AVL Add(K key, V value) const {
     return AVL(AddKey(root_, std::move(key), std::move(value)));
   }
-  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
-  const V* Lookup(const K& key) const {
+  template <typename SomethingLikeK>
+  AVL Remove(const SomethingLikeK& key) const {
+    return AVL(RemoveKey(root_, key));
+  }
+  template <typename SomethingLikeK>
+  const V* Lookup(const SomethingLikeK& key) const {
     NodePtr n = Get(root_, key);
     return n ? &n->kv.second : nullptr;
   }
@@ -50,10 +56,40 @@ class AVL {
     ForEachImpl(root_.get(), std::forward<F>(f));
   }
 
-  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+  bool SameIdentity(const AVL& avl) const { return root_ == avl.root_; }
+
+  bool operator==(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q == nullptr;
+      if (q == nullptr) return false;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
+
+  bool operator<(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q != nullptr;
+      if (q == nullptr) return false;
+      if (p->kv < q->kv) return true;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
 
  private:
   struct Node;
+
   typedef std::shared_ptr<Node> NodePtr;
   struct Node : public std::enable_shared_from_this<Node> {
     Node(K k, V v, NodePtr l, NodePtr r, long h)
@@ -68,6 +104,32 @@ class AVL {
   };
   NodePtr root_;
 
+  class Iterator {
+   public:
+    explicit Iterator(const NodePtr& root) {
+      auto* n = root.get();
+      while (n != nullptr) {
+        stack_.push_back(n);
+        n = n->left.get();
+      }
+    }
+    Node* current() const { return stack_.empty() ? nullptr : stack_.back(); }
+    void MoveNext() {
+      auto* n = stack_.back();
+      stack_.pop_back();
+      if (n->right != nullptr) {
+        n = n->right.get();
+        while (n != nullptr) {
+          stack_.push_back(n);
+          n = n->left.get();
+        }
+      }
+    }
+
+   private:
+    std::vector<Node*> stack_;
+  };
+
   explicit AVL(NodePtr root) : root_(std::move(root)) {}
 
   template <class F>
@@ -86,7 +148,8 @@ class AVL {
                                   1 + std::max(Height(left), Height(right)));
   }
 
-  static NodePtr Get(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr Get(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }
@@ -198,7 +261,8 @@ class AVL {
     return node;
   }
 
-  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr RemoveKey(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }
@@ -246,6 +310,7 @@ class AVL<K, void> {
 
  private:
   struct Node;
+
   typedef std::shared_ptr<Node> NodePtr;
   struct Node : public std::enable_shared_from_this<Node> {
     Node(K k, NodePtr l, NodePtr r, long h)

data/src/core/lib/backoff/backoff.cc

@@ -22,50 +22,23 @@
 
 #include <algorithm>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
-namespace {
+BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
-/* Generate a random number between 0 and 1. We roll our own RNG because seeding
- * rand() modifies a global variable we have no control over. */
-double generate_uniform_random_number(uint32_t* rng_state) {
-  constexpr uint32_t two_raise_31 = uint32_t(1) << 31;
-  *rng_state = (1103515245 * *rng_state + 12345) % two_raise_31;
-  return *rng_state / static_cast<double>(two_raise_31);
-}
-
-double generate_uniform_random_number_between(uint32_t* rng_state, double a,
-                                              double b) {
-  if (a == b) return a;
-  if (a > b) std::swap(a, b);  // make sure a < b
-  const double range = b - a;
-  return a + generate_uniform_random_number(rng_state) * range;
-}
-
-}  // namespace
-
-BackOff::BackOff(const Options& options)
-    : options_(options),
-      rng_state_(static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec)) {
-  Reset();
-}
-
-grpc_millis BackOff::NextAttemptTime() {
+Timestamp BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
     return current_backoff_ + ExecCtx::Get()->Now();
   }
-  current_backoff_ = static_cast<grpc_millis>(
-      std::min(current_backoff_ * options_.multiplier(),
-               static_cast<double>(options_.max_backoff())));
-  const double jitter = generate_uniform_random_number_between(
-      &rng_state_, -options_.jitter() * current_backoff_,
-      options_.jitter() * current_backoff_);
-  const grpc_millis next_timeout =
-      static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + ExecCtx::Get()->Now();
+  current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                              options_.max_backoff());
+  const Duration jitter = Duration::FromSecondsAsDouble(
+      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_.seconds(),
+                    options_.jitter() * current_backoff_.seconds()));
+  return ExecCtx::Get()->Now() + current_backoff_ + jitter;
 }
 
 void BackOff::Reset() {
@@ -73,6 +46,4 @@ void BackOff::Reset() {
   initial_ = true;
 }
 
-void BackOff::SetRandomSeed(uint32_t seed) { rng_state_ = seed; }
-
 }  // namespace grpc_core

data/src/core/lib/backoff/backoff.h

@@ -21,7 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "absl/random/random.h"
+
+#include "src/core/lib/gprpp/time.h"
 
 namespace grpc_core {
 
@@ -35,17 +37,15 @@ class BackOff {
   explicit BackOff(const Options& options);
 
   /// Returns the time at which the next attempt should start.
-  grpc_millis NextAttemptTime();
+  Timestamp NextAttemptTime();
 
   /// Reset the backoff, so the next value returned by NextAttemptTime()
   /// will be the time of the second attempt (rather than the Nth).
   void Reset();
 
-  void SetRandomSeed(unsigned int seed);
-
   class Options {
    public:
-    Options& set_initial_backoff(grpc_millis initial_backoff) {
+    Options& set_initial_backoff(Duration initial_backoff) {
       initial_backoff_ = initial_backoff;
       return *this;
     }
@@ -57,32 +57,32 @@ class BackOff {
       jitter_ = jitter;
       return *this;
     }
-    Options& set_max_backoff(grpc_millis max_backoff) {
+    Options& set_max_backoff(Duration max_backoff) {
       max_backoff_ = max_backoff;
       return *this;
     }
     /// how long to wait after the first failure before retrying
-    grpc_millis initial_backoff() const { return initial_backoff_; }
+    Duration initial_backoff() const { return initial_backoff_; }
     /// factor with which to multiply backoff after a failed retry
     double multiplier() const { return multiplier_; }
     /// amount to randomize backoffs
     double jitter() const { return jitter_; }
     /// maximum time between retries
-    grpc_millis max_backoff() const { return max_backoff_; }
+    Duration max_backoff() const { return max_backoff_; }
 
    private:
-    grpc_millis initial_backoff_;
+    Duration initial_backoff_;
     double multiplier_;
     double jitter_;
-    grpc_millis max_backoff_;
+    Duration max_backoff_;
   };  // class Options
 
  private:
   const Options options_;
-  uint32_t rng_state_;
+  absl::BitGen rand_gen_;
   bool initial_;
   /// current delay before retries
-  grpc_millis current_backoff_;
+  Duration current_backoff_;
 };
 
 }  // namespace grpc_core