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

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

 // Copyright (c) 2011, 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 18 matching lines @@
 
 // ----
 // Author: llib@google.com (Bill Clarke)
 
 #include "config_for_unittests.h"
 #include <assert.h>
 #include <stdio.h>
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 #endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>    // for sleep()
+#endif
 #include <algorithm>
 #include <string>
 #include <vector>
-#include <google/malloc_hook.h>
+#include <gperftools/malloc_hook.h>
 #include "malloc_hook-inl.h"
 #include "base/logging.h"
-#include "base/spinlock.h"
+#include "base/simple_mutex.h"
 #include "base/sysinfo.h"
 #include "tests/testutil.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
+
 namespace {
 
 using std::string;
 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();                                  \
   };                                                    \
   static Test_##a##_##b g_test_##a##_##b;               \
   void Test_##a##_##b::Run()
 
 
 static int RUN_ALL_TESTS() {
   vector<void (*)()>::const_iterator it;
   for (it = g_testlist.begin(); it != g_testlist.end(); ++it) {
     (*it)();   // The test will error-exit if there's a problem.
   }
   fprintf(stderr, "\nPassed %d tests\n\nPASS\n",
           static_cast<int>(g_testlist.size()));
   return 0;
 }
 
+void Sleep(int seconds) {
+#ifdef _MSC_VER
+  _sleep(seconds * 1000);   // Windows's _sleep takes milliseconds argument
+#else
+  sleep(seconds);
+#endif
+}
+
+using std::min;
 using base::internal::kHookListMaxValues;
 
 // Since HookList is a template and is defined in malloc_hook.cc, we can only
 // use an instantiation of it from malloc_hook.cc.  We then reinterpret those
 // values as integers for testing.
 typedef base::internal::HookList<MallocHook::NewHook> TestHookList;
 
 int TestHookList_Traverse(const TestHookList& list, int* output_array, int n) {
   MallocHook::NewHook values_as_hooks[kHookListMaxValues];
-  int result = list.Traverse(values_as_hooks, std::min(n, kHookListMaxValues));
+  int result = list.Traverse(values_as_hooks, min(n, kHookListMaxValues));
   for (int i = 0; i < result; ++i) {
     output_array[i] = reinterpret_cast<const int&>(values_as_hooks[i]);
   }
   return result;
 }
 
 bool TestHookList_Add(TestHookList* list, int val) {
   return list->Add(reinterpret_cast<MallocHook::NewHook>(val));
 }
 
@@ skipping 127 matching lines @@
     EXPECT_EQ(value_index, num_values);  // Should not have found value.
     snprintf(buf, sizeof(buf), "%d]", num_values);
     message += buf;
     sched_yield();
   }
   fprintf(stderr, "thread %d: %s\n", thread_num, message.c_str());
 }
 
 static volatile int num_threads_remaining;
 static TestHookList list = INIT_HOOK_LIST(69);
-static SpinLock threadcount_lock;
+static Mutex threadcount_lock;
 
 void MultithreadedTestThreadRunner(int thread_num) {
   // Wait for all threads to start running.
   {
-    SpinLockHolder h(&threadcount_lock);
+    MutexLock ml(&threadcount_lock);
     assert(num_threads_remaining > 0);
     --num_threads_remaining;
 
     // We should use condvars and the like, but for this test, we'll
     // go simple and busy-wait.
     while (num_threads_remaining > 0) {
       threadcount_lock.Unlock();
-      SleepForMilliseconds(100);
+      Sleep(1);
       threadcount_lock.Lock();
     }
   }
 
   // shift is the smallest number such that (1<<shift) > kHookListMaxValues
   int shift = 0;
   for (int i = kHookListMaxValues; i > 0; i >>= 1)
     shift += 1;
 
   MultithreadedTestThread(&list, shift, thread_num);
 }
 
 
 TEST(HookListTest, MultithreadedTest) {
   ASSERT_TRUE(TestHookList_Remove(&list, 69));
   ASSERT_EQ(0, list.priv_end);
 
   // Run kHookListMaxValues thread, each running MultithreadedTestThread.
   // First, we need to set up the rest of the globals.
   num_threads_remaining = kHookListMaxValues;   // a global var
   RunManyThreadsWithId(&MultithreadedTestThreadRunner, num_threads_remaining,
                        1 << 15);
 
   int values[kHookListMaxValues + 1];
   EXPECT_EQ(0, TestHookList_Traverse(list, values, kHookListMaxValues));
   EXPECT_EQ(0, list.priv_end);
 }
 
-#ifdef HAVE_MMAP
+// We only do mmap-hooking on (some) linux systems.
+#if defined(HAVE_MMAP) && defined(__linux) && \
+    (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))
+
 int mmap_calls = 0;
 int mmap_matching_calls = 0;
 int munmap_calls = 0;
 int munmap_matching_calls = 0;
 const int kMmapMagicFd = 1;
 void* const kMmapMagicPointer = reinterpret_cast<void*>(1);
 
 int MmapReplacement(const void* start,
                      size_t size,
                      int protection,
@@ skipping 44 matching lines @@
   EXPECT_EQ(2, munmap_calls);
   EXPECT_EQ(1, munmap_matching_calls);
 
   // The DEATH test below is flaky, because we've just munmapped the memory,
   // making it available for mmap()ing again. There is no guarantee that it
   // will stay unmapped, and in fact it gets reused ~10% of the time.
   // It the area is reused, then not only we don't die, but we also corrupt
   // whoever owns that memory now.
   // EXPECT_DEATH(*ptr = 'a', "SIGSEGV");
 }
-#endif  // #ifdef HAVE_MMAN
+#endif  // #ifdef HAVE_MMAP && linux && ...
 
 }  // namespace
 
 int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }