Enable tcmalloc's logging in Android.

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

 // 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 38 matching lines @@
 #include "base/commandlineflags.h"
 
 // On some systems (like freebsd), we can't call write() at all in a
 // global constructor, perhaps because errno hasn't been set up.
 // (In windows, we can't call it because it might call malloc.)
 // Calling the write syscall is safer (it doesn't set errno), so we
 // prefer that.  Note we don't care about errno for logging: we just
 // do logging on a best-effort basis.
 #if defined(_MSC_VER)
 #define WRITE_TO_STDERR(buf, len) WriteToStderr(buf, len);  // in port.cc
+#elif defined(__ANDROID__) || defined(ANDROID)
+#include <android/log.h>
+#define WRITE_TO_STDERR(buf, len) \
+    __android_log_write(ANDROID_LOG_ERROR, "gperftools", buf)
 #elif defined(HAVE_SYS_SYSCALL_H)
 #include <sys/syscall.h>
 #define WRITE_TO_STDERR(buf, len) syscall(SYS_write, STDERR_FILENO, buf, len)
 #else
 #define WRITE_TO_STDERR(buf, len) write(STDERR_FILENO, buf, len)
 #endif
 
 // MSVC and mingw define their own, safe version of vnsprintf (the
 // windows one in broken) in port.cc.  Everyone else can use the
 // version here.  We had to give it a unique name for windows.
@@ skipping 128 matching lines @@
 // NOTE: we add a newline to the end of the output if it's not there already
 inline void LogPrintf(int severity, const char* pat, va_list ap) {
   // We write directly to the stderr file descriptor and avoid FILE
   // buffering because that may invoke malloc()
   char buf[1600];
   perftools_vsnprintf(buf, sizeof(buf)-1, pat, ap);
   if (buf[0] != '\0' && buf[strlen(buf)-1] != '\n') {
     assert(strlen(buf)+1 < sizeof(buf));
     strcat(buf, "\n");
   }
+#if defined(__ANDROID__) || defined(ANDROID)
+  android_LogPriority priority = ANDROID_LOG_UNKNOWN;
+  switch (severity) {
+    case INFO: {
+      priority = ANDROID_LOG_INFO;
+      break;
+    }
+    case WARNING: {
+      priority = ANDROID_LOG_WARN;
+      break;
+    }
+    case ERROR: {
+      priority = ANDROID_LOG_ERROR;
+      break;
+    }
+    case FATAL: {
+      priority = ANDROID_LOG_FATAL;
+      break;
+    }
+  }
+  __android_log_write(priority, "gperftools", buf);
+#else  // defined(__ANDROID__) || defined(ANDROID)
   WRITE_TO_STDERR(buf, strlen(buf));
+#endif  // defined(__ANDROID__) || defined(ANDROID)
   if ((severity) == FATAL) {
     // LOG(FATAL) indicates a big problem, so don't run atexit() calls
     tcmalloc::Abort();
   }
 }
 
 // Note that since the order of global constructors is unspecified,
 // global code that calls RAW_LOG may execute before FLAGS_verbose is set.
 // Such code will run with verbosity == 0 no matter what.
 #define VLOG_IS_ON(severity) (FLAGS_verbose >= severity)
@@ skipping 34 matching lines @@
 #else
 typedef int RawFD;
 const RawFD kIllegalRawFD = -1;   // what open returns if it fails
 #endif  // defined(_WIN32) || defined(__CYGWIN__) || defined(__CYGWIN32__)
 
 RawFD RawOpenForWriting(const char* filename);   // uses default permissions
 void RawWrite(RawFD fd, const char* buf, size_t len);
 void RawClose(RawFD fd);
 
 #endif // _LOGGING_H_