add a macro that really identifies glibc

base/process_util_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process_util.h"
 
 #include <dirent.h>
 #include <malloc.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ skipping 727 matching lines @@
     LOG(FATAL) << "Out of memory, size = " << size;
   LOG(FATAL) << "Out of memory.";
 }
 
 void OnNoMemory() {
   OnNoMemorySize(0);
 }
 
 }  // namespace
 
-#if !defined(OS_ANDROID) && !defined(USE_TCMALLOC) && \
+#if defined(GLIBC) && !defined(USE_TCMALLOC) && \

[agl, 2013/05/20 15:18:22]

It's not clear that we don't actually want this malloc behaviour on Android. It
may have been an expedient choice during porting that hasn't been fixed.

It's doubly not clear that we don't want this malloc behaviour for uClibc in
general. We might need to do a dlsym dance to get the original pointers, but
that's very different than just disabling it. 

[Mostyn Bramley-Moore, 2013/05/20 20:41:41]

I downloaded android-ndk-r8e and inspected
platforms/android-14/arch-arm/usr/lib/libc.so - it does not have any of the
__libc_* symbols used below.  Similarly for the x86 version, and also with
uClibc.  So it seems safe to say that this code will only work with glibc,
though I don't have definitive documentation of this.  
You're probably right, but I think this might be better implemented in a
followup task.  Would you settle for a TODO note inside some rearranged ifdefs?
ie something like:

#if !defined(ADDRESS_SANITIZER) && !defined(MEMORY_SANITIZER) &&
!defined(THREAD_SANITIZER)

#if defined(GLIBC) && !defined(USE_TCMALLOC)
... make use of __libc_* ...
#else
// TODO: dylsym dance
#endif

#endif

     !defined(ADDRESS_SANITIZER) && !defined(MEMORY_SANITIZER) && \
     !defined(THREAD_SANITIZER)
 
 extern "C" {
 void* __libc_malloc(size_t size);
 void* __libc_realloc(void* ptr, size_t size);
 void* __libc_calloc(size_t nmemb, size_t size);
 void* __libc_valloc(size_t size);
 void* __libc_pvalloc(size_t size);
 void* __libc_memalign(size_t alignment, size_t size);
@@ skipping 60 matching lines @@
 int posix_memalign(void** ptr, size_t alignment, size_t size)
     __attribute__ ((visibility("default")));
 
 int posix_memalign(void** ptr, size_t alignment, size_t size) {
   // This will use the safe version of memalign, above.
   *ptr = memalign(alignment, size);
   return 0;
 }
 
 }  // extern C
-#endif  // ANDROID, TCMALLOC, *_SANITIZER
+#endif  // GLIBC, !TCMALLOC, !*_SANITIZER
 
 void EnableTerminationOnHeapCorruption() {
   // On Linux, there nothing to do AFAIK.
 }
 
 void EnableTerminationOnOutOfMemory() {
 #if defined(OS_ANDROID)
   // Android doesn't support setting a new handler.
   DLOG(WARNING) << "Not feasible.";
 #else
@@ skipping 39 matching lines @@
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   return false;
 }
 
 }  // namespace base