blob: 8c5aaf31c2fc7d7c4e567576b0a1ad84c0b7a5c2 (
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
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
|
// Copyright (c) 2012 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_DEBUG_LEAK_TRACKER_H_
#define BASE_DEBUG_LEAK_TRACKER_H_
#include "build/build_config.h"
// Only enable leak tracking in non-uClibc debug builds.
#if !defined(NDEBUG) && !defined(__UCLIBC__)
#define ENABLE_LEAK_TRACKER
#endif
#ifdef ENABLE_LEAK_TRACKER
#include "base/containers/linked_list.h"
#include "base/debug/stack_trace.h"
#include "base/logging.h"
#endif // ENABLE_LEAK_TRACKER
// LeakTracker is a 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 net::URLRequest, start by
// adding a member variable of type LeakTracker<net::URLRequest>.
//
// class URLRequest {
// ...
// private:
// base::LeakTracker<URLRequest> leak_tracker_;
// };
//
//
// Next, when we believe all instances of net::URLRequest have been deleted:
//
// LeakTracker<net::URLRequest>::CheckForLeaks();
//
// Should the check fail (because there are live instances of net::URLRequest),
// then the allocation callstack for each leaked instances is dumped to
// the error log.
//
// If ENABLE_LEAK_TRACKER is not defined, then the check has no effect.
namespace base {
namespace debug {
#ifndef ENABLE_LEAK_TRACKER
// If leak tracking is disabled, do nothing.
template<typename T>
class LeakTracker {
public:
~LeakTracker() {}
static void CheckForLeaks() {}
static int NumLiveInstances() { return -1; }
};
#else
// If leak tracking is enabled 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.
size_t count = 0;
// Copy the first 3 leak allocation callstacks onto the stack.
// This way if we hit the CHECK() in a release build, the leak
// information will be available in mini-dump.
const size_t kMaxStackTracesToCopyOntoStack = 3;
StackTrace stacktraces[kMaxStackTracesToCopyOntoStack];
for (LinkNode<LeakTracker<T> >* node = instances()->head();
node != instances()->end();
node = node->next()) {
StackTrace& allocation_stack = node->value()->allocation_stack_;
if (count < kMaxStackTracesToCopyOntoStack)
stacktraces[count] = allocation_stack;
++count;
if (LOG_IS_ON(ERROR)) {
LOG_STREAM(ERROR) << "Leaked " << node << " which was allocated by:";
allocation_stack.OutputToStream(&LOG_STREAM(ERROR));
}
}
CHECK_EQ(0u, count);
// Hack to keep |stacktraces| and |count| alive (so compiler
// doesn't optimize it out, and it will appear in mini-dumps).
if (count == 0x1234) {
for (size_t i = 0; i < kMaxStackTracesToCopyOntoStack; ++i)
stacktraces[i].Print();
}
}
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 // ENABLE_LEAK_TRACKER
} // namespace debug
} // namespace base
#endif // BASE_DEBUG_LEAK_TRACKER_H_
|
