[NOT TO COMMIT!] Replace third_party/tcmalloc/chromium with tcmalloc r136 (the latest).

third_party/tcmalloc/chromium/src/google/heap-checker.h

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 163 matching lines @@
   class Disabler {
    public:
     Disabler();
     ~Disabler();
    private:
     Disabler(const Disabler&);        // disallow copy
     void operator=(const Disabler&);  // and assign
   };
 
   // Ignore an object located at 'ptr' (can go at the start or into the object)
-  // as well as all heap objects (transitively) referenced from it
-  // for the purposes of heap leak checking.
-  // If 'ptr' does not point to an active allocated object
-  // at the time of this call, it is ignored;
-  // but if it does, the object must not get deleted from the heap later on;
-  // it must also be not already ignored at the time of this call.
+  // as well as all heap objects (transitively) referenced from it for the
+  // purposes of heap leak checking. Returns 'ptr' so that one can write
+  //   static T* obj = IgnoreObject(new T(...));
+  //
+  // If 'ptr' does not point to an active allocated object at the time of this
+  // call, it is ignored; but if it does, the object must not get deleted from
+  // the heap later on.
   //
   // See also HiddenPointer, below, if you need to prevent a pointer from
   // being traversed by the heap checker but do not wish to transitively
   // whitelist objects referenced through it.
-  static void IgnoreObject(const void* ptr);
+  template <typename T>
+  static T* IgnoreObject(T* ptr) {
+    DoIgnoreObject(static_cast<const void*>(const_cast<const T*>(ptr)));
+    return ptr;
+  }
 
   // Undo what an earlier IgnoreObject() call promised and asked to do.
   // At the time of this call 'ptr' must point at or inside of an active
   // allocated object which was previously registered with IgnoreObject().
   static void UnIgnoreObject(const void* ptr);
 
   // ----------------------------------------------------------------------- //
-  // Initialization; to be called from main() only.
-
-  // Full starting of recommended whole-program checking.
-  static void InternalInitStart();
-
-  // ----------------------------------------------------------------------- //
   // Internal types defined in .cc
 
   class Allocator;
   struct RangeValue;
 
  private:
 
   // ----------------------------------------------------------------------- //
   // Various helpers
 
   // Create the name of the heap profile file.
   // Should be deleted via Allocator::Free().
   char* MakeProfileNameLocked();
 
   // Helper for constructors
   void Create(const char *name, bool make_start_snapshot);
 
   enum ShouldSymbolize { SYMBOLIZE, DO_NOT_SYMBOLIZE };
 
   // Helper for *NoLeaks and *SameHeap
   bool DoNoLeaks(ShouldSymbolize should_symbolize);
 
+  // Helper for NoGlobalLeaks, also called by the global destructor.
+  static bool NoGlobalLeaksMaybeSymbolize(ShouldSymbolize should_symbolize);
+
   // These used to be public, but they are now deprecated.
   // Will remove entirely when all internal uses are fixed.
   // In the meantime, use friendship so the unittest can still test them.
   static void* GetDisableChecksStart();
   static void DisableChecksToHereFrom(const void* start_address);
   static void DisableChecksIn(const char* pattern);
   friend void RangeDisabledLeaks();
   friend void NamedTwoDisabledLeaks();
   friend void* RunNamedDisabledLeaks(void*);
   friend void TestHeapLeakCheckerNamedDisabling();
   friend int main(int, char**);
 
 
-  // Helper for DisableChecksIn
-  static void DisableChecksInLocked(const char* pattern);
+  // Actually implements IgnoreObject().
+  static void DoIgnoreObject(const void* ptr);
 
   // Disable checks based on stack trace entry at a depth <=
   // max_depth.  Used to hide allocations done inside some special
   // libraries.
   static void DisableChecksFromToLocked(const void* start_address,
                                         const void* end_address,
                                         int max_depth);
 
   // Helper for DoNoLeaks to ignore all objects reachable from all live data
   static void IgnoreAllLiveObjectsLocked(const void* self_stack_top);
@@ skipping 24 matching lines @@
 
   // Helper for IgnoreNonThreadLiveObjectsLocked and IgnoreLiveThreadsLocked
   // to discover and ignore all heap objects
   // reachable from currently considered live objects
   // (live_objects static global variable in out .cc file).
   // "name", "name2" are two strings that we print one after another
   // in a debug message to describe what kind of live object sources
   // are being used.
   static void IgnoreLiveObjectsLocked(const char* name, const char* name2);
 
-  // Runs REGISTER_HEAPCHECK_CLEANUP cleanups and potentially
-  // calls DoMainHeapCheck
-  static void RunHeapCleanups();
-
   // Do the overall whole-program heap leak check if needed;
   // returns true when did the leak check.
   static bool DoMainHeapCheck();
 
   // Type of task for UseProcMapsLocked
   enum ProcMapsTask {
     RECORD_GLOBAL_DATA,
     DISABLE_LIBRARY_ALLOCS
   };
 
@@ skipping 38 matching lines @@
   static const void* GetAllocCaller(void* ptr);
   friend void VerifyHeapProfileTableStackGet();
 
   // This gets to execute before constructors for all global objects
   static void BeforeConstructorsLocked();
   friend void HeapLeakChecker_BeforeConstructors();
 
   // This gets to execute after destructors for all global objects
   friend void HeapLeakChecker_AfterDestructors();
 
+  // Full starting of recommended whole-program checking.
+  friend void HeapLeakChecker_InternalInitStart();
+
+  // Runs REGISTER_HEAPCHECK_CLEANUP cleanups and potentially
+  // calls DoMainHeapCheck
+  friend void HeapLeakChecker_RunHeapCleanups();
+
   // ----------------------------------------------------------------------- //
   // Member data.
 
   class SpinLock* lock_;  // to make HeapLeakChecker objects thread-safe
   const char* name_;  // our remembered name (we own it)
                       // NULL means this leak checker is a noop
 
   // Snapshot taken when the checker was created.  May be NULL
   // for the global heap checker object.  We use void* instead of
   // HeapProfileTable::Snapshot* to avoid including heap-profile-table.h.
@@ skipping 48 matching lines @@
 // (they run only if we are doing heap leak checking.)
 // 'body' should be the cleanup code to run.  'name' doesn't matter,
 // but must be unique amongst all REGISTER_HEAPCHECK_CLEANUP calls.
 #define REGISTER_HEAPCHECK_CLEANUP(name, body)  \
   namespace { \
   void heapcheck_cleanup_##name() { body; } \
   static HeapCleaner heapcheck_cleaner_##name(&heapcheck_cleanup_##name); \
   }
 
 #endif  // BASE_HEAP_CHECKER_H_