Add utilities to facilitate correct usage of rtc::RefCounted classes.

We have a few places where RefCountedObject is a class that's inherited
from, whereas it's meant to be the 'final' class. We also have many
places with RefCountedObject boilerplate code that has been copy pasted
around but FinalRefCountedObject might be a better fit for the
implementation. Then there's the fact that it would be nice to reduce the
amount of required boilerplate code.

Bug: webrtc:12701
Change-Id: I0aaf55197c8640b1b17d20c7c15c8d0bb3605161
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/215928
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33815}

rtc_base/BUILD.gn

@@ -198,7 +198,10 @@ rtc_source_set("refcount") {
     "ref_counted_object.h",
     "ref_counter.h",
   ]
-  deps = [ ":macromagic" ]
+  deps = [
+    ":macromagic",
+    "../api:scoped_refptr",
+  ]
 }
 
 rtc_library("criticalsection") {

rtc_base/ref_counted_object.h

@@ -13,6 +13,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "api/scoped_refptr.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/ref_count.h"
 #include "rtc_base/ref_counter.h"
@@ -69,6 +70,15 @@ class FinalRefCountedObject final : public T {
   FinalRefCountedObject(const FinalRefCountedObject&) = delete;
   FinalRefCountedObject& operator=(const FinalRefCountedObject&) = delete;
 
+  template <class P0>
+  explicit FinalRefCountedObject(P0&& p0) : T(std::forward<P0>(p0)) {}
+
+  template <class P0, class P1, class... Args>
+  FinalRefCountedObject(P0&& p0, P1&& p1, Args&&... args)
+      : T(std::forward<P0>(p0),
+          std::forward<P1>(p1),
+          std::forward<Args>(args)...) {}
+
   void AddRef() const { ref_count_.IncRef(); }
   void Release() const {
     if (ref_count_.DecRef() == RefCountReleaseStatus::kDroppedLastRef) {
@@ -83,6 +93,113 @@ class FinalRefCountedObject final : public T {
   mutable webrtc::webrtc_impl::RefCounter ref_count_{0};
 };
 
+// General utilities for constructing a reference counted class and the
+// appropriate reference count implementation for that class.
+//
+// These utilities select either the `RefCountedObject` implementation or
+// `FinalRefCountedObject` depending on whether the to-be-shared class is
+// derived from the RefCountInterface interface or not (respectively).
+
+// `make_ref_counted`:
+//
+// Use this when you want to construct a reference counted object of type T and
+// get a `scoped_refptr<>` back. Example:
+//
+//   auto p = make_ref_counted<Foo>("bar", 123);
+//
+// For a class that inherits from RefCountInterface, this is equivalent to:
+//
+//   auto p = scoped_refptr<Foo>(new RefCountedObject<Foo>("bar", 123));
+//
+// If the class does not inherit from RefCountInterface, the example is
+// equivalent to:
+//
+//   auto p = scoped_refptr<FinalRefCountedObject<Foo>>(
+//       new FinalRefCountedObject<Foo>("bar", 123));
+//
+// In these cases, `make_ref_counted` reduces the amount of boilerplate code but
+// also helps with the most commonly intended usage of RefCountedObject whereby
+// methods for reference counting, are virtual and designed to satisfy the need
+// of an interface. When such a need does not exist, it is more efficient to use
+// the `FinalRefCountedObject` template, which does not add the vtable overhead.
+//
+// Note that in some cases, using RefCountedObject directly may still be what's
+// needed.
+
+// `make_ref_counted` for classes that are convertible to RefCountInterface.
+template <
+    typename T,
+    typename... Args,
+    typename std::enable_if<std::is_convertible<T*, RefCountInterface*>::value,
+                            T>::type* = nullptr>
+scoped_refptr<T> make_ref_counted(Args&&... args) {
+  return new RefCountedObject<T>(std::forward<Args>(args)...);
+}
+
+// `make_ref_counted` for complete classes that are not convertible to
+// RefCountInterface.
+template <
+    typename T,
+    typename... Args,
+    typename std::enable_if<!std::is_convertible<T*, RefCountInterface*>::value,
+                            T>::type* = nullptr>
+scoped_refptr<FinalRefCountedObject<T>> make_ref_counted(Args&&... args) {
+  return new FinalRefCountedObject<T>(std::forward<Args>(args)...);
+}
+
+// `Ref<>`, `Ref<>::Type` and `Ref<>::Ptr`:
+//
+// `Ref` is a type declaring utility that is compatible with `make_ref_counted`
+// and can be used in classes and methods where it's more convenient (or
+// readable) to have the compiler figure out the fully fleshed out type for a
+// class rather than spell it out verbatim in all places the type occurs (which
+// can mean maintenance work if the class layout changes).
+//
+// Usage examples:
+//
+// If you want to declare the parameter type that's always compatible with
+// this code:
+//
+//   Bar(make_ref_counted<Foo>());
+//
+// You can use `Ref<>::Ptr` to declare a compatible scoped_refptr type:
+//
+//   void Bar(Ref<Foo>::Ptr p);
+//
+// This might be more practically useful in templates though.
+//
+// In rare cases you might need to be able to declare a parameter that's fully
+// compatible with the reference counted T type - and just using T* is not
+// enough. To give a code example, we can declare a function, `Foo` that is
+// compatible with this code:
+//   auto p = make_ref_counted<Foo>();
+//   Foo(p.get());
+//
+//   void Foo(Ref<Foo>::Type* foo_ptr);
+//
+// Alternatively this would be:
+//   void Foo(Foo* foo_ptr);
+// or
+//   void Foo(FinalRefCountedObject<Foo>* foo_ptr);
+
+// Declares the approprate reference counted type for T depending on whether
+// T is convertible to RefCountInterface or not.
+// For classes that are convertible, the type will simply be T.
+// For classes that cannot be converted to RefCountInterface, the type will be
+// FinalRefCountedObject<T>.
+// This is most useful for declaring a scoped_refptr<T> instance for a class
+// that may or may not implement a virtual reference counted interface:
+// * scoped_refptr<Ref<Foo>::Type> my_ptr;
+template <typename T>
+struct Ref {
+  typedef typename std::conditional<
+      std::is_convertible<T*, RefCountInterface*>::value,
+      T,
+      FinalRefCountedObject<T>>::type Type;
+
+  typedef scoped_refptr<Type> Ptr;
+};
+
 }  // namespace rtc
 
 #endif  // RTC_BASE_REF_COUNTED_OBJECT_H_

rtc_base/ref_counted_object_unittest.cc

@@ -64,6 +64,20 @@ class RefClassWithMixedValues : public RefCountInterface {
   std::string c_;
 };
 
+class Foo {
+ public:
+  Foo() {}
+  Foo(int i, int j) : foo_(i + j) {}
+  int foo_ = 0;
+};
+
+class FooItf : public RefCountInterface {
+ public:
+  FooItf() {}
+  FooItf(int i, int j) : foo_(i + j) {}
+  int foo_ = 0;
+};
+
 }  // namespace
 
 TEST(RefCountedObject, HasOneRef) {
@@ -111,4 +125,42 @@ TEST(FinalRefCountedObject, CanWrapIntoScopedRefptr) {
   EXPECT_TRUE(ref2->HasOneRef());
 }
 
+// This test is mostly a compile-time test for scoped_refptr compatibility.
+TEST(RefCounted, SmartPointers) {
+  // Sanity compile-time tests. FooItf is virtual, Foo is not, FooItf inherits
+  // from RefCountInterface, Foo does not.
+  static_assert(std::is_base_of<RefCountInterface, FooItf>::value, "");
+  static_assert(!std::is_base_of<RefCountInterface, Foo>::value, "");
+  static_assert(std::is_polymorphic<FooItf>::value, "");
+  static_assert(!std::is_polymorphic<Foo>::value, "");
+
+  // Check if Ref generates the expected types for Foo and FooItf.
+  static_assert(std::is_base_of<Foo, Ref<Foo>::Type>::value &&
+                    !std::is_same<Foo, Ref<Foo>::Type>::value,
+                "");
+  static_assert(std::is_same<FooItf, Ref<FooItf>::Type>::value, "");
+
+  {
+    // Test with FooItf, a class that inherits from RefCountInterface.
+    // Check that we get a valid FooItf reference counted object.
+    auto p = make_ref_counted<FooItf>(2, 3);
+    EXPECT_NE(p.get(), nullptr);
+    EXPECT_EQ(p->foo_, 5);  // the FooItf ctor just stores 2+3 in foo_.
+
+    // Use a couple of different ways of declaring what should result in the
+    // same type as `p` is of.
+    scoped_refptr<Ref<FooItf>::Type> p2 = p;
+    Ref<FooItf>::Ptr p3 = p;
+  }
+
+  {
+    // Same for `Foo`
+    auto p = make_ref_counted<Foo>(2, 3);
+    EXPECT_NE(p.get(), nullptr);
+    EXPECT_EQ(p->foo_, 5);
+    scoped_refptr<Ref<Foo>::Type> p2 = p;
+    Ref<Foo>::Ptr p3 = p;
+  }
+}
+
 }  // namespace rtc