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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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/. */
#ifndef MOZILLA_ATOMICREFCOUNTEDWITHFINALIZE_H_
#define MOZILLA_ATOMICREFCOUNTEDWITHFINALIZE_H_
#include "mozilla/RefPtr.h"
#include "mozilla/Likely.h"
#include "MainThreadUtils.h"
#include "base/message_loop.h"
#include "base/task.h"
#include "mozilla/gfx/Logging.h"
#define ADDREF_MANUALLY(obj) (obj)->AddRefManually(__FUNCTION__, __FILE__, __LINE__)
#define RELEASE_MANUALLY(obj) (obj)->ReleaseManually(__FUNCTION__, __FILE__, __LINE__)
namespace mozilla {
template<class U>
class StaticRefPtr;
namespace gl {
template<typename T>
class RefSet;
template<typename T>
class RefQueue;
} // namespace gl
template<typename T>
class AtomicRefCountedWithFinalize
{
protected:
explicit AtomicRefCountedWithFinalize(const char* aName)
: mRecycleCallback(nullptr)
, mRefCount(0)
#ifdef DEBUG
, mSpew(false)
, mManualAddRefs(0)
, mManualReleases(0)
#endif
#ifdef NS_BUILD_REFCNT_LOGGING
, mName(aName)
#endif
{}
~AtomicRefCountedWithFinalize() {
if (mRefCount >= 0) {
gfxCriticalError() << "Deleting referenced object? " << mRefCount;
}
}
public:
// Mark user classes that are considered flawless.
template<class U>
friend class ::mozilla::StaticRefPtr;
template<class U>
friend struct mozilla::RefPtrTraits;
template<typename U>
friend class ::mozilla::gl::RefSet;
template<typename U>
friend class ::mozilla::gl::RefQueue;
//friend class mozilla::gl::SurfaceFactory;
void AddRefManually(const char* funcName, const char* fileName, uint32_t lineNum) {
#ifdef DEBUG
uint32_t count = ++mManualAddRefs;
if (mSpew) {
printf_stderr("AddRefManually() #%u in %s at %s:%u\n", count, funcName,
fileName, lineNum);
}
#else
(void)funcName;
(void)fileName;
(void)lineNum;
#endif
AddRef();
}
void ReleaseManually(const char* funcName, const char* fileName, uint32_t lineNum) {
#ifdef DEBUG
uint32_t count = ++mManualReleases;
if (mSpew) {
printf_stderr("ReleaseManually() #%u in %s at %s:%u\n", count, funcName,
fileName, lineNum);
}
#else
(void)funcName;
(void)fileName;
(void)lineNum;
#endif
Release();
}
private:
void AddRef() {
MOZ_ASSERT(mRefCount >= 0, "AddRef() during/after Finalize()/dtor.");
mRefCount++;
NS_LOG_ADDREF(this, mRefCount, mName, sizeof(*this));
}
void Release() {
MOZ_ASSERT(mRefCount > 0, "Release() during/after Finalize()/dtor.");
// Read mRecycleCallback early so that it does not get set to
// deleted memory, if the object is goes away. See bug 994903.
// This saves us in the case where there is no callback, so that
// we can do the "else if" below.
RecycleCallback recycleCallback = mRecycleCallback;
int currCount = --mRefCount;
if (currCount < 0) {
gfxCriticalError() << "Invalid reference count release" << currCount;
++mRefCount;
return;
}
NS_LOG_RELEASE(this, currCount, mName);
if (0 == currCount) {
mRefCount = detail::DEAD;
MOZ_ASSERT(IsDead());
// Recycle listeners must call ClearRecycleCallback
// before releasing their strong reference.
if (mRecycleCallback) {
gfxCriticalError() << "About to release with valid callback";
mRecycleCallback = nullptr;
}
MOZ_ASSERT(mManualAddRefs == mManualReleases);
T* derived = static_cast<T*>(this);
derived->Finalize();
delete derived;
} else if (1 == currCount && recycleCallback) {
// There is nothing enforcing this in the code, except how the callers
// are being careful to never let the reference count go down if there
// is a callback.
MOZ_ASSERT(!IsDead());
T* derived = static_cast<T*>(this);
recycleCallback(derived, mClosure);
}
}
public:
typedef void (*RecycleCallback)(T* aObject, void* aClosure);
/**
* Set a callback responsible for recycling this object
* before it is finalized.
*/
void SetRecycleCallback(RecycleCallback aCallback, void* aClosure)
{
MOZ_ASSERT(!IsDead());
mRecycleCallback = aCallback;
mClosure = aClosure;
}
void ClearRecycleCallback()
{
MOZ_ASSERT(!IsDead());
SetRecycleCallback(nullptr, nullptr);
}
bool HasRecycleCallback() const
{
MOZ_ASSERT(!IsDead());
return !!mRecycleCallback;
}
bool IsDead() const
{
return mRefCount < 0;
}
private:
RecycleCallback mRecycleCallback;
void *mClosure;
Atomic<int> mRefCount;
#ifdef DEBUG
public:
bool mSpew;
private:
Atomic<uint32_t> mManualAddRefs;
Atomic<uint32_t> mManualReleases;
#endif
#ifdef NS_BUILD_REFCNT_LOGGING
const char* mName;
#endif
};
} // namespace mozilla
#endif
|
