Update the tcmalloc vendor branch to r144 (gperftools 2.0), and README.chromium.

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 46 matching lines @@
   // tcmalloc
   // --------
   // "tcmalloc.max_total_thread_cache_bytes"
   //      Upper limit on total number of bytes stored across all
   //      per-thread caches.  Default: 16MB.
   //
   // "tcmalloc.current_total_thread_cache_bytes"
   //      Number of bytes used across all thread caches.
   //      This property is not writable.
   //
+  // "tcmalloc.central_cache_free_bytes"
+  //      Number of free bytes in the central cache that have been
+  //      assigned to size classes. They always count towards virtual
+  //      memory usage, and unless the underlying memory is swapped out
+  //      by the OS, they also count towards physical memory usage.
+  //      This property is not writable.
+  //
+  // "tcmalloc.transfer_cache_free_bytes"
+  //      Number of free bytes that are waiting to be transfered between
+  //      the central cache and a thread cache. They always count
+  //      towards virtual memory usage, and unless the underlying memory
+  //      is swapped out by the OS, they also count towards physical
+  //      memory usage. This property is not writable.
+  //
+  // "tcmalloc.thread_cache_free_bytes"
+  //      Number of free bytes in thread caches. They always count
+  //      towards virtual memory usage, and unless the underlying memory
+  //      is swapped out by the OS, they also count towards physical
+  //      memory usage. This property is not writable.
+  //
   // "tcmalloc.pageheap_free_bytes"
   //      Number of bytes in free, mapped pages in page heap.  These
   //      bytes can be used to fulfill allocation requests.  They
   //      always count towards virtual memory usage, and unless the
   //      underlying memory is swapped out by the OS, they also count
   //      towards physical memory usage.  This property is not writable.
   //
   // "tcmalloc.pageheap_unmapped_bytes"
   //        Number of bytes in free, unmapped pages in page heap.
   //        These are bytes that have been released back to the OS,
@@ skipping 91 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_