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

third_party/tcmalloc/chromium/src/tests/debugallocation_test.cc

 // Copyright (c) 2007, 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 15 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
 // Author: Fred Akalin
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <vector>
-#include "google/malloc_extension.h"
+#include "gperftools/malloc_extension.h"
 #include "base/logging.h"
 
 using std::vector;
 
 vector<void (*)()> g_testlist;  // the tests to run
 
 #define TEST(a, b)                                      \
   struct Test_##a##_##b {                               \
     Test_##a##_##b() { g_testlist.push_back(&Run); }    \
     static void Run();                                  \
@@ skipping 21 matching lines @@
 #define IF_DEBUG_EXPECT_DEATH(statement, regex) do {    \
   if (test_counter++ == test_to_run) {                  \
     fprintf(stderr, "Expected regex:%s\n", regex);      \
     statement;                                          \
   }                                                     \
 } while (false)
 
 // This flag won't be compiled in in opt mode.
 DECLARE_int32(max_free_queue_size);
 
-// Test match as well as mismatch rules:
+// Test match as well as mismatch rules.  But do not test on OS X; on
+// OS X the OS converts new/new[] to malloc before it gets to us, so
+// we are unable to catch these mismatch errors.
+#ifndef __APPLE__
 TEST(DebugAllocationTest, DeallocMismatch) {
   // malloc can be matched only by free
   // new can be matched only by delete and delete(nothrow)
   // new[] can be matched only by delete[] and delete[](nothrow)
   // new(nothrow) can be matched only by delete and delete(nothrow)
   // new(nothrow)[] can be matched only by delete[] and delete[](nothrow)
 
   // Allocate with malloc.
   {
     int* x = static_cast<int*>(malloc(sizeof(*x)));
@@ skipping 36 matching lines @@
   // Allocate with new(nothrow)[].
   {
     int* x = new(std::nothrow) int[1];
     int* y = new(std::nothrow) int[1];
     IF_DEBUG_EXPECT_DEATH(free(x), "mismatch.*being dealloc.*free");
     IF_DEBUG_EXPECT_DEATH(delete x, "mismatch.*being dealloc.*delete");
     delete [] x;
     ::operator delete[](y, std::nothrow);
   }
 }
+#endif  // #ifdef OS_MACOSX
 
 TEST(DebugAllocationTest, DoubleFree) {
   int* pint = new int;
   delete pint;
   IF_DEBUG_EXPECT_DEATH(delete pint, "has been already deallocated");
 }
 
 TEST(DebugAllocationTest, StompBefore) {
   int* pint = new int;
 #ifndef NDEBUG   // don't stomp memory if we're not in a position to detect it
@@ skipping 155 matching lines @@
   // death tests, we will run only the non-death parts.  One way to
   // tell when you are done with all tests is when no 'expected
   // regexp' message is printed for a given argv[1].
   if (argc < 2) {
     test_to_run = -1;   // will never match
   } else {
     test_to_run = atoi(argv[1]);
   }
   return RUN_ALL_TESTS();
 }