Add a chromium version abort function for tcmalloc: Abort().

third_party/tcmalloc/chromium/src/base/simple_mutex.h

 // 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 120 matching lines @@
 # include <pthread.h>
   typedef pthread_rwlock_t MutexType;
 #elif defined(HAVE_PTHREAD)
 # include <pthread.h>
   typedef pthread_mutex_t MutexType;
 #else
 # error Need to implement mutex.h for your architecture, or #define NO_THREADS
 #endif
 
 #include <assert.h>
-#include <stdlib.h>      // for abort()
+#include "base/abort.h"
 
 #define MUTEX_NAMESPACE perftools_mutex_namespace
 
 namespace MUTEX_NAMESPACE {
 
 class Mutex {
  public:
   // This is used for the single-arg constructor
   enum LinkerInitialized { LINKER_INITIALIZED };
 
@@ skipping 75 matching lines @@
 void Mutex::Lock()         { if (is_safe_) EnterCriticalSection(&mutex_); }
 void Mutex::Unlock()       { if (is_safe_) LeaveCriticalSection(&mutex_); }
 bool Mutex::TryLock()      { return is_safe_ ?
                                  TryEnterCriticalSection(&mutex_) != 0 : true; }
 void Mutex::ReaderLock()   { Lock(); }      // we don't have read-write locks
 void Mutex::ReaderUnlock() { Unlock(); }
 
 #elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
 
 #define SAFE_PTHREAD(fncall)  do {   /* run fncall if is_safe_ is true */  \
-  if (is_safe_ && fncall(&mutex_) != 0) abort();                           \
+  if (is_safe_ && fncall(&mutex_) != 0) tcmalloc::Abort();                 \
 } while (0)
 
 Mutex::Mutex() : destroy_(true) {
   SetIsSafe();
-  if (is_safe_ && pthread_rwlock_init(&mutex_, NULL) != 0) abort();
+  if (is_safe_ && pthread_rwlock_init(&mutex_, NULL) != 0) tcmalloc::Abort();
 }
 Mutex::Mutex(Mutex::LinkerInitialized) : destroy_(false) {
   SetIsSafe();
-  if (is_safe_ && pthread_rwlock_init(&mutex_, NULL) != 0) abort();
+  if (is_safe_ && pthread_rwlock_init(&mutex_, NULL) != 0) tcmalloc::Abort();
 }
 Mutex::~Mutex()       { if (destroy_) SAFE_PTHREAD(pthread_rwlock_destroy); }
 void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock); }
 void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock); }
 bool Mutex::TryLock()      { return is_safe_ ?
                                pthread_rwlock_trywrlock(&mutex_) == 0 : true; }
 void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock); }
 void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock); }
 #undef SAFE_PTHREAD
 
 #elif defined(HAVE_PTHREAD)
 
 #define SAFE_PTHREAD(fncall)  do {   /* run fncall if is_safe_ is true */  \
-  if (is_safe_ && fncall(&mutex_) != 0) abort();                           \
+  if (is_safe_ && fncall(&mutex_) != 0) tcmalloc::Abort();                 \
 } while (0)
 
 Mutex::Mutex() : destroy_(true) {
   SetIsSafe();
-  if (is_safe_ && pthread_mutex_init(&mutex_, NULL) != 0) abort();
+  if (is_safe_ && pthread_mutex_init(&mutex_, NULL) != 0) tcmalloc::Abort();
 }
 Mutex::Mutex(Mutex::LinkerInitialized) : destroy_(false) {
   SetIsSafe();
-  if (is_safe_ && pthread_mutex_init(&mutex_, NULL) != 0) abort();
+  if (is_safe_ && pthread_mutex_init(&mutex_, NULL) != 0) tcmalloc::Abort();
 }
 Mutex::~Mutex()       { if (destroy_) SAFE_PTHREAD(pthread_mutex_destroy); }
 void Mutex::Lock()         { SAFE_PTHREAD(pthread_mutex_lock); }
 void Mutex::Unlock()       { SAFE_PTHREAD(pthread_mutex_unlock); }
 bool Mutex::TryLock()      { return is_safe_ ?
                                  pthread_mutex_trylock(&mutex_) == 0 : true; }
 void Mutex::ReaderLock()   { Lock(); }
 void Mutex::ReaderUnlock() { Unlock(); }
 #undef SAFE_PTHREAD
 
@@ skipping 42 matching lines @@
 #define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name)
 #define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name)
 
 }  // namespace MUTEX_NAMESPACE
 
 using namespace MUTEX_NAMESPACE;
 
 #undef MUTEX_NAMESPACE
 
 #endif  /* #define GOOGLE_SIMPLE_MUTEX_H_ */