forked from classilla/tenfourfox
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathLogging.h
More file actions
168 lines (140 loc) · 4.61 KB
/
Copy pathLogging.h
File metadata and controls
168 lines (140 loc) · 4.61 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_logging_h
#define mozilla_logging_h
#include "prlog.h"
#include "mozilla/Assertions.h"
#include "mozilla/Atomics.h"
#include "mozilla/Likely.h"
// This file is a placeholder for a replacement to the NSPR logging framework
// that is defined in prlog.h. Currently it is just a pass through, but as
// work progresses more functionality will be swapped out in favor of
// mozilla logging implementations.
namespace mozilla {
// While not a 100% mapping to PR_LOG's numeric values, mozilla::LogLevel does
// maintain a direct mapping for the Disabled, Debug and Verbose levels.
//
// Mappings of LogLevel to PR_LOG's numeric values:
//
// +---------+------------------+-----------------+
// | Numeric | NSPR Logging | Mozilla Logging |
// +---------+------------------+-----------------+
// | 0 | PR_LOG_NONE | Disabled |
// | 1 | PR_LOG_ALWAYS | Error |
// | 2 | PR_LOG_ERROR | Warning |
// | 3 | PR_LOG_WARNING | Info |
// | 4 | PR_LOG_DEBUG | Debug |
// | 5 | PR_LOG_DEBUG + 1 | Verbose |
// +---------+------------------+-----------------+
//
enum class LogLevel {
Disabled = 0,
Error,
Warning,
Info,
Debug,
Verbose,
};
class LogModule
{
public:
/**
* Retrieves the module with the given name. If it does not already exist
* it will be created.
*
* @param aName The name of the module.
* @return A log module for the given name. This may be shared.
*/
#if !defined(MOZILLA_XPCOMRT_API)
static LogModule* Get(const char* aName);
#else
// For simplicity, libxpcomrt doesn't supoort logging.
static LogModule* Get(const char* aName) { return nullptr; }
#endif
static void Init();
/**
* Indicates whether or not the given log level is enabled.
*/
bool ShouldLog(LogLevel aLevel) const { return mLevel >= aLevel; }
/**
* Retrieves the log module's current level.
*/
LogLevel Level() const { return mLevel; }
private:
friend class LogModuleManager;
explicit LogModule(LogLevel aLevel) : mLevel(aLevel) {}
LogModule(LogModule&) = delete;
LogModule& operator=(const LogModule&) = delete;
Atomic<LogLevel, Relaxed> mLevel;
};
/**
* Helper class that lazy loads the given log module. This is safe to use for
* declaring static references to log modules and can be used as a replacement
* for accessing a LogModule directly.
*
* Example usage:
* static LazyLogModule sLayoutLog("layout");
*
* void Foo() {
* MOZ_LOG(sLayoutLog, LogLevel::Verbose, ("Entering foo"));
* }
*/
class LazyLogModule final
{
public:
explicit MOZ_CONSTEXPR LazyLogModule(const char* aLogName)
: mLogName(aLogName)
, mLog(nullptr)
{
}
operator LogModule*()
{
// NB: The use of an atomic makes the reading and assignment of mLog
// thread-safe. There is a small chance that mLog will be set more
// than once, but that's okay as it will be set to the same LogModule
// instance each time. Also note LogModule::Get is thread-safe.
LogModule* tmp = mLog;
if (MOZ_UNLIKELY(!tmp)) {
tmp = LogModule::Get(mLogName);
mLog = tmp;
}
return tmp;
}
private:
const char* const mLogName;
Atomic<LogModule*, ReleaseAcquire> mLog;
};
namespace detail {
inline bool log_test(const PRLogModuleInfo* module, LogLevel level) {
MOZ_ASSERT(level != LogLevel::Disabled);
return module && module->level >= static_cast<int>(level);
}
inline bool log_test(const LogModule* module, LogLevel level) {
MOZ_ASSERT(level != LogLevel::Disabled);
return module && module->ShouldLog(level);
}
} // namespace detail
} // namespace mozilla
#define MOZ_LOG_TEST(_module,_level) mozilla::detail::log_test(_module, _level)
#define MOZ_LOG(_module,_level,_args) \
PR_BEGIN_MACRO \
if (MOZ_LOG_TEST(_module,_level)) { \
PR_LogPrint _args; \
} \
PR_END_MACRO
#undef PR_LOG
#undef PR_LOG_TEST
/*
* __func__ was standardized in C++11 and is supported by clang, gcc, and MSVC
* 2015. Here we polyfill __func__ for earlier versions of MSVC.
* http://blogs.msdn.com/b/vcblog/archive/2015/06/19/c-11-14-17-features-in-vs-2015-rtm.aspx
*/
#ifdef _MSC_VER
# if _MSC_VER < 1900
# define __func__ __FUNCTION__
# endif
#endif
#endif // mozilla_logging_h