blob: d289691ec8b706d3f365c383922a56eb1bc7d694 (
plain)
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
|
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_LEAK_TRACKER_H_
#define BASE_LEAK_TRACKER_H_
#ifndef NDEBUG
#include "base/debug_util.h"
#include "base/linked_list.h"
#include "base/logging.h"
#endif
// LeakTracker is a debug helper to verify that all instances of a class
// have been destroyed.
//
// It is particularly useful for classes that are bound to a single thread --
// before destroying that thread, one can check that there are no remaining
// instances of that class.
//
// For example, to enable leak tracking for class URLRequest, start by
// adding a member variable of type LeakTracker<URLRequest>.
//
// class URLRequest {
// ...
// private:
// base::LeakTracker<URLRequest> leak_tracker_;
// };
//
//
// Next, when we believe all instances of URLRequest have been deleted:
//
// LeakTracker<URLRequest>::CheckForLeaks();
//
// Should the check fail (because there are live instances of URLRequest),
// then the allocation callstack for each leaked instances is dumped to
// the error log.
//
// In RELEASE mode the check has no effect.
namespace base {
#ifdef NDEBUG
// In release mode we do nothing.
template<typename T>
class LeakTracker {
public:
static void CheckForLeaks() {}
static int NumLiveInstances() { return -1; }
};
#else
// In debug mode we track where the object was allocated from.
template<typename T>
class LeakTracker : public LinkNode<LeakTracker<T> > {
public:
LeakTracker() {
instances()->Append(this);
}
~LeakTracker() {
this->RemoveFromList();
}
static void CheckForLeaks() {
// Walk the allocation list and print each entry it contains.
int count = 0;
for (LinkNode<LeakTracker<T> >* node = instances()->head();
node != instances()->end();
node = node->next()) {
++count;
LOG(ERROR) << "Leaked " << node << " which was allocated by:";
node->value()->allocation_stack_.PrintBacktrace();
}
DCHECK_EQ(0, count);
}
static int NumLiveInstances() {
// Walk the allocation list and count how many entries it has.
int count = 0;
for (LinkNode<LeakTracker<T> >* node = instances()->head();
node != instances()->end();
node = node->next()) {
++count;
}
return count;
}
private:
// Each specialization of LeakTracker gets its own static storage.
static LinkedList<LeakTracker<T> >* instances() {
static LinkedList<LeakTracker<T> > list;
return &list;
}
StackTrace allocation_stack_;
};
#endif // NDEBUG
} // namespace base
#endif // BASE_LEAK_TRACKER_H_
|
