Log to webrtc logging stream from java code.

webrtc/base/logging.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 96 matching lines @@
 // of destructors at program exit.  Let the person who sets the stream trigger
 // cleanup by setting to NULL, or let it leak (safe at program exit).
 LogMessage::StreamList LogMessage::streams_ GUARDED_BY(LogMessage::crit_);
 
 // Boolean options default to false (0)
 bool LogMessage::thread_, LogMessage::timestamp_;
 
 LogMessage::LogMessage(const char* file, int line, LoggingSeverity sev,
                        LogErrorContext err_ctx, int err, const char* module)
     : severity_(sev),
+      android_tag_(kLibjingle),

[AlexG, 2015/09/14 20:12:33]

kLibjingle is defined for WEBRTC_ANDROID only - this will probably fail to
compile.
Define kLibjingle for all platforms? Also may be worth to rename android_tag to
just "tag" - in case other platform will use it in future?

[jiayl2, 2015/09/14 20:54:38]

Done.

       warn_slow_logs_delay_(WARN_SLOW_LOGS_DELAY) {
   if (timestamp_) {
     uint32 time = TimeSince(LogStartTime());
     // Also ensure WallClockStartTime is initialized, so that it matches
     // LogStartTime.
     WallClockStartTime();
     print_stream_ << "[" << std::setfill('0') << std::setw(3) << (time / 1000)
                   << ":" << std::setw(3) << (time % 1000) << std::setfill(' ')
                   << "] ";
   }
@@ skipping 41 matching lines @@
         break;
       }
 #endif  // WEBRTC_MAC && !defined(WEBRTC_IOS)
       default:
         break;
     }
     extra_ = tmp.str();
   }
 }
 
+LogMessage::LogMessage(const char* file,
+                       int line,
+                       LoggingSeverity sev,
+                       const std::string& tag)
+    : LogMessage(file, line, sev, ERRCTX_NONE, 0 /* err */, NULL /* module */) {
+  android_tag_ = tag;

[AlexG, 2015/09/14 20:12:33]

Move this to ctor initialization list?

[jiayl2, 2015/09/14 20:54:38]

That will cause compile error

+}
+
 LogMessage::~LogMessage() {
   if (!extra_.empty())
     print_stream_ << " : " << extra_;
   print_stream_ << std::endl;
 
   const std::string& str = print_stream_.str();
   if (severity_ >= dbg_sev_) {
-    OutputToDebug(str, severity_);
+    OutputToDebug(str, severity_, android_tag_);
   }
 
   uint32 before = Time();
   // Must lock streams_ before accessing
   CritScope cs(&crit_);
   for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
     if (severity_ >= it->second) {
       it->first->OnLogMessage(str);
     }
   }
@@ skipping 130 matching lines @@
 
 void LogMessage::UpdateMinLogSeverity() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
   LoggingSeverity min_sev = dbg_sev_;
   for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
     min_sev = std::min(dbg_sev_, it->second);
   }
   min_sev_ = min_sev;
 }
 
 void LogMessage::OutputToDebug(const std::string& str,
-                               LoggingSeverity severity) {
+                               LoggingSeverity severity,
+                               const std::string& tag) {
   bool log_to_stderr = log_to_stderr_;
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) && (!defined(DEBUG) || defined(NDEBUG))
   // On the Mac, all stderr output goes to the Console log and causes clutter.
   // So in opt builds, don't log to stderr unless the user specifically sets
   // a preference to do so.
   CFStringRef key = CFStringCreateWithCString(kCFAllocatorDefault,
                                               "logToStdErr",
                                               kCFStringEncodingUTF8);
   CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
   if (key != NULL && domain != NULL) {
@@ skipping 23 matching lines @@
   }
 #endif  // WEBRTC_WIN
 #if defined(WEBRTC_ANDROID)
   // Android's logging facility uses severity to log messages but we
   // need to map libjingle's severity levels to Android ones first.
   // Also write to stderr which maybe available to executable started
   // from the shell.
   int prio;
   switch (severity) {
     case LS_SENSITIVE:
-      __android_log_write(ANDROID_LOG_INFO, kLibjingle, "SENSITIVE");
+      __android_log_write(ANDROID_LOG_INFO, tag.c_str(), "SENSITIVE");
       if (log_to_stderr) {
         fprintf(stderr, "SENSITIVE");
         fflush(stderr);
       }
       return;
     case LS_VERBOSE:
       prio = ANDROID_LOG_VERBOSE;
       break;
     case LS_INFO:
       prio = ANDROID_LOG_INFO;

[AlexG, 2015/09/14 20:12:33]

May be use ANDROID_LOG_DEBUG here? We are mostly using Log.d, but it now will be
routed to Log.i

[jiayl2, 2015/09/14 20:54:38]

Mapping info to info is more intuitive. Unless you have a strong reason to use
log.d, I think it's fine to change to log.i.

[AlexG, 2015/09/14 21:02:11]

I meant all Lod.d call from Java will now actually become Log.i:
 public static void d(String tag, String message) {
   log(Severity.LS_INFO, tag, message);
 }

But it may be ok

       break;
     case LS_WARNING:
       prio = ANDROID_LOG_WARN;
       break;
     case LS_ERROR:
       prio = ANDROID_LOG_ERROR;
       break;
     default:
       prio = ANDROID_LOG_UNKNOWN;
   }
 
   int size = str.size();
   int line = 0;
   int idx = 0;
   const int max_lines = size / kMaxLogLineSize + 1;
   if (max_lines == 1) {
-    __android_log_print(prio, kLibjingle, "%.*s", size, str.c_str());
+    __android_log_print(prio, tag.c_str(), "%.*s", size, str.c_str());
   } else {
     while (size > 0) {
       const int len = std::min(size, kMaxLogLineSize);
       // Use the size of the string in the format (str may have \0 in the
       // middle).
-      __android_log_print(prio, kLibjingle, "[%d/%d] %.*s",
+      __android_log_print(prio, tag.c_str(), "[%d/%d] %.*s",
                           line + 1, max_lines,
                           len, str.c_str() + idx);
       idx += len;
       size -= len;
       ++line;
     }
   }
 #endif  // WEBRTC_ANDROID
   if (log_to_stderr) {
     fprintf(stderr, "%s", str.c_str());
@@ skipping 118 matching lines @@
   }
 
   if (state) {
     state->unprintable_count_[input] = consecutive_unprintable;
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc