This change updates the libjingle logging so that it writes to chromiums VLOG instead of its own ...

third_party/libjingle/overrides/talk/base/logging.h

-/*
- * 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.
+
+#ifndef THIRD_PARTY_LIBJINGLE_OVERRIDES_TALK_BASE_LOGGING_H_
+#define THIRD_PARTY_LIBJINGLE_OVERRIDES_TALK_BASE_LOGGING_H_
+
+#include <sstream>
+#include <string>
+
+#include "base/logging.h"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"  // NOLINT

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: I guess we can remove this

[hellner, 2012/01/11 19:16:58]

Correct, this is only used when building libjingle standalone.

Done.

 #endif
 
-#include <list>
-#include <sstream>
-#include <string>
-#include <utility>
-#include "talk/base/basictypes.h"
-#include "talk/base/criticalsection.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.
 // Usage:
 //   const ConstantLabel LIBRARY_ERRORS[] = {
 //     KLABEL(SOME_ERROR),
 //     KLABEL(SOME_OTHER_ERROR),
 //     ...
 //     LASTLABEL
 //   }
 //
 //   int err = LibraryFunc();
 //   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;

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: "char*" without space

[hellner, 2012/01/11 19:16:58]

Done.

+};
 #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[]);

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: "char*" without space

[hellner, 2012/01/11 19:16:58]

Done.

 std::string ErrorName(int err, const ConstantLabel* err_table);

[Sergey Ulanov, 2012/01/11 02:25:49]

It looks strange that these two methods are here - they have nothing to do with
logging. Maybe add TODO to move them

[hellner, 2012/01/11 19:16:58]

Well, they are used to provide (a shorthand for) text information when logging.
The general comment above explains how ErrorName can be used. FindLabel is e.g.
used in talk/base/schanneladapter.cc.

This could potentially be moved to a separate file since the functionality is
orthogonal to the logging. However, I don't think adding a comment is
appropriate here as it may be confusing since the change should be made in
libjingle and not in this override file.

 
 //////////////////////////////////////////////////////////////////////
-
 // 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
 //   of the user, due to privacy concerns.
 //  LS_VERBOSE: This level is for data which we do not want to appear in the
 //   normal debug log, but should appear in diagnostic logs.
 //  LS_INFO: Chatty level used in debugging for all sorts of things, the default
 //   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 };
 
 // LogErrorContext assists in interpreting the meaning of an error value.
 enum LogErrorContext {
   ERRCTX_NONE,
   ERRCTX_ERRNO,     // System-local errno
   ERRCTX_HRESULT,   // Windows HRESULT
   ERRCTX_OSSTATUS,  // MacOS OSStatus
 
   // Abbreviations for LOG_E macro
   ERRCTX_EN = ERRCTX_ERRNO,     // LOG_E(sev, EN, x)
   ERRCTX_HR = ERRCTX_HRESULT,   // LOG_E(sev, HR, x)
   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);
+ private:
+  const std::string file_name_;
+  const int line_;
 
-  // 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();
+  const std::string extra_;
+  const LoggingSeverity severity_;
 
-  // 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_; }
+  std::ostringstream print_stream_;
+};
 
-  //  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;
-
-  // Updates min_sev_ appropriately when debug sinks change.
-  static void UpdateMinLogSeverity();
-
-  // 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,

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: In Chromium each argument must be on its own line if all of them don't fit
on one line. I.e. this code must be formatted as follows:
std::string GenerateExtra(LogErrorContext err_ctx = ERRCTX_NONE,
                          int err = 0,
                          const char* module = NULL)

[Sergey Ulanov, 2012/01/11 02:25:49]

code style doesn't allow default argument values. Can we avoid them here?

[Sergey Ulanov, 2012/01/11 02:25:49]

Is it possible to change this code so that we don't expose this function in the
header? E.g. roll it into LogEHelper(). Don't worry about it if it is too much
work.

[hellner, 2012/01/11 19:16:58]

There are some exceptions to the rule... I don't see a way that I can avoid
default parameters here without making massive changes to libjingle (everywhere
this macro is used but not all parameters passed (I verified that they exist by
removing the default parameters and tried to compile)).

[hellner, 2012/01/11 19:16:58]

Interesting, that's different from what the second example in
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Function_Decla...
. Good to know.

Done.

[hellner, 2012/01/11 19:16:58]

Done.

+                          const char* module = NULL);
+
 class LogMultilineState {
  public:
   size_t unprintable_count_[2];
   LogMultilineState() {
     unprintable_count_[0] = unprintable_count_[1] = 0;
   }
 };
 
 // When possible, pass optional state variable to track various data across
 // multiple calls to LogMultiline.  Otherwise, pass NULL.
 void LogMultiline(LoggingSeverity level, const char* label, bool input,
                   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)

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: this can fit on the previous line

[hellner, 2012/01/11 19:16:58]

Done.

+#define LOG_CHECK_LEVEL_V(sev) \
+  VLOG_IS_ON(sev)

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: this can fit on the previous line

[hellner, 2012/01/11 19:16:58]

Done.

 
-// 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)

[Sergey Ulanov, 2012/01/11 02:25:49]

same here

[hellner, 2012/01/11 19:16:58]

Done.

+#undef LOG
 #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()
+  LOG_V(talk_base::sev)

[Sergey Ulanov, 2012/01/11 02:25:49]

same here

[hellner, 2012/01/11 19:16:58]

Done.

 
 // The _F version prefixes the message with the current function name.
 #if defined(__GNUC__) && defined(_DEBUG)
 #define LOG_F(sev) LOG(sev) << __PRETTY_FUNCTION__ << ": "
 #else
 #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) \

[Sergey Ulanov, 2012/01/11 02:25:49]

As far as I can see, this is used in only one place in logging.cc. Do we need
it?

[hellner, 2012/01/11 19:16:58]

We don't need it since I can just expand the macro in the one place it is used.
However, I think it makes the code easier to understand since it corresponds
directly to VLOG.

I have put it in logging.cc since it isn't needed anywhere else. Please let me
know if this is OK.

+  LAZY_STREAM(logging::LogMessage(file_name, line_number, \
+                                  -sev).stream(), \
+              true)

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: this can feet on the previous line

[hellner, 2012/01/11 19:16:58]

Done.

+
+#define LOG_SEVERITY_PRECONDITION(sev) \
+  !(LOG_CHECK_LEVEL_V(sev)) \
+    ? (void) 0 \

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: operators should not be wrapped, ? must be on the previous line.

[hellner, 2012/01/11 19:16:58]

Totally agree. Done.

+    : talk_base::LogMessageVoidify() &

[Sergey Ulanov, 2012/01/11 02:25:49]

move : to the previos line

[Sergey Ulanov, 2012/01/11 02:25:49]

It's better to wrap this expression in parentheses, even if it is not in
libjingle version.

[hellner, 2012/01/11 19:16:58]

Done.

[hellner, 2012/01/11 19:16:58]

I'm not sure I understand what you mean here can you please elaborate?

[Sergey Ulanov, 2012/01/11 19:54:48]

I was suggesting to write it as follows, notice () around ?: 
#define LOG_SEVERITY_PRECONDITION(sev) \
   (!(LOG_CHECK_LEVEL_V(sev)) ? (void) 0 : talk_base::LogMessageVoidify()) &

But now I see that's not the desired order of operations. I must say that it's
too obscure. I believe that it would be better to make the right part of the &
operator a parameter of this macro. Take a look at src/base/logging.h - it
contains LAZY_STREAM() macro which is analogous to this one. Can we similarly
add stream parameter here? Or we could just reuse LAZY_STREAM() macro here.

[hellner, 2012/01/11 23:53:31]

Good idea.

Done.

 
 #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()

[Sergey Ulanov, 2012/01/11 02:25:49]

How does this work? GenerateExtra accepts no more than three arguments, so this
code will compile only when __VA_ARGS__ contains only one argument. If
__VA_ARGS__ always contains only one argument than why we need to use ... at
all?

[hellner, 2012/01/11 19:16:58]

I believe it's because macros don't support default parameters.

The only parameter that may or may not be passed when calling LOG_E is the very
last one. I was able to remove the default parameters in LogEHelper for all but
the last argument which seems to indicate that my assumption may be correct.

[Sergey Ulanov, 2012/01/11 19:54:48]

Ah, I see it now. The tricky part is that __VA_ARGS__ removes the preceding
comma when written with ##. But we always specify first two parameters for
GenerateExtra(). Do they need to have default values.

[hellner, 2012/01/11 23:53:31]

GenerateExtra no longer has any default parameters. The default parameters were
moved to the constructor of LogEHelper when GenerateExtra was moved to the .cc
file. Only the last argument needs to have a default parameter.

 
-#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)
 
 #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
 
+#undef PLOG
 #define PLOG(sev, err) \
   LOG_ERR_EX(sev, err)
 
 // TODO(?): Add an "assert" wrapper that logs in the same manner.

[Sergey Ulanov, 2012/01/11 02:25:49]

nit: remove this TODO

[hellner, 2012/01/11 19:16:58]

Done.

 
-#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_