Update the tcmalloc vendor branch to r144 (gperftools 2.0).

third_party/tcmalloc/vendor/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 82 matching lines @@
   // 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();
-  // TODO(csilvers): change these to const void*.
-  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.
-  // TODO(csilvers): change to const void*.
-  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).
@@ skipping 97 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_