Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/memory_region_map.h

 /* Copyright (c) 2006, 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 21 matching lines @@
  */
 
 #ifndef BASE_MEMORY_REGION_MAP_H_
 #define BASE_MEMORY_REGION_MAP_H_
 
 #include <config.h>
 
 #ifdef HAVE_PTHREAD
 #include <pthread.h>
 #endif
+#include <stddef.h>
 #include <set>
 #include "base/stl_allocator.h"
 #include "base/spinlock.h"
 #include "base/thread_annotations.h"
 #include "base/low_level_alloc.h"
 
 // TODO(maxim): add a unittest:
 //  execute a bunch of mmaps and compare memory map what strace logs
 //  execute a bunch of mmap/munmup and compare memory map with
 //  own accounting of what those mmaps generated
@@ skipping 39 matching lines @@
   // MemoryRegionMap::Lock()/Unlock() to manage the locks.
   // Uses Lock/Unlock inside.
   static void Init(int max_stack_depth);
 
   // Try to shutdown this module undoing what Init() did.
   // Returns true iff could do full shutdown (or it was not attempted).
   // Full shutdown is attempted when the number of Shutdown() calls equals
   // the number of Init() calls.
   static bool Shutdown();
 
-  // Check that our hooks are still in place and crash if not.
-  // No need for locking.
-  static void CheckMallocHooks();
-
   // Locks to protect our internal data structures.
   // These also protect use of arena_ if our Init() has been done.
   // The lock is recursive.
   static void Lock() EXCLUSIVE_LOCK_FUNCTION(lock_);
   static void Unlock() UNLOCK_FUNCTION(lock_);
 
   // Returns true when the lock is held by this thread (for use in RAW_CHECK-s).
   static bool LockIsHeld();
 
   // Locker object that acquires the MemoryRegionMap::Lock
@@ skipping 109 matching lines @@
     bool operator()(const Region& x, const Region& y) const {
       return x.end_addr < y.end_addr;
     }
   };
 
   // We allocate STL objects in our own arena.
   struct MyAllocator {
     static void *Allocate(size_t n) {
       return LowLevelAlloc::AllocWithArena(n, arena_);
     }
-    static void Free(const void *p) {
+    static void Free(const void *p, size_t /* n */) {
       LowLevelAlloc::Free(const_cast<void*>(p));
     }
   };
 
   // Set of the memory regions
   typedef std::set<Region, RegionCmp,
               STL_Allocator<Region, MyAllocator> > RegionSet;
 
  public:  // more in-depth interface ==========================================
 
   // STL iterator with values of Region
   typedef RegionSet::const_iterator RegionIterator;
 
   // Return the begin/end iterators to all the regions.
   // These need Lock/Unlock protection around their whole usage (loop).
   // Even when the same thread causes modifications during such a loop
   // (which are permitted due to recursive locking)
   // the loop iterator will still be valid as long as its region
   // has not been deleted, but EndRegionLocked should be
   // re-evaluated whenever the set of regions has changed.
   static RegionIterator BeginRegionLocked();
   static RegionIterator EndRegionLocked();
 
   // Effectively private type from our .cc =================================
   // public to let us declare global objects:
   union RegionSetRep;
 
  private:
-
   // representation ===========================================================
 
   // Counter of clients of this module that have called Init().
   static int client_count_;
 
   // Maximal number of caller stack frames to save (>= 0).
   static int max_stack_depth_;
 
   // Arena used for our allocations in regions_.
   static LowLevelAlloc::Arena* arena_;
@@ skipping 52 matching lines @@
   static void SbrkHook(const void* result, std::ptrdiff_t increment);
 
   // Log all memory regions; Useful for debugging only.
   // Assumes Lock() is held
   static void LogAllLocked();
 
   DISALLOW_COPY_AND_ASSIGN(MemoryRegionMap);
 };
 
 #endif  // BASE_MEMORY_REGION_MAP_H_