grpc 1.60.0 → 1.62.0

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

@@ -47,19 +47,38 @@ namespace grpc_core {
 template <typename Child>
 class DualRefCounted : public Orphanable {
  public:
+  // Not copyable nor movable.
+  DualRefCounted(const DualRefCounted&) = delete;
+  DualRefCounted& operator=(const DualRefCounted&) = delete;
+
   ~DualRefCounted() override = default;
 
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref() {
     IncrementRefCount();
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
-
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref(const DebugLocation& location,
                                                 const char* reason) {
     IncrementRefCount(location, reason);
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass() {
+    IncrementRefCount();
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass(const DebugLocation& location,
+                                        const char* reason) {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+
   void Unref() {
     // Convert strong ref to weak ref.
     const uint64_t prev_ref_pair =
@@ -120,7 +139,6 @@ class DualRefCounted : public Orphanable {
         std::memory_order_acq_rel, std::memory_order_acquire));
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
-
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> RefIfNonZero(
       const DebugLocation& location, const char* reason) {
     uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
@@ -150,13 +168,28 @@ class DualRefCounted : public Orphanable {
     IncrementWeakRefCount();
     return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
   }
-
   GRPC_MUST_USE_RESULT WeakRefCountedPtr<Child> WeakRef(
       const DebugLocation& location, const char* reason) {
     IncrementWeakRefCount(location, reason);
     return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  WeakRefCountedPtr<Subclass> WeakRefAsSubclass() {
+    IncrementWeakRefCount();
+    return WeakRefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  WeakRefCountedPtr<Subclass> WeakRefAsSubclass(const DebugLocation& location,
+                                                const char* reason) {
+    IncrementWeakRefCount(location, reason);
+    return WeakRefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+
   void WeakUnref() {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
@@ -207,10 +240,6 @@ class DualRefCounted : public Orphanable {
     }
   }
 
-  // Not copyable nor movable.
-  DualRefCounted(const DualRefCounted&) = delete;
-  DualRefCounted& operator=(const DualRefCounted&) = delete;
-
  protected:
   // Note: Tracing is a no-op in non-debug builds.
   explicit DualRefCounted(

data/src/core/lib/gprpp/linux/env.cc

@@ -29,10 +29,6 @@
 
 #ifdef GPR_LINUX_ENV
 
-#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
-#include <dlfcn.h>
-#endif
-
 #include <features.h>
 #include <stdlib.h>
 
@@ -42,21 +38,7 @@ namespace grpc_core {
 
 absl::optional<std::string> GetEnv(const char* name) {
   char* result = nullptr;
-#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
-  typedef char* (*getenv_type)(const char*);
-  static getenv_type getenv_func = nullptr;
-  // Check to see which getenv variant is supported (go from most
-  // to least secure)
-  if (getenv_func == nullptr) {
-    for (auto name : {"secure_getenv", "__secure_getenv", "getenv"}) {
-      getenv_func = reinterpret_cast<getenv_type>(dlsym(RTLD_DEFAULT, name));
-      if (getenv_func != nullptr) {
-        break;
-      }
-    }
-  }
-  result = getenv_func(name);
-#elif __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17)
+#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17)
   result = secure_getenv(name);
 #else
   result = getenv(name);

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

@@ -32,7 +32,8 @@ namespace grpc_core {
 
 // Loads the content of a file into a slice. add_null_terminator will add a NULL
 // terminator if true.
-absl::StatusOr<Slice> LoadFile(std::string filename, bool add_null_terminator) {
+absl::StatusOr<Slice> LoadFile(const std::string& filename,
+                               bool add_null_terminator) {
   unsigned char* contents = nullptr;
   size_t contents_size = 0;
   FILE* file;

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

@@ -27,7 +27,8 @@ namespace grpc_core {
 
 // Loads the content of a file into a slice. add_null_terminator will add a NULL
 // terminator if true.
-absl::StatusOr<Slice> LoadFile(std::string filename, bool add_null_terminator);
+absl::StatusOr<Slice> LoadFile(const std::string& filename,
+                               bool add_null_terminator);
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_GPRPP_LOAD_FILE_H

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

@@ -97,6 +97,33 @@ class InternallyRefCounted : public Orphanable {
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass() {
+    IncrementRefCount();
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass(const DebugLocation& location,
+                                        const char* reason) {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+
+  GRPC_MUST_USE_RESULT RefCountedPtr<Child> RefIfNonZero() {
+    return RefCountedPtr<Child>(refs_.RefIfNonZero() ? static_cast<Child*>(this)
+                                                     : nullptr);
+  }
+  GRPC_MUST_USE_RESULT RefCountedPtr<Child> RefIfNonZero(
+      const DebugLocation& location, const char* reason) {
+    return RefCountedPtr<Child>(refs_.RefIfNonZero(location, reason)
+                                    ? static_cast<Child*>(this)
+                                    : nullptr);
+  }
+
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
       unref_behavior_(static_cast<Child*>(this));

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

@@ -20,9 +20,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string>
+#include <inttypes.h>
 
-#include <grpc/support/time.h>
+#include <csignal>
+#include <string>
 
 #ifdef GPR_POSIX_SYNC
 
@@ -34,6 +35,7 @@
 #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"
@@ -43,6 +45,7 @@
 
 namespace grpc_core {
 namespace {
+
 class ThreadInternalsPosix;
 
 struct thd_arg {
@@ -192,6 +195,28 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
 
 }  // namespace
 
+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());
+  }
+}
+
+#ifndef GPR_ANDROID
+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());
+  }
+}
+#else  // GPR_ANDROID
+void Thread::Kill(gpr_thd_id /* tid */) {
+  gpr_log(GPR_DEBUG, "Thread::Kill is not supported on Android.");
+}
+#endif
+
 Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
                bool* success, const Options& options)
     : options_(options) {

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

@@ -219,7 +219,7 @@ class NonPolymorphicRefCount {
 // Default behavior: Delete the object.
 struct UnrefDelete {
   template <typename T>
-  void operator()(T* p) {
+  void operator()(T* p) const {
     delete p;
   }
 };
@@ -231,7 +231,7 @@ struct UnrefDelete {
 // later by identifying entries for which RefIfNonZero() returns null.
 struct UnrefNoDelete {
   template <typename T>
-  void operator()(T* /*p*/) {}
+  void operator()(T* /*p*/) const {}
 };
 
 // Call the object's dtor but do not delete it.  This is useful for cases
@@ -239,7 +239,7 @@ struct UnrefNoDelete {
 // arena).
 struct UnrefCallDtor {
   template <typename T>
-  void operator()(T* p) {
+  void operator()(T* p) const {
     p->~T();
   }
 };
@@ -276,35 +276,52 @@ class RefCounted : public Impl {
  public:
   using RefCountedChildType = Child;
 
+  // Not copyable nor movable.
+  RefCounted(const RefCounted&) = delete;
+  RefCounted& operator=(const RefCounted&) = delete;
+
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
   ~RefCounted() = default;
 
+  // Ref() for mutable types.
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref() {
     IncrementRefCount();
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
-
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref(const DebugLocation& location,
                                                 const char* reason) {
     IncrementRefCount(location, reason);
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
-  // TODO(roth): Once all of our code is converted to C++ and can use
-  // RefCountedPtr<> instead of manual ref-counting, make this method
-  // private, since it will only be used by RefCountedPtr<>, which is a
-  // friend of this class.
-  void Unref() {
-    if (GPR_UNLIKELY(refs_.Unref())) {
-      unref_behavior_(static_cast<Child*>(this));
-    }
+  // Ref() for const types.
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> Ref() const {
+    IncrementRefCount();
+    return RefCountedPtr<const Child>(static_cast<const Child*>(this));
   }
-  void Unref(const DebugLocation& location, const char* reason) {
-    if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      unref_behavior_(static_cast<Child*>(this));
-    }
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> Ref(
+      const DebugLocation& location, const char* reason) const {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<const Child>(static_cast<const Child*>(this));
+  }
+
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass() {
+    IncrementRefCount();
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass(const DebugLocation& location,
+                                        const char* reason) {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
   }
 
+  // RefIfNonZero() for mutable types.
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> RefIfNonZero() {
     return RefCountedPtr<Child>(refs_.RefIfNonZero() ? static_cast<Child*>(this)
                                                      : nullptr);
@@ -316,9 +333,32 @@ class RefCounted : public Impl {
                                     : nullptr);
   }
 
-  // Not copyable nor movable.
-  RefCounted(const RefCounted&) = delete;
-  RefCounted& operator=(const RefCounted&) = delete;
+  // RefIfNonZero() for const types.
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> RefIfNonZero() const {
+    return RefCountedPtr<const Child>(
+        refs_.RefIfNonZero() ? static_cast<const Child*>(this) : nullptr);
+  }
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> RefIfNonZero(
+      const DebugLocation& location, const char* reason) const {
+    return RefCountedPtr<const Child>(refs_.RefIfNonZero(location, reason)
+                                          ? static_cast<const Child*>(this)
+                                          : nullptr);
+  }
+
+  // TODO(roth): Once all of our code is converted to C++ and can use
+  // RefCountedPtr<> instead of manual ref-counting, make this method
+  // private, since it will only be used by RefCountedPtr<>, which is a
+  // friend of this class.
+  void Unref() const {
+    if (GPR_UNLIKELY(refs_.Unref())) {
+      unref_behavior_(static_cast<const Child*>(this));
+    }
+  }
+  void Unref(const DebugLocation& location, const char* reason) const {
+    if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
+      unref_behavior_(static_cast<const Child*>(this));
+    }
+  }
 
  protected:
   // Note: Tracing is a no-op on non-debug builds.
@@ -336,12 +376,13 @@ class RefCounted : public Impl {
   template <typename T>
   friend class RefCountedPtr;
 
-  void IncrementRefCount() { refs_.Ref(); }
-  void IncrementRefCount(const DebugLocation& location, const char* reason) {
+  void IncrementRefCount() const { refs_.Ref(); }
+  void IncrementRefCount(const DebugLocation& location,
+                         const char* reason) const {
     refs_.Ref(location, reason);
   }
 
-  RefCount refs_;
+  mutable RefCount refs_;
   GPR_NO_UNIQUE_ADDRESS UnrefBehavior unref_behavior_;
 };
 

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

@@ -43,7 +43,8 @@ class RefCountedPtr {
   RefCountedPtr(std::nullptr_t) {}
 
   // If value is non-null, we take ownership of a ref to it.
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   explicit RefCountedPtr(Y* value) : value_(value) {}
 
   // Move ctors.
@@ -51,7 +52,8 @@ class RefCountedPtr {
     value_ = other.value_;
     other.value_ = nullptr;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   RefCountedPtr(RefCountedPtr<Y>&& other) noexcept {
     value_ = static_cast<T*>(other.value_);
@@ -63,7 +65,8 @@ class RefCountedPtr {
     reset(std::exchange(other.value_, nullptr));
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   RefCountedPtr& operator=(RefCountedPtr<Y>&& other) noexcept {
     reset(std::exchange(other.value_, nullptr));
     return *this;
@@ -74,7 +77,8 @@ class RefCountedPtr {
     if (other.value_ != nullptr) other.value_->IncrementRefCount();
     value_ = other.value_;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   RefCountedPtr(const RefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -92,7 +96,8 @@ class RefCountedPtr {
     reset(other.value_);
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   RefCountedPtr& operator=(const RefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
@@ -107,6 +112,12 @@ class RefCountedPtr {
     if (value_ != nullptr) value_->Unref();
   }
 
+  // An explicit copy method that supports ref-count tracing.
+  RefCountedPtr<T> Ref(const DebugLocation& location, const char* reason) {
+    if (value_ != nullptr) value_->IncrementRefCount(location, reason);
+    return RefCountedPtr<T>(value_);
+  }
+
   void swap(RefCountedPtr& other) { std::swap(value_, other.value_); }
 
   // If value is non-null, we take ownership of a ref to it.
@@ -119,13 +130,15 @@ class RefCountedPtr {
     T* old_value = std::exchange(value_, value);
     if (old_value != nullptr) old_value->Unref(location, reason);
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
     reset(static_cast<T*>(value));
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -143,24 +156,34 @@ class RefCountedPtr {
   T& operator*() const { return *value_; }
   T* operator->() const { return value_; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_base_of<T, Y>::value, bool> = true>
+  RefCountedPtr<Y> TakeAsSubclass() {
+    return RefCountedPtr<Y>(static_cast<Y*>(release()));
+  }
+
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const RefCountedPtr<Y>& other) const {
     return value_ == other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const Y* other) const {
     return value_ == other;
   }
 
   bool operator==(std::nullptr_t) const { return value_ == nullptr; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const RefCountedPtr<Y>& other) const {
     return value_ != other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const Y* other) const {
     return value_ != other;
   }
@@ -184,7 +207,8 @@ class WeakRefCountedPtr {
   WeakRefCountedPtr(std::nullptr_t) {}
 
   // If value is non-null, we take ownership of a ref to it.
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   explicit WeakRefCountedPtr(Y* value) {
     value_ = value;
   }
@@ -194,7 +218,8 @@ class WeakRefCountedPtr {
     value_ = other.value_;
     other.value_ = nullptr;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   WeakRefCountedPtr(WeakRefCountedPtr<Y>&& other) noexcept {
     value_ = static_cast<T*>(other.value_);
@@ -206,7 +231,8 @@ class WeakRefCountedPtr {
     reset(std::exchange(other.value_, nullptr));
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) noexcept {
     reset(std::exchange(other.value_, nullptr));
     return *this;
@@ -217,7 +243,8 @@ class WeakRefCountedPtr {
     if (other.value_ != nullptr) other.value_->IncrementWeakRefCount();
     value_ = other.value_;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   WeakRefCountedPtr(const WeakRefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -235,7 +262,8 @@ class WeakRefCountedPtr {
     reset(other.value_);
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   WeakRefCountedPtr& operator=(const WeakRefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
@@ -250,6 +278,13 @@ class WeakRefCountedPtr {
     if (value_ != nullptr) value_->WeakUnref();
   }
 
+  // An explicit copy method that supports ref-count tracing.
+  WeakRefCountedPtr<T> WeakRef(const DebugLocation& location,
+                               const char* reason) {
+    if (value_ != nullptr) value_->IncrementWeakRefCount(location, reason);
+    return WeakRefCountedPtr<T>(value_);
+  }
+
   void swap(WeakRefCountedPtr& other) { std::swap(value_, other.value_); }
 
   // If value is non-null, we take ownership of a ref to it.
@@ -262,13 +297,15 @@ class WeakRefCountedPtr {
     T* old_value = std::exchange(value_, value);
     if (old_value != nullptr) old_value->WeakUnref(location, reason);
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
     reset(static_cast<T*>(value));
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -280,35 +317,41 @@ class WeakRefCountedPtr {
   // us to pass a ref to idiomatic C code that does not use WeakRefCountedPtr<>.
   // Once all of our code has been converted to idiomatic C++, this
   // method should go away.
-  T* release() {
-    T* value = value_;
-    value_ = nullptr;
-    return value;
-  }
+  T* release() { return std::exchange(value_, nullptr); }
 
   T* get() const { return value_; }
 
   T& operator*() const { return *value_; }
   T* operator->() const { return value_; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_base_of<T, Y>::value, bool> = true>
+  WeakRefCountedPtr<Y> TakeAsSubclass() {
+    return WeakRefCountedPtr<Y>(static_cast<Y*>(release()));
+  }
+
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const WeakRefCountedPtr<Y>& other) const {
     return value_ == other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const Y* other) const {
     return value_ == other;
   }
 
   bool operator==(std::nullptr_t) const { return value_ == nullptr; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const WeakRefCountedPtr<Y>& other) const {
     return value_ != other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const Y* other) const {
     return value_ != other;
   }

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

@@ -104,6 +104,19 @@ inline bool operator==(const RefCountedStringValue& lhs,
   return lhs.as_string_view() == rhs.as_string_view();
 }
 
+inline bool operator!=(const RefCountedStringValue& lhs,
+                       absl::string_view rhs) {
+  return lhs.as_string_view() != rhs;
+}
+inline bool operator!=(absl::string_view lhs,
+                       const RefCountedStringValue& rhs) {
+  return lhs != rhs.as_string_view();
+}
+inline bool operator!=(const RefCountedStringValue& lhs,
+                       const RefCountedStringValue& rhs) {
+  return lhs.as_string_view() != rhs.as_string_view();
+}
+
 inline bool operator<(const RefCountedStringValue& lhs, absl::string_view rhs) {
   return lhs.as_string_view() < rhs;
 }

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

@@ -34,8 +34,7 @@
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
 #include "upb/base/string_view.h"
-#include "upb/mem/arena.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 
 #include <grpc/support/log.h>
 

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

@@ -31,6 +31,7 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/thd_id.h>
 
 namespace grpc_core {
 namespace internal {
@@ -47,6 +48,13 @@ class ThreadInternalsInterface {
 
 class Thread {
  public:
+  // Send a signal to the thread.
+  // This is not supported on all platforms
+  static void Signal(gpr_thd_id tid, int sig);
+  // Kill the running thread. Likely not a clean operation.
+  // This is not supported on all platforms.
+  static void Kill(gpr_thd_id tid);
+
   class Options {
    public:
     Options() : joinable_(true), tracked_(true), stack_size_(0) {}