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,35 @@ |
-/* |
- * 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) 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. |
-// 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" |
+#include "base/logging.h" |
+ |
namespace talk_base { |
-class StreamInterface; |
- |
/////////////////////////////////////////////////////////////////////////////// |
// 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 +45,17 @@ |
// 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[]); |
+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 +66,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,110 +94,35 @@ |
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, |
+ LogErrorContext err_ctx, int err, const char* module = NULL); |
+ ~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(); |
+ 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&) { } |
}; |
////////////////////////////////////////////////////////////////////// |
@@ -256,53 +143,22 @@ |
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) |
+#if defined(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. |
+#define LOG_V(sev) VLOG(sev) |
+#undef LOG |
+#define LOG(sev) LOG_V(talk_base::sev) |
-// 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(sev) \ |
- LOG_SEVERITY_PRECONDITION(talk_base::sev) \ |
- talk_base::LogMessage(__FILE__, __LINE__, talk_base::sev).stream() |
- |
-// 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,77 +166,40 @@ |
#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); |
-} |
- |
+// This macro wrapps the LAZY_STREAM macro from base/logging.h but flips the |
+// order of the parameters. This is necessary since some compilers will fail |
+// unless __VA_ARGS__ is at the end. |
+// TODO(hellner): find reference for this. |
+#define LAZY_STREAM_REVERSE(condition, stream) LAZY_STREAM(stream, condition) |
#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() |
+ LAZY_STREAM_REVERSE(LOG_CHECK_LEVEL_V(talk_base::sev), \ |
+ talk_base::LogEHelper(__FILE__, __LINE__, \ |
+ talk_base::sev, \ |
+ talk_base::ERRCTX_ ## ctx, \ |
+ err, \ |
+ ##__VA_ARGS__).stream()) |
-#else // !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) |
-// 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 |
+#if defined(OS_WIN) |
+#define LOG_GLE_EX(sev, err) LOG_E(sev, HRESULT, err) |
+#define LOG_GLE(sev) LOG_GLE_EX(sev, GetLastError()) |
+#define LOG_GLEM(sev, mod) LOG_E(sev, HRESULT, GetLastError(), mod) |
+#define LOG_ERR_EX(sev, err) LOG_GLE_EX(sev, err) |
+#define LOG_ERR(sev) LOG_GLE(sev) |
+#define LAST_SYSTEM_ERROR (::GetLastError()) |
+#else |
+#define LOG_ERR_EX(sev, err) LOG_ERRNO_EX(sev, err) |
+#define LOG_ERR(sev) LOG_ERRNO(sev) |
+#define LAST_SYSTEM_ERROR (errno) |
+#endif // OS_WIN |
-#define LOG_E(sev, ctx, err, ...) \ |
- while (false) talk_base::LogMessage(__FILE__, __LINE__, talk_base::sev, \ |
- talk_base::ERRCTX_ ## ctx, err , ##__VA_ARGS__) \ |
- .stream() |
+#undef PLOG |
+#define PLOG(sev, err) LOG_ERR_EX(sev, err) |
-#endif // !LOGGING |
+#endif // LOGGING_INSIDE_LIBJINGLE |
-#define LOG_ERRNO_EX(sev, err) \ |
- LOG_E(sev, ERRNO, err) |
-#define LOG_ERRNO(sev) \ |
- LOG_ERRNO_EX(sev, errno) |
- |
-#ifdef WIN32 |
-#define LOG_GLE_EX(sev, err) \ |
- LOG_E(sev, HRESULT, err) |
-#define LOG_GLE(sev) \ |
- LOG_GLE_EX(sev, GetLastError()) |
-#define LOG_GLEM(sev, mod) \ |
- LOG_E(sev, HRESULT, GetLastError(), mod) |
-#define LOG_ERR_EX(sev, err) \ |
- LOG_GLE_EX(sev, err) |
-#define LOG_ERR(sev) \ |
- LOG_GLE(sev) |
-#define LAST_SYSTEM_ERROR \ |
- (::GetLastError()) |
-#elif POSIX |
-#define LOG_ERR_EX(sev, err) \ |
- LOG_ERRNO_EX(sev, err) |
-#define LOG_ERR(sev) \ |
- LOG_ERRNO(sev) |
-#define LAST_SYSTEM_ERROR \ |
- (errno) |
-#endif // WIN32 |
- |
-#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) |
- |
-} // namespace talk_base |
- |
-#endif // TALK_BASE_LOGGING_H_ |
+#endif // THIRD_PARTY_LIBJINGLE_OVERRIDES_TALK_BASE_LOGGING_H_ |