From 1dd09321cd1e8bbd4a205f990ad9ec41897c7ec5 Mon Sep 17 00:00:00 2001
From: Soheil Hassas Yeganeh <soheil@google.com>
Date: Tue, 13 Nov 2018 14:35:24 -0500
Subject: Add a non-polymorphic variant to RefCounted.

Using RefCounted<Child, NonPolymorphic> users can now build smart,
ref-counted pointers without paying the costs of a vtable when it's
possible.
---
 test/core/gprpp/ref_counted_test.cc | 47 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 46 insertions(+), 1 deletion(-)

(limited to 'test/core')

diff --git a/test/core/gprpp/ref_counted_test.cc b/test/core/gprpp/ref_counted_test.cc
index f85a2e4675..62a3ea4d53 100644
--- a/test/core/gprpp/ref_counted_test.cc
+++ b/test/core/gprpp/ref_counted_test.cc
@@ -29,7 +29,10 @@ namespace {
 
 class Foo : public RefCounted<Foo> {
  public:
-  Foo() {}
+  Foo() {
+    static_assert(std::has_virtual_destructor<Foo>::value,
+                  "PolymorphicRefCount doesn't have a virtual dtor");
+  }
 };
 
 TEST(RefCounted, Basic) {
@@ -45,6 +48,28 @@ TEST(RefCounted, ExtraRef) {
   foo->Unref();
 }
 
+class FooNonPolymorphic
+    : public RefCounted<FooNonPolymorphic, NonPolymorphicRefCount> {
+ public:
+  FooNonPolymorphic() {
+    static_assert(!std::has_virtual_destructor<FooNonPolymorphic>::value,
+                  "NonPolymorphicRefCount has a virtual dtor");
+  }
+};
+
+TEST(RefCountedNonPolymorphic, Basic) {
+  FooNonPolymorphic* foo = New<FooNonPolymorphic>();
+  foo->Unref();
+}
+
+TEST(RefCountedNonPolymorphic, ExtraRef) {
+  FooNonPolymorphic* foo = New<FooNonPolymorphic>();
+  RefCountedPtr<FooNonPolymorphic> foop = foo->Ref();
+  foop.release();
+  foo->Unref();
+  foo->Unref();
+}
+
 // Note: We use DebugOnlyTraceFlag instead of TraceFlag to ensure that
 // things build properly in both debug and non-debug cases.
 DebugOnlyTraceFlag foo_tracer(true, "foo");
@@ -66,6 +91,26 @@ TEST(RefCountedWithTracing, Basic) {
   foo->Unref(DEBUG_LOCATION, "original_ref");
 }
 
+class FooNonPolymorphicWithTracing
+    : public RefCountedWithTracing<FooNonPolymorphicWithTracing,
+                                   NonPolymorphicRefCount> {
+ public:
+  FooNonPolymorphicWithTracing() : RefCountedWithTracing(&foo_tracer) {}
+};
+
+TEST(RefCountedNonPolymorphicWithTracing, Basic) {
+  FooNonPolymorphicWithTracing* foo = New<FooNonPolymorphicWithTracing>();
+  RefCountedPtr<FooNonPolymorphicWithTracing> foop =
+      foo->Ref(DEBUG_LOCATION, "extra_ref");
+  foop.release();
+  foo->Unref(DEBUG_LOCATION, "extra_ref");
+  // Can use the no-argument methods, too.
+  foop = foo->Ref();
+  foop.release();
+  foo->Unref();
+  foo->Unref(DEBUG_LOCATION, "original_ref");
+}
+
 }  // namespace
 }  // namespace testing
 }  // namespace grpc_core
-- 
cgit v1.2.3