Update the tcmalloc chromium branch to r144 (gperftools 2.0), and merge chromium-specific changes.

third_party/tcmalloc/chromium/src/gperftools/malloc_extension.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 63 matching lines @@
 class SysAllocator {
  public:
   SysAllocator() {
   }
   virtual ~SysAllocator();
 
   // Allocates "size"-byte of memory from system aligned with "alignment".
   // Returns NULL if failed. Otherwise, the returned pointer p up to and
   // including (p + actual_size -1) have been allocated.
   virtual void* Alloc(size_t size, size_t *actual_size, size_t alignment) = 0;
-
-  // Notification that command-line flags have been initialized.
-  virtual void FlagsInitialized() = 0;
 };
 
 // The default implementations of the following routines do nothing.
 // All implementations should be thread-safe; the current one
 // (TCMallocImplementation) is.
 class PERFTOOLS_DLL_DECL MallocExtension {
  public:
   virtual ~MallocExtension();
 
   // Call this very early in the program execution -- say, in a global
   // constructor -- to set up parameters and state needed by all
   // instrumented malloc implemenatations.  One example: this routine
   // sets environemnt variables to tell STL to use libc's malloc()
   // instead of doing its own memory management.  This is safe to call
   // multiple times, as long as each time is before threads start up.
   static void Initialize();
 
   // See "verify_memory.h" to see what these routines do
   virtual bool VerifyAllMemory();
-  virtual bool VerifyNewMemory(void* p);
-  virtual bool VerifyArrayNewMemory(void* p);
-  virtual bool VerifyMallocMemory(void* p);
+  virtual bool VerifyNewMemory(const void* p);
+  virtual bool VerifyArrayNewMemory(const void* p);
+  virtual bool VerifyMallocMemory(const void* p);
   virtual bool MallocMemoryStats(int* blocks, size_t* total,
                                  int histogram[kMallocHistogramSize]);
 
   // Get a human readable description of the current state of the malloc
   // data structures.  The state is stored as a null-terminated string
   // in a prefix of "buffer[0,buffer_length-1]".
   // REQUIRES: buffer_length > 0.
   virtual void GetStats(char* buffer, int buffer_length);
 
   // Outputs to "writer" a sample of live objects and the stack traces
@@ skipping 157 matching lines @@
   // allocation).  This number may be equal to or greater than the number
   // of bytes requested when p was allocated.
   // p must have been allocated by this malloc implementation,
   // must not be an interior pointer -- that is, must be exactly
   // the pointer returned to by malloc() et al., not some offset
   // from that -- and should not have been freed yet.  p may be NULL.
   // (Currently only implemented in tcmalloc; other implementations
   // will return 0.)
   // This is equivalent to malloc_size() in OS X, malloc_usable_size()
   // in glibc, and _msize() for windows.
-  virtual size_t GetAllocatedSize(void* p);
+  virtual size_t GetAllocatedSize(const void* p);
+
+  // Returns kOwned if this malloc implementation allocated the memory
+  // pointed to by p, or kNotOwned if some other malloc implementation
+  // allocated it or p is NULL.  May also return kUnknownOwnership if
+  // the malloc implementation does not keep track of ownership.
+  // REQUIRES: p must be a value returned from a previous call to
+  // malloc(), calloc(), realloc(), memalign(), posix_memalign(),
+  // valloc(), pvalloc(), new, or new[], and must refer to memory that
+  // is currently allocated (so, for instance, you should not pass in
+  // a pointer after having called free() on it).
+  enum Ownership {
+    // NOTE: Enum values MUST be kept in sync with the version in
+    // malloc_extension_c.h
+    kUnknownOwnership = 0,
+    kOwned,
+    kNotOwned
+  };
+  virtual Ownership GetOwnership(const void* p);
 
   // The current malloc implementation.  Always non-NULL.
   static MallocExtension* instance();
 
   // Change the malloc implementation.  Typically called by the
   // malloc implementation during initialization.
   static void Register(MallocExtension* implementation);
 
   // Returns detailed information about malloc's freelists. For each list,
   // return a FreeListInfo:
@@ skipping 79 matching lines @@
 
   // Perhaps add the following:
   // - stack trace if this range was sampled
   // - heap growth stack trace if applicable to this range
   // - age when allocated (for inuse) or freed (if not in use)
 };
 
 } // namespace base
 
 #endif  // BASE_MALLOC_EXTENSION_H_