1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// This header provides virtual, non-templated alternatives to MFBT's
// RefCounted<T>. It intentionally uses MFBT coding style with the intention of
// moving there should there be other use cases for it.
#ifndef MOZILLA_GENERICREFCOUNTED_H_
#define MOZILLA_GENERICREFCOUNTED_H_
#include <type_traits>
#include "mozilla/RefPtr.h"
#include "mozilla/RefCounted.h"
namespace mozilla {
/**
* Common base class for GenericRefCounted and GenericAtomicRefCounted.
*
* Having this shared base class, common to both the atomic and non-atomic
* cases, allows to have RefPtr's that don't care about whether the
* objects they're managing have atomic refcounts or not.
*/
class GenericRefCountedBase {
protected:
virtual ~GenericRefCountedBase() = default;
public:
// AddRef() and Release() method names are for compatibility with nsRefPtr.
virtual void AddRef() = 0;
virtual void Release() = 0;
// ref() and deref() method names are for compatibility with wtf::RefPtr.
// No virtual keywords here: if a subclass wants to override the refcounting
// mechanism, it is welcome to do so by overriding AddRef() and Release().
void ref() { AddRef(); }
void deref() { Release(); }
#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
virtual const char* typeName() const = 0;
virtual size_t typeSize() const = 0;
#endif
};
namespace detail {
template <RefCountAtomicity Atomicity>
class GenericRefCounted : public GenericRefCountedBase {
protected:
GenericRefCounted() : refCnt(0) {}
virtual ~GenericRefCounted() { MOZ_ASSERT(refCnt == detail::DEAD); }
public:
virtual void AddRef() override {
// Note: this method must be thread safe for GenericAtomicRefCounted.
MOZ_ASSERT(int32_t(refCnt) >= 0);
MozRefCountType cnt = ++refCnt;
detail::RefCountLogger::logAddRef(this, cnt);
}
virtual void Release() override {
// Note: this method must be thread safe for GenericAtomicRefCounted.
MOZ_ASSERT(int32_t(refCnt) > 0);
detail::RefCountLogger::ReleaseLogger logger{this};
MozRefCountType cnt = --refCnt;
// Note: it's not safe to touch |this| after decrementing the refcount,
// except for below.
logger.logRelease(cnt);
if (0 == cnt) {
// Because we have atomically decremented the refcount above, only
// one thread can get a 0 count here, so as long as we can assume that
// everything else in the system is accessing this object through
// RefPtrs, it's safe to access |this| here.
#ifdef DEBUG
refCnt = detail::DEAD;
#endif
delete this;
}
}
MozRefCountType refCount() const { return refCnt; }
bool hasOneRef() const {
MOZ_ASSERT(refCnt > 0);
return refCnt == 1;
}
private:
std::conditional_t<Atomicity == AtomicRefCount, Atomic<MozRefCountType>,
MozRefCountType>
refCnt;
};
} // namespace detail
/**
* This reference-counting base class is virtual instead of
* being templated, which is useful in cases where one needs
* genericity at binary code level, but comes at the cost
* of a moderate performance and size overhead, like anything virtual.
*/
class GenericRefCounted
: public detail::GenericRefCounted<detail::NonAtomicRefCount> {};
/**
* GenericAtomicRefCounted is like GenericRefCounted, with an atomically updated
* reference counter.
*/
class GenericAtomicRefCounted
: public detail::GenericRefCounted<detail::AtomicRefCount> {};
} // namespace mozilla
#endif
|
