Chromium Code Reviews Chromium Code Reviews
Issue 8991010:
This change updates the libjingle logging so that it writes to chromiums VLOG instead of its own ... (Closed)
Base URL: http://src.chromium.org/svn/trunk/src/| Index: third_party/libjingle/overrides/talk/base/logging.h |
| =================================================================== |
| --- third_party/libjingle/overrides/talk/base/logging.h (revision 113136) |
| +++ third_party/libjingle/overrides/talk/base/logging.h (working copy) |
| @@ -1,81 +1,44 @@ |
| -/* |
| - * libjingle |
| - * Copyright 2004--2005, Google Inc. |
| - * |
| - * Redistribution and use in source and binary forms, with or without |
| - * modification, are permitted provided that the following conditions are met: |
| - * |
| - * 1. Redistributions of source code must retain the above copyright notice, |
| - * this list of conditions and the following disclaimer. |
| - * 2. Redistributions in binary form must reproduce the above copyright notice, |
| - * this list of conditions and the following disclaimer in the documentation |
| - * and/or other materials provided with the distribution. |
| - * 3. The name of the author may not be used to endorse or promote products |
| - * derived from this software without specific prior written permission. |
| - * |
| - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| - * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| - */ |
| +// 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. |
| -// LOG(...) an ostream target that can be used to send formatted |
| -// output to a variety of logging targets, such as debugger console, stderr, |
| -// file, or any StreamInterface. |
| -// The severity level passed as the first argument to the the LOGging |
| -// functions is used as a filter, to limit the verbosity of the logging. |
| -// Static members of LogMessage documented below are used to control the |
| -// verbosity and target of the output. |
| -// There are several variations on the LOG macro which facilitate logging |
| -// of common error conditions, detailed below. |
| +// This file overrides the logging macros in libjingle (talk/base/logging.h). |
| +// Instead of using libjingle's logging implementation, the libjingle macros are |
| +// mapped to the corresponding base/logging.h macro (chromium's VLOG). |
| +// If this file is included outside of libjingle (e.g. in wrapper code) it |
| +// should be included after base/logging.h (if any) or compiler error or |
| +// unexpected behavior may occur (macros that have the same name in libjingle as |
| +// in chromium will use the libjingle definition if this file is included |
| +// first). |
| -// LOG(sev) logs the given stream at severity "sev", which must be a |
| -// compile-time constant of the LoggingSeverity type, without the namespace |
| -// prefix. |
| -// LOG_V(sev) Like LOG(), but sev is a run-time variable of the LoggingSeverity |
| -// type (basically, it just doesn't prepend the namespace). |
| -// LOG_F(sev) Like LOG(), but includes the name of the current function. |
| -// LOG_GLE(M)(sev [, mod]) attempt to add a string description of the |
| -// HRESULT returned by GetLastError. The "M" variant allows searching of a |
| -// DLL's string table for the error description. |
| -// LOG_ERRNO(sev) attempts to add a string description of an errno-derived |
| -// error. errno and associated facilities exist on both Windows and POSIX, |
| -// but on Windows they only apply to the C/C++ runtime. |
| -// LOG_ERR(sev) is an alias for the platform's normal error system, i.e. _GLE on |
| -// Windows and _ERRNO on POSIX. |
| -// (The above three also all have _EX versions that let you specify the error |
| -// code, rather than using the last one.) |
| -// LOG_E(sev, ctx, err, ...) logs a detailed error interpreted using the |
| -// specified context. |
| -// LOG_CHECK_LEVEL(sev) (and LOG_CHECK_LEVEL_V(sev)) can be used as a test |
| -// before performing expensive or sensitive operations whose sole purpose is |
| -// to output logging data at the desired level. |
| -// Lastly, PLOG(sev, err) is an alias for LOG_ERR_EX. |
| +// Setting the LoggingSeverity (and lower) that should be written to file should |
| +// be done via command line by specifying the flags: |
| +// --vmodule or --v please see base/logging.h for details on how to use them. |
| +// Specifying what file to write to is done using InitLogging also in |
| +// base/logging.h. |
| -#ifndef TALK_BASE_LOGGING_H_ |
| -#define TALK_BASE_LOGGING_H_ |
| +// The macros and classes declared in here are not described as they are |
| +// NOT TO BE USED outside of libjingle. |
| -#ifdef HAVE_CONFIG_H |
| -#include "config.h" // NOLINT |
| -#endif |
| +#ifndef THIRD_PARTY_LIBJINGLE_OVERRIDES_TALK_BASE_LOGGING_H_ |
| +#define THIRD_PARTY_LIBJINGLE_OVERRIDES_TALK_BASE_LOGGING_H_ |
| -#include <list> |
| #include <sstream> |
| #include <string> |
| -#include <utility> |
| -#include "talk/base/basictypes.h" |
| -#include "talk/base/criticalsection.h" |
| -namespace talk_base { |
| +// Note that this works inside chromium because the include order is |
| +// guaranteed/required as mentioned above. |
| +#ifndef BASE_LOGGING_H_ // This is the include guard for the chromium logging. |
| +#define LOGGING_INSIDE_LIBJINGLE |
|
Sergey Ulanov
2011/12/28 02:38:15
Can we define this in the gyp in the same way SAFE
hellner
2012/01/10 23:31:28
Yes, doing this is an improvement since we no long
|
| +#include "base/logging.h" |
| +#endif // BASE_LOGGING_H_ |
| -class StreamInterface; |
| +#ifdef HAVE_CONFIG_H |
| +#include "config.h" // NOLINT |
| +#endif |
| +namespace talk_base { |
| + |
| /////////////////////////////////////////////////////////////////////////////// |
| // ConstantLabel can be used to easily generate string names from constant |
| // values. This can be useful for logging descriptive names of error messages. |
| @@ -91,19 +54,18 @@ |
| // LOG(LS_ERROR) << "LibraryFunc returned: " |
| // << ErrorName(err, LIBRARY_ERRORS); |
| -struct ConstantLabel { int value; const char * label; }; |
| - |
| -#if defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS) |
| +struct ConstantLabel { |
| + int value; |
| + const char * label; |
| +}; |
| #define KLABEL(x) { x, #x } |
| #define TLABEL(x, y) { x, y } |
| #define LASTLABEL { 0, 0 } |
| -#endif // defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS) |
| const char * FindLabel(int value, const ConstantLabel entries[]); |
| std::string ErrorName(int err, const ConstantLabel* err_table); |
| ////////////////////////////////////////////////////////////////////// |
| - |
| // Note that the non-standard LoggingSeverity aliases exist because they are |
| // still in broad use. The meanings of the levels are: |
| // LS_SENSITIVE: Information which should only be logged with the consent |
| @@ -114,7 +76,17 @@ |
| // in debug builds. |
| // LS_WARNING: Something that may warrant investigation. |
| // LS_ERROR: Something that should not have occurred. |
| -enum LoggingSeverity { LS_SENSITIVE, LS_VERBOSE, LS_INFO, LS_WARNING, LS_ERROR, |
| +// Note that LoggingSeverity is mapped over to chromiums verbosity levels where |
| +// anything lower than or equal to the current verbosity level is written to |
| +// file which is the opposite of logging severity in libjingle where higher |
| +// severity numbers than or equal to the current severity level are written to |
| +// file. Also, note that the values are explicitly defined here for convenience |
| +// since the command line flag must be set using numerical values. |
| +enum LoggingSeverity { LS_ERROR = 1, |
| + LS_WARNING = 2, |
| + LS_INFO = 3, |
| + LS_VERBOSE = 4, |
| + LS_SENSITIVE = 5, |
| INFO = LS_INFO, |
| WARNING = LS_WARNING, |
| LERROR = LS_ERROR }; |
| @@ -132,116 +104,45 @@ |
| ERRCTX_OS = ERRCTX_OSSTATUS, // LOG_E(sev, OS, x) |
| }; |
| -class LogMessage { |
| +// Class that makes it possible describe a LOG_E message as a single string. |
| +// I.e. the format that VLOG is expecting. |
| +class LogEHelper { |
| public: |
| - static const int NO_LOGGING; |
| + LogEHelper(const char* file, int line, LoggingSeverity severity, |
| + const std::string extra); |
| + ~LogEHelper(); |
| - LogMessage(const char* file, int line, LoggingSeverity sev, |
| - LogErrorContext err_ctx = ERRCTX_NONE, int err = 0, |
| - const char* module = NULL); |
| - ~LogMessage(); |
| - |
| - static inline bool Loggable(LoggingSeverity sev) { return (sev >= min_sev_); } |
| std::ostream& stream() { return print_stream_; } |
| - // These are attributes which apply to all logging channels |
| - // LogContext: Display the file and line number of the message |
| - static void LogContext(int min_sev); |
| - // LogThreads: Display the thread identifier of the current thread |
| - static void LogThreads(bool on = true); |
| - // LogTimestamps: Display the elapsed time of the program |
| - static void LogTimestamps(bool on = true); |
| - |
| - // Timestamps begin with program execution, but can be reset with this |
| - // function for measuring the duration of an activity, or to synchronize |
| - // timestamps between multiple instances. |
| - static void ResetTimestamps(); |
| - |
| - // These are the available logging channels |
| - // Debug: Debug console on Windows, otherwise stderr |
| - static void LogToDebug(int min_sev); |
| - static int GetLogToDebug() { return dbg_sev_; } |
| - |
| - // Stream: Any non-blocking stream interface. LogMessage takes ownership of |
| - // the stream. Multiple streams may be specified by using AddLogToStream. |
| - // LogToStream is retained for backwards compatibility; when invoked, it |
| - // will discard any previously set streams and install the specified stream. |
| - // GetLogToStream gets the severity for the specified stream, of if none |
| - // is specified, the minimum stream severity. |
| - // RemoveLogToStream removes the specified stream, without destroying it. |
| - static void LogToStream(StreamInterface* stream, int min_sev); |
| - static int GetLogToStream(StreamInterface* stream = NULL); |
| - static void AddLogToStream(StreamInterface* stream, int min_sev); |
| - static void RemoveLogToStream(StreamInterface* stream); |
| - |
| - // Testing against MinLogSeverity allows code to avoid potentially expensive |
| - // logging operations by pre-checking the logging level. |
| - static int GetMinLogSeverity() { return min_sev_; } |
| - |
| - static void SetDiagnosticMode(bool f) { is_diagnostic_mode_ = f; } |
| - static bool IsDiagnosticMode() { return is_diagnostic_mode_; } |
| - |
| - // Parses the provided parameter stream to configure the options above. |
| - // Useful for configuring logging from the command line. If file logging |
| - // is enabled, it is output to the specified filename. |
| - static void ConfigureLogging(const char* params, const char* filename); |
| - |
| - // Convert the string to a LS_ value; also accept numeric values. |
| - static int ParseLogSeverity(const std::string& value); |
| - |
| private: |
| - typedef std::list<std::pair<StreamInterface*, int> > StreamList; |
| + const std::string file_name_; |
| + const int line_; |
| - // Updates min_sev_ appropriately when debug sinks change. |
| - static void UpdateMinLogSeverity(); |
| + const std::string extra_; |
| + const LoggingSeverity severity_; |
| - // These assist in formatting some parts of the debug output. |
| - static const char* Describe(LoggingSeverity sev); |
| - static const char* DescribeFile(const char* file); |
| - |
| - // These write out the actual log messages. |
| - static void OutputToDebug(const std::string& msg, LoggingSeverity severity_); |
| - static void OutputToStream(StreamInterface* stream, const std::string& msg); |
| - |
| - // The ostream that buffers the formatted message before output |
| std::ostringstream print_stream_; |
| +}; |
| - // The severity level of this message |
| - LoggingSeverity severity_; |
| - |
| - // String data generated in the constructor, that should be appended to |
| - // the message before output. |
| - std::string extra_; |
| - |
| - // Global lock for the logging subsystem |
| - static CriticalSection crit_; |
| - |
| - // dbg_sev_ is the thresholds for those output targets |
| - // min_sev_ is the minimum (most verbose) of those levels, and is used |
| - // as a short-circuit in the logging macros to identify messages that won't |
| - // be logged. |
| - // ctx_sev_ is the minimum level at which file context is displayed |
| - static int min_sev_, dbg_sev_, ctx_sev_; |
| - |
| - // The output streams and their associated severities |
| - static StreamList streams_; |
| - |
| - // Flags for formatting options |
| - static bool thread_, timestamp_; |
| - |
| - // The timestamp at which logging started. |
| - static uint32 start_; |
| - |
| - // are we in diagnostic mode (as defined by the app)? |
| - static bool is_diagnostic_mode_; |
| - |
| - DISALLOW_COPY_AND_ASSIGN(LogMessage); |
| +// This class is used to explicitly ignore values in the conditional |
| +// logging macros. This avoids compiler warnings like "value computed |
| +// is not used" and "statement has no effect". |
| +class LogMessageVoidify { |
| + public: |
| + LogMessageVoidify() { } |
| + // This has to be an operator with a precedence lower than << but |
| + // higher than ?: |
| + void operator&(std::ostream&) { } |
| }; |
| ////////////////////////////////////////////////////////////////////// |
| // Logging Helpers |
| ////////////////////////////////////////////////////////////////////// |
| +// Summarizes LOG_E messages as strings. |
| +std::string GenerateExtra(LogErrorContext err_ctx = ERRCTX_NONE, int err = 0, |
| + const char* module = NULL); |
| + |
| class LogMultilineState { |
| public: |
| size_t unprintable_count_[2]; |
| @@ -256,53 +157,26 @@ |
| const void* data, size_t len, bool hex_mode, |
| LogMultilineState* state); |
| +} // namespace talk_base |
| + |
| ////////////////////////////////////////////////////////////////////// |
| -// Macros which automatically disable logging when LOGGING == 0 |
| +// Libjingle macros which are mapped over to their VLOG equivalent in |
| +// base/logging.h |
| ////////////////////////////////////////////////////////////////////// |
| -// If LOGGING is not explicitly defined, default to enabled in debug mode |
| -#if defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS) |
| -#if !defined(LOGGING) |
| -#if defined(_DEBUG) && !defined(NDEBUG) && !defined(NO_LIBJINGLE_LOGGING) |
| -#define LOGGING 1 |
| -#else |
| -#define LOGGING 0 |
| -#endif |
| -#endif // !defined(LOGGING) |
| +#ifdef LOGGING_INSIDE_LIBJINGLE |
| -#ifndef LOG |
| -#if LOGGING |
| +#define LOG_CHECK_LEVEL(sev) \ |
| + VLOG_IS_ON(talk_base::sev) |
| +#define LOG_CHECK_LEVEL_V(sev) \ |
| + VLOG_IS_ON(sev) |
| -// The following non-obvious technique for implementation of a |
| -// conditional log stream was stolen from google3/base/logging.h. |
| - |
| -// This class is used to explicitly ignore values in the conditional |
| -// logging macros. This avoids compiler warnings like "value computed |
| -// is not used" and "statement has no effect". |
| - |
| -class LogMessageVoidify { |
| - public: |
| - LogMessageVoidify() { } |
| - // This has to be an operator with a precedence lower than << but |
| - // higher than ?: |
| - void operator&(std::ostream&) { } |
| -}; |
| - |
| -#define LOG_SEVERITY_PRECONDITION(sev) \ |
| - !(talk_base::LogMessage::Loggable(sev)) \ |
| - ? (void) 0 \ |
| - : talk_base::LogMessageVoidify() & |
| - |
| +#define LOG_V(sev) \ |
| + VLOG(sev) |
| +#undef LOG |
| #define LOG(sev) \ |
| - LOG_SEVERITY_PRECONDITION(talk_base::sev) \ |
| - talk_base::LogMessage(__FILE__, __LINE__, talk_base::sev).stream() |
| + LOG_V(talk_base::sev) |
| -// The _V version is for when a variable is passed in. It doesn't do the |
| -// namespace concatination. |
| -#define LOG_V(sev) \ |
| - LOG_SEVERITY_PRECONDITION(sev) \ |
| - talk_base::LogMessage(__FILE__, __LINE__, sev).stream() |
| - |
| // The _F version prefixes the message with the current function name. |
| #if defined(__GNUC__) && defined(_DEBUG) |
| #define LOG_F(sev) LOG(sev) << __PRETTY_FUNCTION__ << ": " |
| @@ -310,44 +184,31 @@ |
| #define LOG_F(sev) LOG(sev) << __FUNCTION__ << ": " |
| #endif |
| -#define LOG_CHECK_LEVEL(sev) \ |
| - talk_base::LogCheckLevel(talk_base::sev) |
| -#define LOG_CHECK_LEVEL_V(sev) \ |
| - talk_base::LogCheckLevel(sev) |
| -inline bool LogCheckLevel(LoggingSeverity sev) { |
| - return (LogMessage::GetMinLogSeverity() <= sev); |
| -} |
| +// LOG_E can't call VLOG directly like LOG_V can since VLOG expands into usage |
| +// of the __FILE__ macro (for filtering) and the actual VLOG call from LOG_E |
| +// happens inside LogEHelper. Note that the second parameter to the LAZY_STREAM |
| +// macro is true since the filter check is already done for LOG_E. |
| +#define LOG_E_BASE(file_name, line_number, sev) \ |
| + LAZY_STREAM(logging::LogMessage(file_name, line_number, \ |
| + -sev).stream(), \ |
| + true) |
| +#define LOG_SEVERITY_PRECONDITION(sev) \ |
| + !(LOG_CHECK_LEVEL_V(sev)) \ |
| + ? (void) 0 \ |
| + : talk_base::LogMessageVoidify() & |
| + |
| #define LOG_E(sev, ctx, err, ...) \ |
| LOG_SEVERITY_PRECONDITION(talk_base::sev) \ |
| - talk_base::LogMessage(__FILE__, __LINE__, talk_base::sev, \ |
| - talk_base::ERRCTX_ ## ctx, err , ##__VA_ARGS__) \ |
| - .stream() |
| + talk_base::LogEHelper( \ |
| + __FILE__, __LINE__, talk_base::sev, \ |
| + talk_base::GenerateExtra( \ |
| + talk_base::ERRCTX_ ## ctx, err , ##__VA_ARGS__)).stream() |
| -#else // !LOGGING |
| - |
| -// Hopefully, the compiler will optimize away some of this code. |
| -// Note: syntax of "1 ? (void)0 : LogMessage" was causing errors in g++, |
| -// converted to "while (false)" |
| -#define LOG(sev) \ |
| - while (false)talk_base:: LogMessage(NULL, 0, talk_base::sev).stream() |
| -#define LOG_V(sev) \ |
| - while (false) talk_base::LogMessage(NULL, 0, sev).stream() |
| -#define LOG_F(sev) LOG(sev) << __FUNCTION__ << ": " |
| -#define LOG_CHECK_LEVEL(sev) \ |
| - false |
| -#define LOG_CHECK_LEVEL_V(sev) \ |
| - false |
| - |
| -#define LOG_E(sev, ctx, err, ...) \ |
| - while (false) talk_base::LogMessage(__FILE__, __LINE__, talk_base::sev, \ |
| - talk_base::ERRCTX_ ## ctx, err , ##__VA_ARGS__) \ |
| - .stream() |
| - |
| -#endif // !LOGGING |
| - |
| +#undef LOG_ERRNO_EX |
| #define LOG_ERRNO_EX(sev, err) \ |
| LOG_E(sev, ERRNO, err) |
| +#undef LOG_ERRNO |
| #define LOG_ERRNO(sev) \ |
| LOG_ERRNO_EX(sev, errno) |
| @@ -373,14 +234,12 @@ |
| (errno) |
| #endif // WIN32 |
| +#undef PLOG |
| #define PLOG(sev, err) \ |
| LOG_ERR_EX(sev, err) |
| // TODO(?): Add an "assert" wrapper that logs in the same manner. |
| -#endif // LOG |
| -#endif // defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS) |
| +#endif // LOGGING_INSIDE_LIBJINGLE |
| -} // namespace talk_base |
| - |
| -#endif // TALK_BASE_LOGGING_H_ |
| +#endif // THIRD_PARTY_LIBJINGLE_OVERRIDES_TALK_BASE_LOGGING_H_ |
