Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/tests/heap-checker_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 83 matching lines @@
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/commandlineflags.h"
 #include "base/googleinit.h"
 #include "base/logging.h"
 #include "base/commandlineflags.h"
 #include "base/thread_lister.h"
-#include <google/heap-checker.h>
+#include <gperftools/heap-checker.h>
 #include "memory_region_map.h"
-#include <google/malloc_extension.h>
-#include <google/stacktrace.h>
+#include <gperftools/malloc_extension.h>
+#include <gperftools/stacktrace.h>
 
 // On systems (like freebsd) that don't define MAP_ANONYMOUS, use the old
 // form of the name instead.
 #ifndef MAP_ANONYMOUS
 # define MAP_ANONYMOUS MAP_ANON
 #endif
 
 using namespace std;
 
 // ========================================================================= //
@@ skipping 1256 matching lines @@
 
   LOGF << "In main(): heap_check=" << FLAGS_heap_check << endl;
 
   CHECK(HeapLeakChecker::NoGlobalLeaks());  // so far, so good
 
   if (FLAGS_test_leak) {
     void* arr;
     RunHidden(NewCallback(MakeALeak, &arr));
     Use(&arr);
     LogHidden("Leaking", arr);
-    if (FLAGS_test_cancel_global_check)  HeapLeakChecker::CancelGlobalCheck();
+    if (FLAGS_test_cancel_global_check) {
+      HeapLeakChecker::CancelGlobalCheck();
+    } else {
+      // Verify we can call NoGlobalLeaks repeatedly without deadlocking
+      HeapLeakChecker::NoGlobalLeaks();
+      HeapLeakChecker::NoGlobalLeaks();
+    }
     return Pass();
       // whole-program leak-check should (with very high probability)
       // catch the leak of arr (10 * sizeof(int) bytes)
       // (when !FLAGS_test_cancel_global_check)
   }
 
   if (FLAGS_test_loop_leak) {
     void* arr1;
     void* arr2;
     RunHidden(NewCallback(MakeDeathLoop, &arr1, &arr2));
     Use(&arr1);
     Use(&arr2);
     LogHidden("Loop leaking", arr1);
     LogHidden("Loop leaking", arr2);
-    if (FLAGS_test_cancel_global_check)  HeapLeakChecker::CancelGlobalCheck();
+    if (FLAGS_test_cancel_global_check) {
+      HeapLeakChecker::CancelGlobalCheck();
+    } else {
+      // Verify we can call NoGlobalLeaks repeatedly without deadlocking
+      HeapLeakChecker::NoGlobalLeaks();
+      HeapLeakChecker::NoGlobalLeaks();
+    }
     return Pass();
       // whole-program leak-check should (with very high probability)
       // catch the leak of arr1 and arr2 (4 * sizeof(void*) bytes)
       // (when !FLAGS_test_cancel_global_check)
   }
 
   if (FLAGS_test_register_leak) {
     // make us fail only where the .sh test expects:
     Pause();
     for (int i = 0; i < 100; ++i) {  // give it some time to crash
@@ skipping 72 matching lines @@
     CHECK(heap_check.SameHeap());
   } else {
     WARN_IF(heap_check.SameHeap() != true,
             "overall leaks are caught; we must be using a stripped binary");
   }
 
   CHECK(HeapLeakChecker::NoGlobalLeaks());  // so far, so good
 
   return Pass();
 }