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

third_party/tcmalloc/vendor/src/tests/tcmalloc_unittest.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 70 matching lines @@
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>        // defines pvalloc/etc on cygwin
 #endif
 #include <assert.h>
 #include <vector>
 #include <algorithm>
 #include <string>
 #include <new>
 #include "base/logging.h"
 #include "base/simple_mutex.h"
-#include "google/malloc_hook.h"
-#include "google/malloc_extension.h"
-#include "google/tcmalloc.h"
+#include "gperftools/malloc_hook.h"
+#include "gperftools/malloc_extension.h"
+#include "gperftools/tcmalloc.h"
 #include "thread_cache.h"
 #include "tests/testutil.h"
 
 // Windows doesn't define pvalloc and a few other obsolete unix
 // functions; nor does it define posix_memalign (which is not obsolete).
 #if defined(_WIN32)
 # define cfree free         // don't bother to try to test these obsolete fns
 # define valloc malloc
 # define pvalloc malloc
 // I'd like to map posix_memalign to _aligned_malloc, but _aligned_malloc
 // must be paired with _aligned_free (not normal free), which is too
 // invasive a change to how we allocate memory here.  So just bail
 static bool kOSSupportsMemalign = false;
 static inline void* Memalign(size_t align, size_t size) {
   //LOG(FATAL) << "memalign not supported on windows";
   exit(1);
+  return NULL;
 }
 static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
   //LOG(FATAL) << "posix_memalign not supported on windows";
   exit(1);
+  return -1;
 }
 
 // OS X defines posix_memalign in some OS versions but not others;
 // it's confusing enough to check that it's easiest to just not to test.
 #elif defined(__APPLE__)
 static bool kOSSupportsMemalign = false;
 static inline void* Memalign(size_t align, size_t size) {
   //LOG(FATAL) << "memalign not supported on OS X";
   exit(1);
+  return NULL;
 }
 static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
   //LOG(FATAL) << "posix_memalign not supported on OS X";
   exit(1);
+  return -1;
 }
 
 #else
 static bool kOSSupportsMemalign = true;
 static inline void* Memalign(size_t align, size_t size) {
   return memalign(align, size);
 }
 static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
   return posix_memalign(ptr, align, size);
 }
@@ skipping 939 matching lines @@
       p1 = Memalign(sizeof(p1) * 2, 50);
       CHECK(p1 != NULL);
       VerifyNewHookWasCalled();
       free(p1);
       VerifyDeleteHookWasCalled();
     }
 
     // Windows has _aligned_malloc.  Let's test that that's captured too.
 #if (defined(_MSC_VER) || defined(__MINGW32__)) && !defined(PERFTOOLS_NO_ALIGNED_MALLOC)
     p1 = _aligned_malloc(sizeof(p1) * 2, 64);
+    CHECK(p1 != NULL);
     VerifyNewHookWasCalled();
     _aligned_free(p1);
     VerifyDeleteHookWasCalled();
 #endif
 
     p1 = valloc(60);
     CHECK(p1 != NULL);
     VerifyNewHookWasCalled();
     free(p1);
     VerifyDeleteHookWasCalled();
@@ skipping 217 matching lines @@
   int minor;
   const char* patch;
   char mmp[64];
   const char* human_version = tc_version(&major, &minor, &patch);
   snprintf(mmp, sizeof(mmp), "%d.%d%s", major, minor, patch);
   CHECK(!strcmp(PACKAGE_STRING, human_version));
   CHECK(!strcmp(PACKAGE_VERSION, mmp));
 
   fprintf(LOGSTREAM, "PASS\n");
 }