rtc::Bind: Capture scoped_refptr reference arguments by value

webrtc/base/bind_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/gunit.h"
 
 #include "webrtc/base/refcount.h"
 
 namespace rtc {
 
 namespace {
 
+struct LifeTimeCheck;
+
 struct MethodBindTester {
   void NullaryVoid() { ++call_count; }
   int NullaryInt() { ++call_count; return 1; }
   int NullaryConst() const { ++call_count; return 2; }
   void UnaryVoid(int dummy) { ++call_count; }
   template <class T> T Identity(T value) { ++call_count; return value; }
   int UnaryByRef(int& value) const { ++call_count; return ++value; }  // NOLINT
   int Multiply(int a, int b) const { ++call_count; return a * b; }
+  void RefArgument(const scoped_refptr<LifeTimeCheck>& object) {
+    EXPECT_TRUE(object.get() != nullptr);
+  }
+
   mutable int call_count;
 };
 
 struct A { int dummy; };
 struct B: public RefCountInterface { int dummy; };
 struct C: public A, B {};
 struct D {
   int AddRef();
 };
 struct E: public D {
   int Release();
 };
 struct F {
   void AddRef();
   void Release();
 };
 
-class LifeTimeCheck : public RefCountInterface {
- public:
-  LifeTimeCheck(bool* has_died) : has_died_(has_died), is_ok_to_die_(false) {}
-  ~LifeTimeCheck() {
-    EXPECT_TRUE(is_ok_to_die_);
-    *has_died_ = true;
-  }
-  void PrepareToDie() { is_ok_to_die_ = true; }
+struct LifeTimeCheck {
+  LifeTimeCheck() : ref_count_(0) {}
+  void AddRef() { ++ref_count_; }
+  void Release() { --ref_count_; }
   void NullaryVoid() {}
-
- private:
-  bool* const has_died_;
-  bool is_ok_to_die_;
+  int ref_count_;
 };
 
 int Return42() { return 42; }
 int Negate(int a) { return -a; }
 int Multiply(int a, int b) { return a * b; }
 
 }  // namespace
 
 // Try to catch any problem with scoped_refptr type deduction in rtc::Bind at
 // compile time.
+static_assert(is_same<detail::RemoveScopedPtrRef<

[tommi, 2015/08/24 15:43:31]

these are nice

+                          const scoped_refptr<RefCountInterface>&>::type,
+                      scoped_refptr<RefCountInterface>>::value,
+              "const scoped_refptr& should be captured by value");
+
+static_assert(is_same<detail::RemoveScopedPtrRef<const scoped_refptr<F>&>::type,
+                      scoped_refptr<F>>::value,
+              "const scoped_refptr& should be captured by value");
+
+static_assert(
+    is_same<detail::RemoveScopedPtrRef<const int&>::type, const int&>::value,
+    "const int& should be captured as const int&");
+
+static_assert(
+    is_same<detail::RemoveScopedPtrRef<const F&>::type, const F&>::value,
+    "const F& should be captured as const F&");
+
+static_assert(
+    is_same<detail::RemoveScopedPtrRef<F&>::type, F&>::value,
+    "F& should be captured as F&");
+
 #define EXPECT_IS_CAPTURED_AS_PTR(T)                              \
   static_assert(is_same<detail::PointerType<T>::type, T*>::value, \
                 "PointerType")
 #define EXPECT_IS_CAPTURED_AS_SCOPED_REFPTR(T)                        \
   static_assert(                                                      \
       is_same<detail::PointerType<T>::type, scoped_refptr<T>>::value, \
       "PointerType")
 
 EXPECT_IS_CAPTURED_AS_PTR(void);
 EXPECT_IS_CAPTURED_AS_PTR(int);
@@ skipping 39 matching lines @@
 
 TEST(BindTest, BindToFunction) {
   EXPECT_EQ(42, Bind(&Return42)());
   EXPECT_EQ(3, Bind(&Negate, -3)());
   EXPECT_EQ(56, Bind(&Multiply, 8, 7)());
 }
 
 // Test Bind where method object implements RefCountInterface and is passed as a
 // pointer.
 TEST(BindTest, CapturePointerAsScopedRefPtr) {
-  bool object_has_died = false;
-  scoped_refptr<LifeTimeCheck> object =
-      new RefCountedObject<LifeTimeCheck>(&object_has_died);
+  LifeTimeCheck object;
+  EXPECT_EQ(object.ref_count_, 0);
+  scoped_refptr<LifeTimeCheck> scoped_object(&object);
+  EXPECT_EQ(object.ref_count_, 1);
   {
-    auto functor = Bind(&LifeTimeCheck::PrepareToDie, object.get());
-    object = nullptr;
-    EXPECT_FALSE(object_has_died);
-    // Run prepare to die via functor.
-    functor();
+    auto functor = Bind(&LifeTimeCheck::NullaryVoid, &object);
+    EXPECT_EQ(object.ref_count_, 2);
+    scoped_object = nullptr;
+    EXPECT_EQ(object.ref_count_, 1);
   }
-  EXPECT_TRUE(object_has_died);
+  EXPECT_EQ(object.ref_count_, 0);
 }
 
 // Test Bind where method object implements RefCountInterface and is passed as a
 // scoped_refptr<>.
 TEST(BindTest, CaptureScopedRefPtrAsScopedRefPtr) {
-  bool object_has_died = false;
-  scoped_refptr<LifeTimeCheck> object =
-      new RefCountedObject<LifeTimeCheck>(&object_has_died);
+  LifeTimeCheck object;
+  EXPECT_EQ(object.ref_count_, 0);
+  scoped_refptr<LifeTimeCheck> scoped_object(&object);
+  EXPECT_EQ(object.ref_count_, 1);
   {
-    auto functor = Bind(&LifeTimeCheck::PrepareToDie, object);
-    object = nullptr;
-    EXPECT_FALSE(object_has_died);
-    // Run prepare to die via functor.
-    functor();
+    auto functor = Bind(&LifeTimeCheck::NullaryVoid, scoped_object);
+    EXPECT_EQ(object.ref_count_, 2);
+    scoped_object = nullptr;
+    EXPECT_EQ(object.ref_count_, 1);
   }
-  EXPECT_TRUE(object_has_died);
+  EXPECT_EQ(object.ref_count_, 0);
 }
 
 // Test Bind where method object is captured as scoped_refptr<> and the functor
 // dies while there are references left.
 TEST(BindTest, FunctorReleasesObjectOnDestruction) {
-  bool object_has_died = false;
-  scoped_refptr<LifeTimeCheck> object =
-      new RefCountedObject<LifeTimeCheck>(&object_has_died);
-  Bind(&LifeTimeCheck::NullaryVoid, object.get())();
-  EXPECT_FALSE(object_has_died);
-  object->PrepareToDie();
-  object = nullptr;
-  EXPECT_TRUE(object_has_died);
+  LifeTimeCheck object;
+  EXPECT_EQ(object.ref_count_, 0);
+  scoped_refptr<LifeTimeCheck> scoped_object(&object);
+  EXPECT_EQ(object.ref_count_, 1);
+  Bind(&LifeTimeCheck::NullaryVoid, &object)();
+  EXPECT_EQ(object.ref_count_, 1);
+  scoped_object = nullptr;
+  EXPECT_EQ(object.ref_count_, 0);
+}
+
+// Test Bind with scoped_refptr<> argument.
+TEST(BindTest, ScopedRefPointerArgument) {
+  LifeTimeCheck object;
+  EXPECT_EQ(object.ref_count_, 0);
+  scoped_refptr<LifeTimeCheck> scoped_object(&object);
+  EXPECT_EQ(object.ref_count_, 1);
+  {
+    MethodBindTester bind_tester;
+    auto functor =
+        Bind(&MethodBindTester::RefArgument, &bind_tester, scoped_object);
+    EXPECT_EQ(object.ref_count_, 2);
+  }
+  EXPECT_EQ(object.ref_count_, 1);
+  scoped_object = nullptr;
+  EXPECT_EQ(object.ref_count_, 0);
+}
+
+namespace {
+
+const int* Ref(const int& a) { return &a; }
+
+}  // anonymous namespace
+
+// Test Bind with non-scoped_refptr<> reference argument.
+TEST(BindTest, RefArgument) {
+  const int x = 42;
+  EXPECT_TRUE(Ref(x) == &x);
+  // Bind() should not make a copy of |x|, i.e. the pointers should be the same.
+  auto functor = Bind(&Ref, x);
+  EXPECT_TRUE(functor() == &x);
 }
 
 }  // namespace rtc