grpc 1.64.0 → 1.65.0.pre1

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

@@ -21,13 +21,14 @@
 #include <cstdint>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/down_cast.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
@@ -46,15 +47,16 @@ namespace grpc_core {
 //
 // This will be used by CRTP (curiously-recurring template pattern), e.g.:
 //   class MyClass : public RefCounted<MyClass> { ... };
-template <typename Child>
-class DualRefCounted {
+//
+// Impl & UnrefBehavior are as per RefCounted.
+template <typename Child, typename Impl = PolymorphicRefCount,
+          typename UnrefBehavior = UnrefDelete>
+class DualRefCounted : public Impl {
  public:
   // Not copyable nor movable.
   DualRefCounted(const DualRefCounted&) = delete;
   DualRefCounted& operator=(const DualRefCounted&) = delete;
 
-  virtual ~DualRefCounted() = default;
-
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref() {
     IncrementRefCount();
     return RefCountedPtr<Child>(static_cast<Child*>(this));
@@ -91,8 +93,9 @@ class DualRefCounted {
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p unref %d -> %d, weak_ref %d -> %d", trace_, this,
-              strong_refs, strong_refs - 1, weak_refs, weak_refs + 1);
+      LOG(INFO) << trace_ << ":" << this << " unref " << strong_refs << " -> "
+                << strong_refs - 1 << ", weak_ref " << weak_refs << " -> "
+                << weak_refs + 1;
     }
     CHECK_GT(strong_refs, 0u);
 #endif
@@ -109,9 +112,10 @@ class DualRefCounted {
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d unref %d -> %d, weak_ref %d -> %d) %s",
-              trace_, this, location.file(), location.line(), strong_refs,
-              strong_refs - 1, weak_refs, weak_refs + 1, reason);
+      LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " unref " << strong_refs << " -> "
+                << strong_refs - 1 << ", weak_ref " << weak_refs << " -> "
+                << weak_refs + 1 << ") " << reason;
     }
     CHECK_GT(strong_refs, 0u);
 #else
@@ -133,8 +137,9 @@ class DualRefCounted {
 #ifndef NDEBUG
       const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
       if (trace_ != nullptr) {
-        gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %d -> %d (weak_refs=%d)",
-                trace_, this, strong_refs, strong_refs + 1, weak_refs);
+        LOG(INFO) << trace_ << ":" << this << " ref_if_non_zero " << strong_refs
+                  << " -> " << strong_refs + 1 << " (weak_refs=" << weak_refs
+                  << ")";
       }
 #endif
       if (strong_refs == 0) return nullptr;
@@ -151,10 +156,10 @@ class DualRefCounted {
 #ifndef NDEBUG
       const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
       if (trace_ != nullptr) {
-        gpr_log(GPR_INFO,
-                "%s:%p %s:%d ref_if_non_zero %d -> %d (weak_refs=%d) %s",
-                trace_, this, location.file(), location.line(), strong_refs,
-                strong_refs + 1, weak_refs, reason);
+        LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                  << location.line() << " ref_if_non_zero " << strong_refs
+                  << " -> " << strong_refs + 1 << " (weak_refs=" << weak_refs
+                  << ") " << reason;
       }
 #else
       // Avoid unused-parameter warnings for debug-only parameters
@@ -209,13 +214,13 @@ class DualRefCounted {
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     if (trace != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)", trace, this,
-              weak_refs, weak_refs - 1, strong_refs);
+      LOG(INFO) << trace << ":" << this << " weak_unref " << weak_refs << " -> "
+                << weak_refs - 1 << " (refs=" << strong_refs << ")";
     }
     CHECK_GT(weak_refs, 0u);
 #endif
     if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
-      delete static_cast<Child*>(this);
+      unref_behavior_(static_cast<Child*>(this));
     }
   }
   void WeakUnref(const DebugLocation& location, const char* reason) {
@@ -231,9 +236,9 @@ class DualRefCounted {
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     if (trace != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d weak_unref %d -> %d (refs=%d) %s", trace,
-              this, location.file(), location.line(), weak_refs, weak_refs - 1,
-              strong_refs, reason);
+      LOG(INFO) << trace << ":" << this << " " << location.file() << ":"
+                << location.line() << " weak_unref " << weak_refs << " -> "
+                << weak_refs - 1 << " (refs=" << strong_refs << ") " << reason;
     }
     CHECK_GT(weak_refs, 0u);
 #else
@@ -242,7 +247,7 @@ class DualRefCounted {
     (void)reason;
 #endif
     if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
-      delete static_cast<Child*>(this);
+      unref_behavior_(static_cast<const Child*>(this));
     }
   }
 
@@ -266,6 +271,9 @@ class DualRefCounted {
   // Ref count has dropped to zero, so the object is now orphaned.
   virtual void Orphaned() = 0;
 
+  // Note: Depending on the Impl used, this dtor can be implicitly virtual.
+  ~DualRefCounted() = default;
+
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().
   template <typename T>
@@ -293,8 +301,8 @@ class DualRefCounted {
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     CHECK_NE(strong_refs, 0u);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p ref %d -> %d; (weak_refs=%d)", trace_, this,
-              strong_refs, strong_refs + 1, weak_refs);
+      LOG(INFO) << trace_ << ":" << this << " ref " << strong_refs << " -> "
+                << strong_refs + 1 << "; (weak_refs=" << weak_refs << ")";
     }
 #else
     refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
@@ -308,9 +316,10 @@ class DualRefCounted {
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     CHECK_NE(strong_refs, 0u);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d ref %d -> %d (weak_refs=%d) %s", trace_,
-              this, location.file(), location.line(), strong_refs,
-              strong_refs + 1, weak_refs, reason);
+      LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " ref " << strong_refs << " -> "
+                << strong_refs + 1 << " (weak_refs=" << weak_refs << ") "
+                << reason;
     }
 #else
     // Use conditionally-important parameters
@@ -327,9 +336,10 @@ class DualRefCounted {
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p weak_ref %d -> %d; (refs=%d)", trace_, this,
-              weak_refs, weak_refs + 1, strong_refs);
+      LOG(INFO) << trace_ << ":" << this << " weak_ref " << weak_refs << " -> "
+                << weak_refs + 1 << "; (refs=" << strong_refs << ")";
     }
+    if (strong_refs == 0) CHECK_NE(weak_refs, 0u);
 #else
     refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
 #endif
@@ -342,10 +352,11 @@ class DualRefCounted {
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d weak_ref %d -> %d (refs=%d) %s", trace_,
-              this, location.file(), location.line(), weak_refs, weak_refs + 1,
-              strong_refs, reason);
+      LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " weak_ref " << weak_refs << " -> "
+                << weak_refs + 1 << " (refs=" << strong_refs << ") " << reason;
     }
+    if (strong_refs == 0) CHECK_NE(weak_refs, 0u);
 #else
     // Use conditionally-important parameters
     (void)location;
@@ -358,6 +369,7 @@ class DualRefCounted {
   const char* trace_;
 #endif
   std::atomic<uint64_t> refs_{0};
+  GPR_NO_UNIQUE_ADDRESS UnrefBehavior unref_behavior_;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,54 @@
+// Copyright 2024 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 "src/core/lib/gprpp/dump_args.h"
+
+#include "absl/log/check.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+namespace dump_args_detail {
+
+std::ostream& operator<<(std::ostream& out, const DumpArgs& args) {
+  // Parse the argument string into a vector of keys.
+  // #__VA_ARGS__ produces a stringified version of the arguments passed to the
+  // macro. It's comma separated, and we can use that to split the string into
+  // keys. Those keys might include parenthesis for e.g. argument lists, and so
+  // we need to skip commas that are inside parenthesis.
+  std::vector<absl::string_view> keys;
+  int depth = 0;
+  const char* start = args.arg_string_;
+  for (const char* p = args.arg_string_; *p; ++p) {
+    if (*p == '(') {
+      ++depth;
+    } else if (*p == ')') {
+      --depth;
+    } else if (*p == ',' && depth == 0) {
+      keys.push_back(absl::string_view(start, p - start));
+      start = p + 1;
+    }
+  }
+  keys.push_back(start);
+  CHECK_EQ(keys.size(), args.arg_dumpers_.size());
+  for (size_t i = 0; i < keys.size(); i++) {
+    if (i != 0) out << ", ";
+    out << absl::StripAsciiWhitespace(keys[i]) << " = ";
+    args.arg_dumpers_[i](out);
+  }
+  return out;
+}
+
+}  // namespace dump_args_detail
+}  // namespace grpc_core

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

@@ -0,0 +1,69 @@
+// Copyright 2024 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_SRC_CORE_LIB_GPRPP_DUMP_ARGS_H
+#define GRPC_SRC_CORE_LIB_GPRPP_DUMP_ARGS_H
+
+#include <ostream>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+
+namespace grpc_core {
+namespace dump_args_detail {
+
+// Helper function... just ignore the initializer list passed into it.
+// Allows doing 'statements' via parameter pack expansion in C++11 - given
+// template <typename... Ts>:
+//  do_these_things({foo<Ts>()...});
+// will execute foo<T>() for each T in Ts.
+template <typename T>
+void do_these_things(std::initializer_list<T>) {}
+
+class DumpArgs {
+ public:
+  template <typename... Args>
+  explicit DumpArgs(const char* arg_string, const Args&... args)
+      : arg_string_(arg_string) {
+    do_these_things({AddDumper(&args)...});
+  }
+
+  friend std::ostream& operator<<(std::ostream& out, const DumpArgs& args);
+
+ private:
+  template <typename T>
+  int AddDumper(T* p) {
+    arg_dumpers_.push_back([p](std::ostream& os) { os << *p; });
+    return 0;
+  }
+
+  const char* arg_string_;
+  std::vector<absl::AnyInvocable<void(std::ostream&) const>> arg_dumpers_;
+};
+
+}  // namespace dump_args_detail
+}  // namespace grpc_core
+
+// Helper to print a list of variables and their values.
+// Each type must be streamable to std::ostream.
+// Usage:
+//   int a = 1;
+//   int b = 2;
+//   LOG(INFO) << GRPC_DUMP_ARGS(a, b)
+// Output:
+//   a = 1, b = 2
+#define GRPC_DUMP_ARGS(...) \
+  grpc_core::dump_args_detail::DumpArgs(#__VA_ARGS__, __VA_ARGS__)
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_DUMP_ARGS_H

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

@@ -0,0 +1,70 @@
+// Copyright 2024 The 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 "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+namespace {
+bool IsGlob(absl::string_view trace_glob) {
+  return std::any_of(trace_glob.begin(), trace_glob.end(),
+                     [](const char c) { return c == '?' || c == '*'; });
+}
+}  // namespace
+
+bool GlobMatch(absl::string_view name, absl::string_view pattern) {
+  if (!IsGlob(pattern)) return name == pattern;
+  size_t name_idx = 0;
+  size_t trace_idx = 0;
+  // pointers for iterative wildcard * matching.
+  size_t name_next_idx = name_idx;
+  size_t trace_next_idx = trace_idx;
+
+  while (trace_idx < pattern.length() || name_idx < name.length()) {
+    if (trace_idx < pattern.length()) {
+      switch (pattern.at(trace_idx)) {
+        case '?':
+          if (name_idx < name.length()) {
+            ++trace_idx;
+            ++name_idx;
+            continue;
+          }
+          break;
+        case '*':
+          trace_next_idx = trace_idx;
+          name_next_idx = name_idx + 1;
+          ++trace_idx;
+          continue;
+        default:
+          if (name_idx < name.length() &&
+              name.at(name_idx) == pattern.at(trace_idx)) {
+            ++trace_idx;
+            ++name_idx;
+            continue;
+          }
+          break;
+      }
+    }
+    // Failed to match a character. Restart if possible.
+    if (name_next_idx > 0 && name_next_idx <= name.length()) {
+      trace_idx = trace_next_idx;
+      name_idx = name_next_idx;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,29 @@
+// Copyright 2024 The 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_SRC_CORE_LIB_GPRPP_GLOB_H
+#define GRPC_SRC_CORE_LIB_GPRPP_GLOB_H
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// A basic glob matcher based on https://research.swtch.com/glob.
+// This supports `?` (a single wildcard character), and `*` (multiple wildcard
+// characters).
+bool GlobMatch(absl::string_view name, absl::string_view pattern);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_GLOB_H

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

@@ -17,7 +17,7 @@
 #include <grpc/support/cpu.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/lib/gprpp/posix/stat.cc

@@ -28,8 +28,7 @@
 #include <sys/stat.h>
 
 #include "absl/log/check.h"
-
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
 
 #include "src/core/lib/gprpp/stat.h"
 #include "src/core/lib/gprpp/strerror.h"
@@ -42,8 +41,8 @@ absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
   struct stat buf;
   if (stat(filename, &buf) != 0) {
     std::string error_msg = StrError(errno);
-    gpr_log(GPR_ERROR, "stat failed for filename %s with error %s.", filename,
-            error_msg.c_str());
+    LOG(ERROR) << "stat failed for filename " << filename << " with error "
+               << error_msg;
     return absl::Status(absl::StatusCode::kInternal, error_msg);
   }
   // Last file/directory modification time.

data/src/core/lib/gprpp/posix/thd.cc

@@ -33,17 +33,17 @@
 #include <unistd.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/thd.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 namespace {
@@ -157,8 +157,7 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
     CHECK_EQ(pthread_attr_destroy(&attr), 0);
 
     if (!(*success)) {
-      gpr_log(GPR_ERROR, "pthread_create failed: %s",
-              StrError(pthread_create_err).c_str());
+      LOG(ERROR) << "pthread_create failed: " << StrError(pthread_create_err);
       // don't use gpr_free, as this was allocated using malloc (see above)
       free(info);
       if (options.tracked()) {
@@ -198,8 +197,8 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
 void Thread::Signal(gpr_thd_id tid, int sig) {
   auto kill_err = pthread_kill((pthread_t)tid, sig);
   if (kill_err != 0) {
-    gpr_log(GPR_ERROR, "pthread_kill for tid %" PRIdPTR " failed: %s", tid,
-            StrError(kill_err).c_str());
+    LOG(ERROR) << "pthread_kill for tid " << tid
+               << " failed: " << StrError(kill_err);
   }
 }
 
@@ -207,13 +206,13 @@ void Thread::Signal(gpr_thd_id tid, int sig) {
 void Thread::Kill(gpr_thd_id tid) {
   auto cancel_err = pthread_cancel((pthread_t)tid);
   if (cancel_err != 0) {
-    gpr_log(GPR_ERROR, "pthread_cancel for tid %" PRIdPTR " failed: %s", tid,
-            StrError(cancel_err).c_str());
+    LOG(ERROR) << "pthread_cancel for tid " << tid
+               << " failed: " << StrError(cancel_err);
   }
 }
 #else  // GPR_ANDROID
 void Thread::Kill(gpr_thd_id /* tid */) {
-  gpr_log(GPR_DEBUG, "Thread::Kill is not supported on Android.");
+  VLOG(2) << "Thread::Kill is not supported on Android.";
 }
 #endif
 

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

@@ -24,8 +24,8 @@
 #include <cinttypes>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/atomic_utils.h"
@@ -73,8 +73,8 @@ class RefCount {
 #ifndef NDEBUG
     const Value prior = value_.fetch_add(n, std::memory_order_relaxed);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
-              prior, prior + n);
+      LOG(INFO) << trace_ << ":" << this << " ref " << prior << " -> "
+                << prior + n;
     }
 #else
     value_.fetch_add(n, std::memory_order_relaxed);
@@ -84,9 +84,9 @@ class RefCount {
 #ifndef NDEBUG
     const Value prior = value_.fetch_add(n, std::memory_order_relaxed);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_, this, location.file(), location.line(), prior, prior + n,
-              reason);
+      LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " ref " << prior << " -> " << prior + n
+                << " " << reason;
     }
 #else
     // Use conditionally-important parameters
@@ -101,8 +101,8 @@ class RefCount {
 #ifndef NDEBUG
     const Value prior = value_.fetch_add(1, std::memory_order_relaxed);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
-              prior, prior + 1);
+      LOG(INFO) << trace_ << ":" << this << " ref " << prior << " -> "
+                << prior + 1;
     }
     assert(prior > 0);
 #else
@@ -113,9 +113,9 @@ class RefCount {
 #ifndef NDEBUG
     const Value prior = value_.fetch_add(1, std::memory_order_relaxed);
     if (trace_ != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_, this, location.file(), location.line(), prior, prior + 1,
-              reason);
+      LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " ref " << prior << " -> " << prior + 1
+                << " " << reason;
     }
     assert(prior > 0);
 #else
@@ -130,8 +130,8 @@ class RefCount {
 #ifndef NDEBUG
     if (trace_ != nullptr) {
       const Value prior = get();
-      gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR,
-              trace_, this, prior, prior + 1);
+      LOG(INFO) << trace_ << ":" << this << " ref_if_non_zero " << prior
+                << " -> " << prior + 1;
     }
 #endif
     return IncrementIfNonzero(&value_);
@@ -140,10 +140,9 @@ class RefCount {
 #ifndef NDEBUG
     if (trace_ != nullptr) {
       const Value prior = get();
-      gpr_log(GPR_INFO,
-              "%s:%p %s:%d ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_, this, location.file(), location.line(), prior, prior + 1,
-              reason);
+      LOG(INFO) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " ref_if_non_zero " << prior << " -> "
+                << prior + 1 << " " << reason;
     }
 #endif
     // Avoid unused-parameter warnings for debug-only parameters
@@ -163,8 +162,8 @@ class RefCount {
     const Value prior = value_.fetch_sub(1, std::memory_order_acq_rel);
 #ifndef NDEBUG
     if (trace != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR, trace, this,
-              prior, prior - 1);
+      LOG(INFO) << trace << ":" << this << " unref " << prior << " -> "
+                << prior - 1;
     }
     DCHECK_GT(prior, 0);
 #endif
@@ -180,9 +179,9 @@ class RefCount {
     const Value prior = value_.fetch_sub(1, std::memory_order_acq_rel);
 #ifndef NDEBUG
     if (trace != nullptr) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d unref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace, this, location.file(), location.line(), prior, prior - 1,
-              reason);
+      LOG(INFO) << trace << ":" << this << " " << location.file() << ":"
+                << location.line() << " unref " << prior << " -> " << prior - 1
+                << " " << reason;
     }
     DCHECK_GT(prior, 0);
 #else
@@ -246,6 +245,15 @@ struct UnrefCallDtor {
   }
 };
 
+// Call the Destroy method on the object. This is useful when the object
+// needs precise control of how it's deallocated.
+struct UnrefCallDestroy {
+  template <typename T>
+  void operator()(T* p) const {
+    p->Destroy();
+  }
+};
+
 // A base class for reference-counted objects.
 // New objects should be created via new and start with a refcount of 1.
 // When the refcount reaches 0, executes the specified UnrefBehavior.

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

@@ -63,17 +63,19 @@ class SingleSetPtr {
   void Reset() { Delete(p_.exchange(nullptr, std::memory_order_acq_rel)); }
 
   bool is_set() const {
-    T* p = p_.load(std::memory_order_acquire);
+    T* p = Get();
     return p != nullptr;
   }
 
+  T* Get() const { return p_.load(std::memory_order_acquire); }
+
   T* operator->() const {
-    T* p = p_.load(std::memory_order_acquire);
+    T* p = Get();
     DCHECK_NE(p, nullptr);
     return p;
   }
 
-  T& operator*() const { return *operator->(); }
+  T& operator*() const { return *Get(); }
 
  private:
   static void Delete(T* p) {