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

third_party/tcmalloc/vendor/src/malloc_extension.cc

 // 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 27 matching lines @@
 #include <stdint.h>
 #elif defined HAVE_INTTYPES_H
 #include <inttypes.h>
 #else
 #include <sys/types.h>
 #endif
 #include <string>
 #include "base/dynamic_annotations.h"
 #include "base/sysinfo.h"    // for FillProcSelfMaps
 #ifndef NO_HEAP_CHECK
-#include "google/heap-checker.h"
+#include "gperftools/heap-checker.h"
 #endif
-#include "google/malloc_extension.h"
-#include "google/malloc_extension_c.h"
+#include "gperftools/malloc_extension.h"
+#include "gperftools/malloc_extension_c.h"
 #include "maybe_threads.h"
 
 using STL_NAMESPACE::string;
 using STL_NAMESPACE::vector;
 
 static void DumpAddressMap(string* result) {
   *result += "\nMAPPED_LIBRARIES:\n";
   // We keep doubling until we get a fit
   const size_t old_resultlen = result->size();
   for (int amap_size = 10240; amap_size < 10000000; amap_size *= 2) {
@@ skipping 39 matching lines @@
   dummy += "!";         // so the definition of dummy isn't optimized out
 #endif  /* __GLIBC__ */
 }
 
 // SysAllocator implementation
 SysAllocator::~SysAllocator() {}
 
 // Default implementation -- does nothing
 MallocExtension::~MallocExtension() { }
 bool MallocExtension::VerifyAllMemory() { return true; }
-bool MallocExtension::VerifyNewMemory(void* p) { return true; }
-bool MallocExtension::VerifyArrayNewMemory(void* p) { return true; }
-bool MallocExtension::VerifyMallocMemory(void* p) { return true; }
+bool MallocExtension::VerifyNewMemory(const void* p) { return true; }
+bool MallocExtension::VerifyArrayNewMemory(const void* p) { return true; }
+bool MallocExtension::VerifyMallocMemory(const void* p) { return true; }
 
 bool MallocExtension::GetNumericProperty(const char* property, size_t* value) {
   return false;
 }
 
 bool MallocExtension::SetNumericProperty(const char* property, size_t value) {
   return false;
 }
 
 void MallocExtension::GetStats(char* buffer, int length) {
@@ skipping 46 matching lines @@
 }
 
 double MallocExtension::GetMemoryReleaseRate() {
   return -1.0;
 }
 
 size_t MallocExtension::GetEstimatedAllocatedSize(size_t size) {
   return size;
 }
 
-size_t MallocExtension::GetAllocatedSize(void* p) {
+size_t MallocExtension::GetAllocatedSize(const void* p) {
   assert(GetOwnership(p) != kNotOwned);
   return 0;
 }
 
 MallocExtension::Ownership MallocExtension::GetOwnership(const void* p) {
   return kUnknownOwnership;
 }
 
 void MallocExtension::GetFreeListSizes(
     vector<MallocExtension::FreeListInfo>* v) {
@@ skipping 145 matching lines @@
 }
 
 // These are C shims that work on the current instance.
 
 #define C_SHIM(fn, retval, paramlist, arglist)          \
   extern "C" PERFTOOLS_DLL_DECL retval MallocExtension_##fn paramlist {    \
     return MallocExtension::instance()->fn arglist;     \
   }
 
 C_SHIM(VerifyAllMemory, int, (void), ());
-C_SHIM(VerifyNewMemory, int, (void* p), (p));
-C_SHIM(VerifyArrayNewMemory, int, (void* p), (p));
-C_SHIM(VerifyMallocMemory, int, (void* p), (p));
+C_SHIM(VerifyNewMemory, int, (const void* p), (p));
+C_SHIM(VerifyArrayNewMemory, int, (const void* p), (p));
+C_SHIM(VerifyMallocMemory, int, (const void* p), (p));
 C_SHIM(MallocMemoryStats, int,
        (int* blocks, size_t* total, int histogram[kMallocHistogramSize]),
        (blocks, total, histogram));
 
 C_SHIM(GetStats, void,
        (char* buffer, int buffer_length), (buffer, buffer_length));
 C_SHIM(GetNumericProperty, int,
        (const char* property, size_t* value), (property, value));
 C_SHIM(SetNumericProperty, int,
        (const char* property, size_t value), (property, value));
 
 C_SHIM(MarkThreadIdle, void, (void), ());
 C_SHIM(MarkThreadBusy, void, (void), ());
 C_SHIM(ReleaseFreeMemory, void, (void), ());
 C_SHIM(ReleaseToSystem, void, (size_t num_bytes), (num_bytes));
 C_SHIM(GetEstimatedAllocatedSize, size_t, (size_t size), (size));
-C_SHIM(GetAllocatedSize, size_t, (void* p), (p));
+C_SHIM(GetAllocatedSize, size_t, (const void* p), (p));
 
 // Can't use the shim here because of the need to translate the enums.
 extern "C"
 MallocExtension_Ownership MallocExtension_GetOwnership(const void* p) {
   return static_cast<MallocExtension_Ownership>(
       MallocExtension::instance()->GetOwnership(p));
 }