grpc 1.62.0 → 1.69.0

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

@@ -1,54 +0,0 @@
-//
-// Copyright 2020 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 <grpc/support/port_platform.h>
-
-#include <string>
-
-// IWYU pragma: no_include <bits/struct_stat.h>
-
-#include "absl/status/status.h"
-
-#ifdef GPR_POSIX_STAT
-
-#include <errno.h>
-#include <sys/stat.h>
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gprpp/stat.h"
-#include "src/core/lib/gprpp/strerror.h"
-
-namespace grpc_core {
-
-absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
-  GPR_ASSERT(filename != nullptr);
-  GPR_ASSERT(timestamp != nullptr);
-  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());
-    return absl::Status(absl::StatusCode::kInternal, error_msg);
-  }
-  // Last file/directory modification time.
-  *timestamp = buf.st_mtime;
-  return absl::OkStatus();
-}
-
-}  // namespace grpc_core
-
-#endif  // GPR_POSIX_STAT

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

@@ -1,247 +0,0 @@
-//
-//
-// Copyright 2015 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.
-//
-//
-
-// Posix implementation for gpr threads.
-
-#include <grpc/support/port_platform.h>
-
-#include <inttypes.h>
-
-#include <csignal>
-#include <string>
-
-#ifdef GPR_POSIX_SYNC
-
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.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"
-
-namespace grpc_core {
-namespace {
-
-class ThreadInternalsPosix;
-
-struct thd_arg {
-  ThreadInternalsPosix* thread;
-  void (*body)(void* arg);  // body of a thread
-  void* arg;                // argument to a thread
-  const char* name;         // name of thread. Can be nullptr.
-  bool joinable;
-  bool tracked;
-};
-
-size_t RoundUpToPageSize(size_t size) {
-  // TODO(yunjiaw): Change this variable (page_size) to a function-level static
-  // when possible
-  size_t page_size = static_cast<size_t>(sysconf(_SC_PAGESIZE));
-  return (size + page_size - 1) & ~(page_size - 1);
-}
-
-// Returns the minimum valid stack size that can be passed to
-// pthread_attr_setstacksize.
-size_t MinValidStackSize(size_t request_size) {
-  size_t min_stacksize = sysconf(_SC_THREAD_STACK_MIN);
-  if (request_size < min_stacksize) {
-    request_size = min_stacksize;
-  }
-
-  // On some systems, pthread_attr_setstacksize() can fail if stacksize is
-  // not a multiple of the system page size.
-  return RoundUpToPageSize(request_size);
-}
-
-class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
- public:
-  ThreadInternalsPosix(const char* thd_name, void (*thd_body)(void* arg),
-                       void* arg, bool* success, const Thread::Options& options)
-      : started_(false) {
-    gpr_mu_init(&mu_);
-    gpr_cv_init(&ready_);
-    pthread_attr_t attr;
-    // don't use gpr_malloc as we may cause an infinite recursion with
-    // the profiling code
-    thd_arg* info = static_cast<thd_arg*>(malloc(sizeof(*info)));
-    GPR_ASSERT(info != nullptr);
-    info->thread = this;
-    info->body = thd_body;
-    info->arg = arg;
-    info->name = thd_name;
-    info->joinable = options.joinable();
-    info->tracked = options.tracked();
-    if (options.tracked()) {
-      Fork::IncThreadCount();
-    }
-
-    GPR_ASSERT(pthread_attr_init(&attr) == 0);
-    if (options.joinable()) {
-      GPR_ASSERT(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) ==
-                 0);
-    } else {
-      GPR_ASSERT(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) ==
-                 0);
-    }
-
-    if (options.stack_size() != 0) {
-      size_t stack_size = MinValidStackSize(options.stack_size());
-      GPR_ASSERT(pthread_attr_setstacksize(&attr, stack_size) == 0);
-    }
-
-    int pthread_create_err = pthread_create(
-        &pthread_id_, &attr,
-        [](void* v) -> void* {
-          thd_arg arg = *static_cast<thd_arg*>(v);
-          free(v);
-          if (arg.name != nullptr) {
-#if GPR_APPLE_PTHREAD_NAME
-            // Apple supports 64 characters, and will
-            // truncate if it's longer.
-            pthread_setname_np(arg.name);
-#elif GPR_LINUX_PTHREAD_NAME
-            // Linux supports 16 characters max, and will
-            // error if it's longer.
-            char buf[16];
-            size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
-            strncpy(buf, arg.name, buf_len);
-            buf[buf_len] = '\0';
-            pthread_setname_np(pthread_self(), buf);
-#endif  // GPR_APPLE_PTHREAD_NAME
-          }
-
-          gpr_mu_lock(&arg.thread->mu_);
-          while (!arg.thread->started_) {
-            gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
-                        gpr_inf_future(GPR_CLOCK_MONOTONIC));
-          }
-          gpr_mu_unlock(&arg.thread->mu_);
-
-          if (!arg.joinable) {
-            delete arg.thread;
-          }
-
-          (*arg.body)(arg.arg);
-          if (arg.tracked) {
-            Fork::DecThreadCount();
-          }
-          return nullptr;
-        },
-        info);
-    *success = (pthread_create_err == 0);
-
-    GPR_ASSERT(pthread_attr_destroy(&attr) == 0);
-
-    if (!(*success)) {
-      gpr_log(GPR_ERROR, "pthread_create failed: %s",
-              StrError(pthread_create_err).c_str());
-      // don't use gpr_free, as this was allocated using malloc (see above)
-      free(info);
-      if (options.tracked()) {
-        Fork::DecThreadCount();
-      }
-    }
-  }
-
-  ~ThreadInternalsPosix() override {
-    gpr_mu_destroy(&mu_);
-    gpr_cv_destroy(&ready_);
-  }
-
-  void Start() override {
-    gpr_mu_lock(&mu_);
-    started_ = true;
-    gpr_cv_signal(&ready_);
-    gpr_mu_unlock(&mu_);
-  }
-
-  void Join() override {
-    int pthread_join_err = pthread_join(pthread_id_, nullptr);
-    if (pthread_join_err != 0) {
-      Crash("pthread_join failed: " + StrError(pthread_join_err));
-    }
-  }
-
- private:
-  gpr_mu mu_;
-  gpr_cv ready_;
-  bool started_;
-  pthread_t pthread_id_;
-};
-
-}  // 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) {
-  bool outcome = false;
-  impl_ = new ThreadInternalsPosix(thd_name, thd_body, arg, &outcome, options);
-  if (outcome) {
-    state_ = ALIVE;
-  } else {
-    state_ = FAILED;
-    delete impl_;
-    impl_ = nullptr;
-  }
-
-  if (success != nullptr) {
-    *success = outcome;
-  }
-}
-}  // namespace grpc_core
-
-// The following is in the external namespace as it is exposed as C89 API
-gpr_thd_id gpr_thd_currentid(void) {
-  // Use C-style casting because Linux and OSX have different definitions
-  // of pthread_t so that a single C++ cast doesn't handle it.
-  // NOLINTNEXTLINE(google-readability-casting)
-  return (gpr_thd_id)pthread_self();
-}
-
-#endif  // GPR_POSIX_SYNC

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

@@ -1,391 +0,0 @@
-//
-//
-// Copyright 2017 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_REF_COUNTED_H
-#define GRPC_SRC_CORE_LIB_GPRPP_REF_COUNTED_H
-
-#include <grpc/support/port_platform.h>
-
-#include <atomic>
-#include <cassert>
-#include <cinttypes>
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gprpp/atomic_utils.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-
-namespace grpc_core {
-
-// RefCount is a simple atomic ref-count.
-//
-// This is a C++ implementation of gpr_refcount, with inline functions. Due to
-// inline functions, this class is significantly more efficient than
-// gpr_refcount and should be preferred over gpr_refcount whenever possible.
-//
-// TODO(soheil): Remove gpr_refcount after submitting the GRFC and the paragraph
-//               above.
-class RefCount {
- public:
-  using Value = intptr_t;
-
-  RefCount() : RefCount(1) {}
-
-  // `init` is the initial refcount stored in this object.
-  //
-  // `trace` is a string to be logged with trace events; if null, no
-  // trace logging will be done.  Tracing is a no-op in non-debug builds.
-  explicit RefCount(
-      Value init,
-      const char*
-#ifndef NDEBUG
-          // Leave unnamed if NDEBUG to avoid unused parameter warning
-          trace
-#endif
-      = nullptr)
-      :
-#ifndef NDEBUG
-        trace_(trace),
-#endif
-        value_(init) {
-  }
-
-  // Increases the ref-count by `n`.
-  void Ref(Value n = 1) {
-#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);
-    }
-#else
-    value_.fetch_add(n, std::memory_order_relaxed);
-#endif
-  }
-  void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
-#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);
-    }
-#else
-    // Use conditionally-important parameters
-    (void)location;
-    (void)reason;
-    value_.fetch_add(n, std::memory_order_relaxed);
-#endif
-  }
-
-  // Similar to Ref() with an assert on the ref-count being non-zero.
-  void RefNonZero() {
-#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);
-    }
-    assert(prior > 0);
-#else
-    value_.fetch_add(1, std::memory_order_relaxed);
-#endif
-  }
-  void RefNonZero(const DebugLocation& location, const char* reason) {
-#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);
-    }
-    assert(prior > 0);
-#else
-    // Avoid unused-parameter warnings for debug-only parameters
-    (void)location;
-    (void)reason;
-    RefNonZero();
-#endif
-  }
-
-  bool RefIfNonZero() {
-#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);
-    }
-#endif
-    return IncrementIfNonzero(&value_);
-  }
-  bool RefIfNonZero(const DebugLocation& location, const char* reason) {
-#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);
-    }
-#endif
-    // Avoid unused-parameter warnings for debug-only parameters
-    (void)location;
-    (void)reason;
-    return IncrementIfNonzero(&value_);
-  }
-
-  // Decrements the ref-count and returns true if the ref-count reaches 0.
-  bool Unref() {
-#ifndef NDEBUG
-    // Grab a copy of the trace flag before the atomic change, since we
-    // will no longer be holding a ref afterwards and therefore can't
-    // safely access it, since another thread might free us in the interim.
-    auto* trace = trace_;
-#endif
-    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);
-    }
-    GPR_DEBUG_ASSERT(prior > 0);
-#endif
-    return prior == 1;
-  }
-  bool Unref(const DebugLocation& location, const char* reason) {
-#ifndef NDEBUG
-    // Grab a copy of the trace flag before the atomic change, since we
-    // will no longer be holding a ref afterwards and therefore can't
-    // safely access it, since another thread might free us in the interim.
-    auto* trace = trace_;
-#endif
-    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);
-    }
-    GPR_DEBUG_ASSERT(prior > 0);
-#else
-    // Avoid unused-parameter warnings for debug-only parameters
-    (void)location;
-    (void)reason;
-#endif
-    return prior == 1;
-  }
-
- private:
-  Value get() const { return value_.load(std::memory_order_relaxed); }
-
-#ifndef NDEBUG
-  const char* trace_;
-#endif
-  std::atomic<Value> value_{0};
-};
-
-// PolymorphicRefCount enforces polymorphic destruction of RefCounted.
-class PolymorphicRefCount {
- public:
-  virtual ~PolymorphicRefCount() = default;
-};
-
-// NonPolymorphicRefCount does not enforce polymorphic destruction of
-// RefCounted. Please refer to RefCounted for more details, and
-// when in doubt use PolymorphicRefCount.
-class NonPolymorphicRefCount {
- public:
-  ~NonPolymorphicRefCount() = default;
-};
-
-// Behavior of RefCounted<> upon ref count reaching 0.
-
-// Default behavior: Delete the object.
-struct UnrefDelete {
-  template <typename T>
-  void operator()(T* p) const {
-    delete p;
-  }
-};
-
-// Do not delete the object upon unref.  This is useful in cases where all
-// existing objects must be tracked in a registry but the object's entry in
-// the registry cannot be removed from the object's dtor due to
-// synchronization issues.  In this case, the registry can be cleaned up
-// later by identifying entries for which RefIfNonZero() returns null.
-struct UnrefNoDelete {
-  template <typename T>
-  void operator()(T* /*p*/) const {}
-};
-
-// Call the object's dtor but do not delete it.  This is useful for cases
-// where the object is stored in memory allocated elsewhere (e.g., the call
-// arena).
-struct UnrefCallDtor {
-  template <typename T>
-  void operator()(T* p) const {
-    p->~T();
-  }
-};
-
-// 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.
-//
-// This will commonly be used by CRTP (curiously-recurring template pattern)
-// e.g., class MyClass : public RefCounted<MyClass>
-//
-// Use PolymorphicRefCount and NonPolymorphicRefCount to select between
-// different implementations of RefCounted.
-//
-// Note that NonPolymorphicRefCount does not support polymorphic destruction.
-// So, use NonPolymorphicRefCount only when both of the following conditions
-// are guaranteed to hold:
-// (a) Child is a concrete leaf class in RefCounted<Child>, and
-// (b) you are guaranteed to call Unref only on concrete leaf classes and not
-//     their parents.
-//
-// The following example is illegal, because calling Unref() will not call
-// the dtor of Child.
-//
-//    class Parent : public RefCounted<Parent, NonPolymorphicRefCount> {}
-//    class Child : public Parent {}
-//
-//    Child* ch;
-//    ch->Unref();
-//
-template <typename Child, typename Impl = PolymorphicRefCount,
-          typename UnrefBehavior = UnrefDelete>
-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));
-  }
-
-  // Ref() for const types.
-  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> Ref() const {
-    IncrementRefCount();
-    return RefCountedPtr<const Child>(static_cast<const 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);
-  }
-  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);
-  }
-
-  // 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.
-  explicit RefCounted(const char* trace = nullptr,
-                      intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace) {}
-
-  // Note: Tracing is a no-op on non-debug builds.
-  explicit RefCounted(UnrefBehavior b, const char* trace = nullptr,
-                      intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace), unref_behavior_(b) {}
-
- private:
-  // Allow RefCountedPtr<> to access IncrementRefCount().
-  template <typename T>
-  friend class RefCountedPtr;
-
-  void IncrementRefCount() const { refs_.Ref(); }
-  void IncrementRefCount(const DebugLocation& location,
-                         const char* reason) const {
-    refs_.Ref(location, reason);
-  }
-
-  mutable RefCount refs_;
-  GPR_NO_UNIQUE_ADDRESS UnrefBehavior unref_behavior_;
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_LIB_GPRPP_REF_COUNTED_H