grpc 1.82.0 → 1.83.0.pre1

data/src/core/lib/security/authorization/matchers.cc

@@ -30,13 +30,13 @@
 namespace grpc_core {
 
 std::unique_ptr<AuthorizationMatcher> AuthorizationMatcher::Create(
-    Rbac::Permission permission) {
+    const Rbac::Permission& permission) {
   switch (permission.type) {
     case Rbac::Permission::RuleType::kAnd: {
       std::vector<std::unique_ptr<AuthorizationMatcher>> matchers;
       matchers.reserve(permission.permissions.size());
       for (const auto& rule : permission.permissions) {
-        matchers.push_back(AuthorizationMatcher::Create(std::move(*rule)));
+        matchers.push_back(AuthorizationMatcher::Create(*rule));
       }
       return std::make_unique<AndAuthorizationMatcher>(std::move(matchers));
     }
@@ -44,43 +44,43 @@ std::unique_ptr<AuthorizationMatcher> AuthorizationMatcher::Create(
       std::vector<std::unique_ptr<AuthorizationMatcher>> matchers;
       matchers.reserve(permission.permissions.size());
       for (const auto& rule : permission.permissions) {
-        matchers.push_back(AuthorizationMatcher::Create(std::move(*rule)));
+        matchers.push_back(AuthorizationMatcher::Create(*rule));
       }
       return std::make_unique<OrAuthorizationMatcher>(std::move(matchers));
     }
     case Rbac::Permission::RuleType::kNot:
       return std::make_unique<NotAuthorizationMatcher>(
-          AuthorizationMatcher::Create(std::move(*permission.permissions[0])));
+          AuthorizationMatcher::Create(*permission.permissions[0]));
     case Rbac::Permission::RuleType::kAny:
       return std::make_unique<AlwaysAuthorizationMatcher>();
     case Rbac::Permission::RuleType::kHeader:
       return std::make_unique<HeaderAuthorizationMatcher>(
-          std::move(permission.header_matcher));
+          permission.header_matcher);
     case Rbac::Permission::RuleType::kPath:
       return std::make_unique<PathAuthorizationMatcher>(
-          std::move(permission.string_matcher));
+          permission.string_matcher);
     case Rbac::Permission::RuleType::kDestIp:
       return std::make_unique<IpAuthorizationMatcher>(
-          IpAuthorizationMatcher::Type::kDestIp, std::move(permission.ip));
+          IpAuthorizationMatcher::Type::kDestIp, permission.ip);
     case Rbac::Permission::RuleType::kDestPort:
       return std::make_unique<PortAuthorizationMatcher>(permission.port);
     case Rbac::Permission::RuleType::kMetadata:
       return std::make_unique<MetadataAuthorizationMatcher>(permission.invert);
     case Rbac::Permission::RuleType::kReqServerName:
       return std::make_unique<ReqServerNameAuthorizationMatcher>(
-          std::move(permission.string_matcher));
+          permission.string_matcher);
   }
   return nullptr;
 }
 
 std::unique_ptr<AuthorizationMatcher> AuthorizationMatcher::Create(
-    Rbac::Principal principal) {
+    const Rbac::Principal& principal) {
   switch (principal.type) {
     case Rbac::Principal::RuleType::kAnd: {
       std::vector<std::unique_ptr<AuthorizationMatcher>> matchers;
       matchers.reserve(principal.principals.size());
       for (const auto& id : principal.principals) {
-        matchers.push_back(AuthorizationMatcher::Create(std::move(*id)));
+        matchers.push_back(AuthorizationMatcher::Create(*id));
       }
       return std::make_unique<AndAuthorizationMatcher>(std::move(matchers));
     }
@@ -88,34 +88,33 @@ std::unique_ptr<AuthorizationMatcher> AuthorizationMatcher::Create(
       std::vector<std::unique_ptr<AuthorizationMatcher>> matchers;
       matchers.reserve(principal.principals.size());
       for (const auto& id : principal.principals) {
-        matchers.push_back(AuthorizationMatcher::Create(std::move(*id)));
+        matchers.push_back(AuthorizationMatcher::Create(*id));
       }
       return std::make_unique<OrAuthorizationMatcher>(std::move(matchers));
     }
     case Rbac::Principal::RuleType::kNot:
       return std::make_unique<NotAuthorizationMatcher>(
-          AuthorizationMatcher::Create(std::move(*principal.principals[0])));
+          AuthorizationMatcher::Create(*principal.principals[0]));
     case Rbac::Principal::RuleType::kAny:
       return std::make_unique<AlwaysAuthorizationMatcher>();
     case Rbac::Principal::RuleType::kPrincipalName:
       return std::make_unique<AuthenticatedAuthorizationMatcher>(
-          std::move(principal.string_matcher));
+          principal.string_matcher);
     case Rbac::Principal::RuleType::kSourceIp:
       return std::make_unique<IpAuthorizationMatcher>(
-          IpAuthorizationMatcher::Type::kSourceIp, std::move(principal.ip));
+          IpAuthorizationMatcher::Type::kSourceIp, principal.ip);
     case Rbac::Principal::RuleType::kDirectRemoteIp:
       return std::make_unique<IpAuthorizationMatcher>(
-          IpAuthorizationMatcher::Type::kDirectRemoteIp,
-          std::move(principal.ip));
+          IpAuthorizationMatcher::Type::kDirectRemoteIp, principal.ip);
     case Rbac::Principal::RuleType::kRemoteIp:
       return std::make_unique<IpAuthorizationMatcher>(
-          IpAuthorizationMatcher::Type::kRemoteIp, std::move(principal.ip));
+          IpAuthorizationMatcher::Type::kRemoteIp, principal.ip);
     case Rbac::Principal::RuleType::kHeader:
       return std::make_unique<HeaderAuthorizationMatcher>(
-          std::move(principal.header_matcher));
+          principal.header_matcher);
     case Rbac::Principal::RuleType::kPath:
       return std::make_unique<PathAuthorizationMatcher>(
-          std::move(principal.string_matcher.value()));
+          principal.string_matcher.value());
     case Rbac::Principal::RuleType::kMetadata:
       return std::make_unique<MetadataAuthorizationMatcher>(principal.invert);
   }
@@ -150,7 +149,8 @@ bool HeaderAuthorizationMatcher::Matches(const EvaluateArgs& args) const {
       args.GetHeaderValue(matcher_.name(), &concatenated_value));
 }
 
-IpAuthorizationMatcher::IpAuthorizationMatcher(Type type, Rbac::CidrRange range)
+IpAuthorizationMatcher::IpAuthorizationMatcher(Type type,
+                                               const Rbac::CidrRange& range)
     : type_(type), prefix_len_(range.prefix_len) {
   auto address =
       StringToSockaddr(range.address_prefix, 0);  // Port does not matter here.

data/src/core/lib/security/authorization/matchers.h

@@ -42,12 +42,12 @@ class AuthorizationMatcher {
   // Creates an instance of a matcher based off the rules defined in Permission
   // config.
   static std::unique_ptr<AuthorizationMatcher> Create(
-      Rbac::Permission permission);
+      const Rbac::Permission& permission);
 
   // Creates an instance of a matcher based off the rules defined in Principal
   // config.
   static std::unique_ptr<AuthorizationMatcher> Create(
-      Rbac::Principal principal);
+      const Rbac::Principal& principal);
 };
 
 class AlwaysAuthorizationMatcher : public AuthorizationMatcher {
@@ -113,8 +113,8 @@ class MetadataAuthorizationMatcher : public AuthorizationMatcher {
 // Perform a match against HTTP headers.
 class HeaderAuthorizationMatcher : public AuthorizationMatcher {
  public:
-  explicit HeaderAuthorizationMatcher(HeaderMatcher matcher)
-      : matcher_(std::move(matcher)) {}
+  explicit HeaderAuthorizationMatcher(const HeaderMatcher& matcher)
+      : matcher_(matcher) {}
 
   bool Matches(const EvaluateArgs& args) const override;
 
@@ -132,7 +132,7 @@ class IpAuthorizationMatcher : public AuthorizationMatcher {
     kRemoteIp,
   };
 
-  IpAuthorizationMatcher(Type type, Rbac::CidrRange range);
+  IpAuthorizationMatcher(Type type, const Rbac::CidrRange& range);
 
   bool Matches(const EvaluateArgs& args) const override;
 
@@ -158,8 +158,9 @@ class PortAuthorizationMatcher : public AuthorizationMatcher {
 // or DNS SAN in that order, otherwise uses subject field.
 class AuthenticatedAuthorizationMatcher : public AuthorizationMatcher {
  public:
-  explicit AuthenticatedAuthorizationMatcher(std::optional<StringMatcher> auth)
-      : matcher_(std::move(auth)) {}
+  explicit AuthenticatedAuthorizationMatcher(
+      const std::optional<StringMatcher>& auth)
+      : matcher_(auth) {}
 
   bool Matches(const EvaluateArgs& args) const override;
 
@@ -172,8 +173,8 @@ class AuthenticatedAuthorizationMatcher : public AuthorizationMatcher {
 class ReqServerNameAuthorizationMatcher : public AuthorizationMatcher {
  public:
   explicit ReqServerNameAuthorizationMatcher(
-      StringMatcher requested_server_name)
-      : matcher_(std::move(requested_server_name)) {}
+      const StringMatcher& requested_server_name)
+      : matcher_(requested_server_name) {}
 
   bool Matches(const EvaluateArgs&) const override;
 
@@ -184,8 +185,8 @@ class ReqServerNameAuthorizationMatcher : public AuthorizationMatcher {
 // Perform a match against the path header of HTTP request.
 class PathAuthorizationMatcher : public AuthorizationMatcher {
  public:
-  explicit PathAuthorizationMatcher(StringMatcher path)
-      : matcher_(std::move(path)) {}
+  explicit PathAuthorizationMatcher(const StringMatcher& path)
+      : matcher_(path) {}
 
   bool Matches(const EvaluateArgs& args) const override;
 
@@ -198,11 +199,9 @@ class PathAuthorizationMatcher : public AuthorizationMatcher {
 // of its permissions and a match in one of its principals.
 class PolicyAuthorizationMatcher : public AuthorizationMatcher {
  public:
-  explicit PolicyAuthorizationMatcher(Rbac::Policy policy)
-      : permissions_(
-            AuthorizationMatcher::Create(std::move(policy.permissions))),
-        principals_(
-            AuthorizationMatcher::Create(std::move(policy.principals))) {}
+  explicit PolicyAuthorizationMatcher(const Rbac::Policy& policy)
+      : permissions_(AuthorizationMatcher::Create(policy.permissions)),
+        principals_(AuthorizationMatcher::Create(policy.principals)) {}
 
   bool Matches(const EvaluateArgs& args) const override;
 

data/src/core/lib/security/authorization/rbac_policy.h

@@ -183,7 +183,7 @@ struct Rbac {
   std::map<std::string, Policy> policies;
 
   AuditCondition audit_condition;
-  std::vector<std::unique_ptr<experimental::AuditLoggerFactory::Config>>
+  std::vector<std::shared_ptr<const experimental::AuditLoggerFactory::Config>>
       logger_configs;
 };
 

data/src/core/lib/security/authorization/stdout_logger.cc

@@ -57,13 +57,13 @@ std::string StdoutAuditLoggerFactory::Config::ToString() const { return "{}"; }
 
 absl::string_view StdoutAuditLoggerFactory::name() const { return kName; }
 
-absl::StatusOr<std::unique_ptr<AuditLoggerFactory::Config>>
+absl::StatusOr<std::shared_ptr<const AuditLoggerFactory::Config>>
 StdoutAuditLoggerFactory::ParseAuditLoggerConfig(const Json&) {
-  return std::make_unique<StdoutAuditLoggerFactory::Config>();
+  return std::make_shared<StdoutAuditLoggerFactory::Config>();
 }
 
 std::unique_ptr<AuditLogger> StdoutAuditLoggerFactory::CreateAuditLogger(
-    std::unique_ptr<AuditLoggerFactory::Config> config) {
+    std::shared_ptr<const AuditLoggerFactory::Config> config) {
   // Sanity check.
   GRPC_CHECK(config != nullptr);
   GRPC_CHECK_EQ(config->name(), name());

data/src/core/lib/security/authorization/stdout_logger.h

@@ -28,30 +28,31 @@
 namespace grpc_core {
 namespace experimental {
 
-class StdoutAuditLogger : public AuditLogger {
+class StdoutAuditLogger final : public AuditLogger {
  public:
   StdoutAuditLogger() = default;
   absl::string_view name() const override { return "stdout_logger"; }
   void Log(const AuditContext&) override;
 };
 
-class StdoutAuditLoggerFactory : public AuditLoggerFactory {
+class StdoutAuditLoggerFactory final : public AuditLoggerFactory {
  public:
-  class Config : public AuditLoggerFactory::Config {
+  class Config final : public AuditLoggerFactory::Config {
    public:
     Config() = default;
     absl::string_view name() const override;
     std::string ToString() const override;
   };
+
   StdoutAuditLoggerFactory() = default;
 
   absl::string_view name() const override;
 
-  absl::StatusOr<std::unique_ptr<AuditLoggerFactory::Config>>
+  absl::StatusOr<std::shared_ptr<const AuditLoggerFactory::Config>>
   ParseAuditLoggerConfig(const Json& json) override;
 
   std::unique_ptr<AuditLogger> CreateAuditLogger(
-      std::unique_ptr<AuditLoggerFactory::Config>) override;
+      std::shared_ptr<const AuditLoggerFactory::Config> config) override;
 };
 
 }  // namespace experimental

data/src/core/lib/surface/call.cc

@@ -248,14 +248,6 @@ void Call::MaybeUnpublishFromParent() {
 }
 
 void Call::CancelWithStatus(grpc_status_code status, const char* description) {
-  if (!IsErrorFlattenEnabled()) {
-    CancelWithError(grpc_error_set_int(
-        grpc_error_set_str(
-            absl::Status(static_cast<absl::StatusCode>(status), description),
-            StatusStrProperty::kGrpcMessage, description),
-        StatusIntProperty::kRpcStatus, status));
-    return;
-  }
   if (status == GRPC_STATUS_OK) {
     VLOG(2) << "CancelWithStatus() called with OK status, using UNKNOWN";
     status = GRPC_STATUS_UNKNOWN;

data/src/core/lib/surface/call.h

@@ -70,6 +70,8 @@ typedef struct grpc_call_create_args {
 
   grpc_core::Timestamp send_deadline;
   bool registered_method;  // client_only
+
+  std::optional<absl::FunctionRef<void(grpc_core::Arena*)>> arena_init_function;
 } grpc_call_create_args;
 
 namespace grpc_core {

data/src/core/lib/surface/channel.cc

@@ -22,6 +22,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -112,7 +114,8 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
           ? std::optional<grpc_core::Slice>(grpc_core::CSliceRef(*host))
           : std::nullopt,
       grpc_core::Timestamp::FromTimespecRoundUp(deadline),
-      /*registered_method=*/false);
+      /*registered_method=*/false,
+      /*arena_init_function=*/std::nullopt);
 }
 
 void* grpc_channel_register_call(grpc_channel* channel, const char* method,
@@ -148,7 +151,23 @@ grpc_call* grpc_channel_create_registered_call(
           ? std::optional<grpc_core::Slice>(rc->authority->Ref())
           : std::nullopt,
       grpc_core::Timestamp::FromTimespecRoundUp(deadline),
-      /*registered_method=*/true);
+      /*registered_method=*/true,
+      /*arena_init_function=*/std::nullopt);
+}
+
+grpc_call* grpc_channel_create_call_with_arena_init(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, grpc_core::Slice method,
+    std::optional<grpc_core::Slice> authority, gpr_timespec deadline,
+    bool registered_method,
+    std::optional<absl::FunctionRef<void(grpc_core::Arena*)>>
+        arena_init_function) {
+  grpc_core::ExecCtx exec_ctx;
+  return grpc_core::Channel::FromC(channel)->CreateCall(
+      parent_call, propagation_mask, completion_queue, nullptr,
+      std::move(method), std::move(authority),
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline), registered_method,
+      arena_init_function);
 }
 
 char* grpc_channel_get_target(grpc_channel* channel) {

data/src/core/lib/surface/channel.h

@@ -73,12 +73,12 @@ class Channel : public UnstartedCallDestination,
   virtual bool IsLame() const = 0;
 
   // TODO(roth): This should return a C++ type.
-  virtual grpc_call* CreateCall(grpc_call* parent_call,
-                                uint32_t propagation_mask,
-                                grpc_completion_queue* cq,
-                                grpc_pollset_set* pollset_set_alternative,
-                                Slice path, std::optional<Slice> authority,
-                                Timestamp deadline, bool registered_method) = 0;
+  virtual grpc_call* CreateCall(
+      grpc_call* parent_call, uint32_t propagation_mask,
+      grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
+      Slice path, std::optional<Slice> authority, Timestamp deadline,
+      bool registered_method,
+      std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) = 0;
 
   virtual grpc_event_engine::experimental::EventEngine* event_engine()
       const = 0;
@@ -178,4 +178,12 @@ inline grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
 void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
                        void* tag, void* reserved);
 
+grpc_call* grpc_channel_create_call_with_arena_init(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, grpc_core::Slice method,
+    std::optional<grpc_core::Slice> authority, gpr_timespec deadline,
+    bool registered_method,
+    std::optional<absl::FunctionRef<void(grpc_core::Arena*)>>
+        arena_init_function);
+
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_H

data/src/core/lib/surface/filter_stack_call.cc

@@ -111,6 +111,9 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   RefCountedPtr<Arena> arena = channel->call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       args->channel->event_engine());
+  if (args->arena_init_function.has_value()) {
+    (*args->arena_init_function)(arena.get());
+  }
   call = new (arena->Alloc(call_alloc_size)) FilterStackCall(arena, *args);
   GRPC_DCHECK(FromC(call->c_ptr()) == call);
   GRPC_DCHECK(FromCallStack(call->call_stack()) == call);
@@ -458,32 +461,10 @@ void FilterStackCall::RecvTrailingFilter(grpc_metadata_batch* b,
   } else {
     std::optional<grpc_status_code> grpc_status = b->Take(GrpcStatusMetadata());
     if (grpc_status.has_value()) {
-      grpc_error_handle error;
-      if (IsErrorFlattenEnabled()) {
-        auto grpc_message = b->Take(GrpcMessageMetadata());
-        absl::string_view message;
-        if (grpc_message.has_value()) message = grpc_message->as_string_view();
-        error =
-            absl::Status(static_cast<absl::StatusCode>(*grpc_status), message);
-      } else {
-        grpc_status_code status_code = *grpc_status;
-        if (status_code != GRPC_STATUS_OK) {
-          Slice peer = GetPeerString();
-          error = grpc_error_set_int(
-              GRPC_ERROR_CREATE(absl::StrCat("Error received from peer ",
-                                             peer.as_string_view())),
-              StatusIntProperty::kRpcStatus,
-              static_cast<intptr_t>(status_code));
-        }
-        auto grpc_message = b->Take(GrpcMessageMetadata());
-        if (grpc_message.has_value()) {
-          error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage,
-                                     grpc_message->as_string_view());
-        } else if (!error.ok()) {
-          error =
-              grpc_error_set_str(error, StatusStrProperty::kGrpcMessage, "");
-        }
-      }
+      auto grpc_message = b->Take(GrpcMessageMetadata());
+      absl::string_view message;
+      if (grpc_message.has_value()) message = grpc_message->as_string_view();
+      absl::Status error(static_cast<absl::StatusCode>(*grpc_status), message);
       SetFinalStatus(error);
     } else if (!is_client()) {
       SetFinalStatus(absl::OkStatus());
@@ -929,10 +910,10 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
               Slice(grpc_slice_copy(
                   *op->data.send_status_from_server.status_details)));
           if (!status_error.ok()) {
-            status_error = grpc_error_set_str(
-                status_error, StatusStrProperty::kGrpcMessage,
+            status_error = AddMessageDetail(
                 StringViewFromSlice(
-                    *op->data.send_status_from_server.status_details));
+                    *op->data.send_status_from_server.status_details),
+                status_error);
           }
         }
 

data/src/core/lib/surface/legacy_channel.cc

@@ -160,13 +160,12 @@ bool LegacyChannel::IsLame() const {
   return elem->filter == &LameClientFilter::kFilter;
 }
 
-grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
-                                     uint32_t propagation_mask,
-                                     grpc_completion_queue* cq,
-                                     grpc_pollset_set* pollset_set_alternative,
-                                     Slice path, std::optional<Slice> authority,
-                                     Timestamp deadline,
-                                     bool registered_method) {
+grpc_call* LegacyChannel::CreateCall(
+    grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
+    Slice path, std::optional<Slice> authority, Timestamp deadline,
+    bool registered_method,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   GRPC_CHECK(is_client_);
   GRPC_CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
   grpc_call_create_args args;
@@ -181,6 +180,7 @@ grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
   args.authority = std::move(authority);
   args.send_deadline = deadline;
   args.registered_method = registered_method;
+  args.arena_init_function = arena_init_function;
   grpc_call* call;
   GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call));
   return call;

data/src/core/lib/surface/legacy_channel.h

@@ -62,7 +62,9 @@ class LegacyChannel final : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* pollset_set_alternative, Slice path,
                         std::optional<Slice> authority, Timestamp deadline,
-                        bool registered_method) override;
+                        bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
 
   void StartCall(UnstartedCallHandler) override {
     Crash("StartCall() not supported on LegacyChannel");

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "55.0.0"; }
+const char* grpc_version_string(void) { return "56.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "glacier"; }
+const char* grpc_g_stands_for(void) { return "garden"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -33,23 +33,23 @@ namespace grpc_core {
 
 BdpEstimator::BdpEstimator(absl::string_view name)
     : accumulator_(0),
-      estimate_(65536),
+      estimate_(kInitialBdpDefault),
       ping_start_time_(gpr_time_0(GPR_CLOCK_MONOTONIC)),
-      inter_ping_delay_(Duration::Milliseconds(100)),  // start at 100ms
+      inter_ping_delay_(Duration::Milliseconds(kDefaultInterPingDelayMillis)),
       stable_estimate_count_(0),
       ping_state_(PingState::UNSCHEDULED),
       bw_est_(0),
-      name_(name) {}
+      peer_name_(name) {}
 
 Timestamp BdpEstimator::CompletePing() {
-  gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
-  gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
-  double dt = static_cast<double>(dt_ts.tv_sec) +
-              (1e-9 * static_cast<double>(dt_ts.tv_nsec));
-  double bw = dt > 0 ? (static_cast<double>(accumulator_) / dt) : 0;
-  Duration start_inter_ping_delay = inter_ping_delay_;
+  const gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
+  const gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
+  const double dt = static_cast<double>(dt_ts.tv_sec) +
+                    (1e-9 * static_cast<double>(dt_ts.tv_nsec));
+  const double bw = (dt > 0) ? (static_cast<double>(accumulator_) / dt) : 0;
+  const Duration start_inter_ping_delay = inter_ping_delay_;
   GRPC_TRACE_LOG(bdp_estimator, INFO)
-      << "bdp[" << name_ << "]:complete acc=" << accumulator_
+      << "bdp[" << peer_name_ << "]:complete acc=" << accumulator_
       << " est=" << estimate_ << " dt=" << dt << " bw=" << bw / 125000.0
       << "Mbs bw_est=" << bw_est_ / 125000.0 << "Mbs";
   GRPC_CHECK(ping_state_ == PingState::STARTED);
@@ -57,10 +57,10 @@ Timestamp BdpEstimator::CompletePing() {
     estimate_ = std::max(accumulator_, estimate_ * 2);
     bw_est_ = bw;
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]: estimate increased to " << estimate_;
+        << "bdp[" << peer_name_ << "]: estimate increased to " << estimate_;
     inter_ping_delay_ /= 2;  // if the ping estimate changes,
                              // exponentially get faster at probing
-  } else if (inter_ping_delay_ < Duration::Seconds(10)) {
+  } else if (inter_ping_delay_ < Duration::Seconds(kMaxInterPingDelaySeconds)) {
     stable_estimate_count_++;
     if (stable_estimate_count_ >= 2) {
       // If the ping estimate is steady, slowly ramp down the probe time.
@@ -72,7 +72,7 @@ Timestamp BdpEstimator::CompletePing() {
   if (start_inter_ping_delay != inter_ping_delay_) {
     stable_estimate_count_ = 0;
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]:update_inter_time to "
+        << "bdp[" << peer_name_ << "]:update_inter_time to "
         << inter_ping_delay_.millis() << "ms";
   }
   ping_state_ = PingState::UNSCHEDULED;

data/src/core/lib/transport/bdp_estimator.h

@@ -23,6 +23,7 @@
 #include <grpc/support/time.h>
 #include <inttypes.h>
 
+#include <cstdint>
 #include <string>
 
 #include "src/core/lib/debug/trace.h"
@@ -33,6 +34,10 @@
 
 namespace grpc_core {
 
+constexpr int64_t kInitialBdpDefault = 65536;
+constexpr uint32_t kDefaultInterPingDelayMillis = 100;
+constexpr uint32_t kMaxInterPingDelaySeconds = 10;
+
 class BdpEstimator {
  public:
   explicit BdpEstimator(absl::string_view name);
@@ -48,7 +53,7 @@ class BdpEstimator {
   // transport (but not necessarily started)
   void SchedulePing() {
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]:sched acc=" << accumulator_
+        << "bdp[" << peer_name_ << "]:sched acc=" << accumulator_
         << " est=" << estimate_;
     GRPC_CHECK(ping_state_ == PingState::UNSCHEDULED);
     ping_state_ = PingState::SCHEDULED;
@@ -56,11 +61,10 @@ class BdpEstimator {
   }
 
   // Start a ping: call after calling grpc_bdp_estimator_schedule_ping and
-  // once
-  // the ping is on the wire
+  // once the ping is on the wire.
   void StartPing() {
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]:start acc=" << accumulator_
+        << "bdp[" << peer_name_ << "]:start acc=" << accumulator_
         << " est=" << estimate_;
     GRPC_CHECK(ping_state_ == PingState::SCHEDULED);
     ping_state_ = PingState::STARTED;
@@ -83,7 +87,7 @@ class BdpEstimator {
   int stable_estimate_count_;
   PingState ping_state_;
   double bw_est_;
-  absl::string_view name_;
+  absl::string_view peer_name_;
 };
 
 }  // namespace grpc_core