Upstream android debug and log related files

base/logging.cc

 // Copyright (c) 2011 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/logging.h"
 
 #if defined(OS_WIN)
 #include <io.h>
 #include <windows.h>
 typedef HANDLE FileHandle;
@@ skipping 40 matching lines @@
 #include "base/debug/stack_trace.h"
 #include "base/eintr_wrapper.h"
 #include "base/string_piece.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/utf_string_conversions.h"
 #include "base/vlog.h"
 #if defined(OS_POSIX)
 #include "base/safe_strerror_posix.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include <android/log.h>
+#endif
+
 namespace logging {
 
 DcheckState g_dcheck_state = DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
 VlogInfo* g_vlog_info = NULL;
 
 const char* const log_severity_names[LOG_NUM_SEVERITIES] = {
   "INFO", "WARNING", "ERROR", "ERROR_REPORT", "FATAL" };
 
 int min_log_level = 0;
 
@@ skipping 51 matching lines @@
 #endif
 }
 
 int32 CurrentThreadId() {
 #if defined(OS_WIN)
   return GetCurrentThreadId();
 #elif defined(OS_MACOSX)
   return mach_thread_self();
 #elif defined(OS_LINUX)
   return syscall(__NR_gettid);
+#elif defined(OS_ANDROID)
+  return gettid();
 #elif defined(OS_FREEBSD)
   // TODO(BSD): find a better thread ID
   return reinterpret_cast<int64>(pthread_self());
 #elif defined(OS_NACL)
   return pthread_self();
 #endif
 }
 
 uint64 TickCount() {
 #if defined(OS_WIN)
@@ skipping 397 matching lines @@
 
 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
                        std::string* result)
     : severity_(severity), file_(file), line_(line) {
   Init(file, line);
   stream_ << "Check failed: " << *result;
   delete result;
 }
 
 LogMessage::~LogMessage() {
-#ifndef NDEBUG
+  // TODO(port): enable stacktrace generation on LOG_FATAL once backtrace are
+  // working in Android.
+#if  !defined(NDEBUG) && !defined(OS_ANDROID)
   if (severity_ == LOG_FATAL) {
     // Include a stack trace on a fatal.
     base::debug::StackTrace trace;
     stream_ << std::endl;  // Newline to separate from log message.
     trace.OutputToStream(&stream_);
   }
 #endif
   stream_ << std::endl;
   std::string str_newline(stream_.str());
 
   // Give any log message handler first dibs on the message.
   if (log_message_handler && log_message_handler(severity_, file_, line_,
           message_start_, str_newline)) {
     // The handler took care of it, no further processing.
     return;
   }
 
   if (logging_destination == LOG_ONLY_TO_SYSTEM_DEBUG_LOG ||
       logging_destination == LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG) {
 #if defined(OS_WIN)
     OutputDebugStringA(str_newline.c_str());
+#elif defined(OS_ANDROID)
+    android_LogPriority priority = ANDROID_LOG_UNKNOWN;
+    switch (severity_) {
+      case LOG_INFO:
+        priority = ANDROID_LOG_INFO;
+        break;
+      case LOG_WARNING:
+        priority = ANDROID_LOG_WARN;
+        break;
+      case LOG_ERROR:
+      case LOG_ERROR_REPORT:
+        priority = ANDROID_LOG_ERROR;
+        break;
+      case LOG_FATAL:
+        priority = ANDROID_LOG_FATAL;
+        break;
+    }
+    __android_log_write(priority, "chromium", str_newline.c_str());
 #endif
     fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   } else if (severity_ >= kAlwaysPrintErrorLevel) {
     // When we're only outputting to a log file, above a certain log level, we
     // should still output to stderr so that we can better detect and diagnose
     // problems with unit tests, especially on the buildbots.
     fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   }
@@ skipping 240 matching lines @@
 
 // This was defined at the beginnig of this file.
 #undef write
 
 std::ostream& operator<<(std::ostream& o, const StringPiece& piece) {
   o.write(piece.data(), static_cast<std::streamsize>(piece.size()));
   return o;
 }
 
 }  // namespace base