base/debug/leak_tracker.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef BASE_DEBUG_LEAK_TRACKER_H_
   6 #define BASE_DEBUG_LEAK_TRACKER_H_
   7
   8 #include "build/build_config.h"
   9
  10 // Only enable leak tracking in non-uClibc debug builds.
  11 #if !defined(NDEBUG) && !defined(__UCLIBC__)
  12 #define ENABLE_LEAK_TRACKER
  13 #endif
  14
  15 #ifdef ENABLE_LEAK_TRACKER
  16 #include "base/containers/linked_list.h"
  17 #include "base/debug/stack_trace.h"
  18 #include "base/logging.h"
  19 #endif  // ENABLE_LEAK_TRACKER
  20
  21 // LeakTracker is a helper to verify that all instances of a class
  22 // have been destroyed.
  23 //
  24 // It is particularly useful for classes that are bound to a single thread --
  25 // before destroying that thread, one can check that there are no remaining
  26 // instances of that class.
  27 //
  28 // For example, to enable leak tracking for class net::URLRequest, start by
  29 // adding a member variable of type LeakTracker<net::URLRequest>.
  30 //
  31 //   class URLRequest {
  32 //     ...
  33 //    private:
  34 //     base::LeakTracker<URLRequest> leak_tracker_;
  35 //   };
  36 //
  37 //
  38 // Next, when we believe all instances of net::URLRequest have been deleted:
  39 //
  40 //   LeakTracker<net::URLRequest>::CheckForLeaks();
  41 //
  42 // Should the check fail (because there are live instances of net::URLRequest),
  43 // then the allocation callstack for each leaked instances is dumped to
  44 // the error log.
  45 //
  46 // If ENABLE_LEAK_TRACKER is not defined, then the check has no effect.
  47
  48 namespace base {
  49 namespace debug {
  50
  51 #ifndef ENABLE_LEAK_TRACKER
  52
  53 // If leak tracking is disabled, do nothing.
  54 template<typename T>
  55 class LeakTracker {
  56  public:
  57   ~LeakTracker() {}
  58   static void CheckForLeaks() {}
  59   static int NumLiveInstances() { return -1; }
  60 };
  61
  62 #else
  63
  64 // If leak tracking is enabled we track where the object was allocated from.
  65
  66 template<typename T>
  67 class LeakTracker : public LinkNode<LeakTracker<T> > {
  68  public:
  69   LeakTracker() {
  70     instances()->Append(this);
  71   }
  72
  73   ~LeakTracker() {
  74     this->RemoveFromList();
  75   }
  76
  77   static void CheckForLeaks() {
  78     // Walk the allocation list and print each entry it contains.
  79     size_t count = 0;
  80
  81     // Copy the first 3 leak allocation callstacks onto the stack.
  82     // This way if we hit the CHECK() in a release build, the leak
  83     // information will be available in mini-dump.
  84     const size_t kMaxStackTracesToCopyOntoStack = 3;
  85     StackTrace stacktraces[kMaxStackTracesToCopyOntoStack];
  86
  87     for (LinkNode<LeakTracker<T> >* node = instances()->head();
  88          node != instances()->end();
  89          node = node->next()) {
  90       StackTrace& allocation_stack = node->value()->allocation_stack_;
  91
  92       if (count < kMaxStackTracesToCopyOntoStack)
  93         stacktraces[count] = allocation_stack;
  94
  95       ++count;
  96       if (LOG_IS_ON(ERROR)) {
  97         LOG_STREAM(ERROR) << "Leaked " << node << " which was allocated by:";
  98         allocation_stack.OutputToStream(&LOG_STREAM(ERROR));
  99       }
 100     }
 101
 102     CHECK_EQ(0u, count);
 103
 104     // Hack to keep |stacktraces| and |count| alive (so compiler
 105     // doesn't optimize it out, and it will appear in mini-dumps).
 106     if (count == 0x1234) {
 107       for (size_t i = 0; i < kMaxStackTracesToCopyOntoStack; ++i)
 108         stacktraces[i].Print();
 109     }
 110   }
 111
 112   static int NumLiveInstances() {
 113     // Walk the allocation list and count how many entries it has.
 114     int count = 0;
 115     for (LinkNode<LeakTracker<T> >* node = instances()->head();
 116          node != instances()->end();
 117          node = node->next()) {
 118       ++count;
 119     }
 120     return count;
 121   }
 122
 123  private:
 124   // Each specialization of LeakTracker gets its own static storage.
 125   static LinkedList<LeakTracker<T> >* instances() {
 126     static LinkedList<LeakTracker<T> > list;
 127     return &list;
 128   }
 129
 130   StackTrace allocation_stack_;
 131 };
 132
 133 #endif  // ENABLE_LEAK_TRACKER
 134
 135 }  // namespace debug
 136 }  // namespace base
 137
 138 #endif  // BASE_DEBUG_LEAK_TRACKER_H_