Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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 DecoderDoctorLogger_h_
#define DecoderDoctorLogger_h_
#include "DDLoggedTypeTraits.h"
#include "DDLogCategory.h"
#include "DDLogValue.h"
#include "mozilla/Atomics.h"
#include "mozilla/DefineEnum.h"
#include "mozilla/MozPromise.h"
#include "mozilla/NonDereferenceable.h"
#include "nsString.h"
namespace mozilla {
// Main class used to capture log messages from the media stack, and to
// retrieve processed messages associated with an HTMLMediaElement.
//
// The logging APIs are designed to work as fast as possible (in most cases
// only checking a couple of atomic variables, and not allocating memory), so
// as not to introduce perceptible latency.
// Consider using DDLOG...() macros, and IsDDLoggingEnabled(), to avoid any
// unneeded work when logging is not enabled.
//
// Structural logging messages are used to determine when objects are created
// and destroyed, and to link objects that depend on each other, ultimately
// tying groups of objects and their messages to HTMLMediaElement objects.
//
// A separate thread processes log messages, and can asynchronously retrieve
// processed messages that correspond to a given HTMLMediaElement.
// That thread is also responsible for removing dated messages, so as not to
// take too much memory.
class DecoderDoctorLogger {
public:
// Called by nsLayoutStatics::Initialize() before any other media work.
// Pre-enables logging if MOZ_LOG requires DDLogger.
static void Init();
// Is logging currently enabled? This is tested anyway in all public `Log...`
// functions, but it may be used to prevent logging-only work in clients.
static inline bool IsDDLoggingEnabled() {
return MOZ_UNLIKELY(static_cast<LogState>(sLogState) == scEnabled);
}
// Shutdown logging. This will prevent more messages to be queued, but the
// already-queued messages may still get processed.
static void ShutdownLogging() { sLogState = scShutdown; }
// Something went horribly wrong, stop all logging and log processing.
static void Panic(const char* aReason) {
PanicInternal(aReason, /* aDontBlock */ false);
}
// Logging functions.
//
// All logging functions take:
// - The object that produces the message, either as a template type (for
// which a specialized DDLoggedTypeTraits exists), or a pointer and a type
// name (needed for inner classes that cannot specialize
// DDLoggedTypeTraits.)
// - A DDLogCategory defining the type of log message; some are used
// internally for capture the lifetime and linking of C++ objects, others
// are used to split messages into different domains.
// - A label (string literal).
// - An optional Variant value, see DDLogValue for the accepted types.
//
// The following `EagerLog...` functions always cause their arguments to be
// pre-evaluated even if logging is disabled, in which case runtime could be
// wasted. Consider using `DDLOG...` macros instead, or test
// `IsDDLoggingEnabled()` first.
template <typename Value>
static void EagerLogValue(const char* aSubjectTypeName,
const void* aSubjectPointer,
DDLogCategory aCategory, const char* aLabel,
Value&& aValue) {
Log(aSubjectTypeName, aSubjectPointer, aCategory, aLabel,
DDLogValue{std::forward<Value>(aValue)});
}
template <typename Subject, typename Value>
static void EagerLogValue(const Subject* aSubject, DDLogCategory aCategory,
const char* aLabel, Value&& aValue) {
EagerLogValue(DDLoggedTypeTraits<Subject>::Name(), aSubject, aCategory,
aLabel, std::forward<Value>(aValue));
}
// EagerLogValue that can explicitly take strings, as the templated function
// above confuses Variant when forwarding string literals.
static void EagerLogValue(const char* aSubjectTypeName,
const void* aSubjectPointer,
DDLogCategory aCategory, const char* aLabel,
const char* aValue) {
Log(aSubjectTypeName, aSubjectPointer, aCategory, aLabel,
DDLogValue{aValue});
}
template <typename Subject>
static void EagerLogValue(const Subject* aSubject, DDLogCategory aCategory,
const char* aLabel, const char* aValue) {
EagerLogValue(DDLoggedTypeTraits<Subject>::Name(), aSubject, aCategory,
aLabel, aValue);
}
static void EagerLogPrintf(const char* aSubjectTypeName,
const void* aSubjectPointer,
DDLogCategory aCategory, const char* aLabel,
const char* aString) {
Log(aSubjectTypeName, aSubjectPointer, aCategory, aLabel,
DDLogValue{nsCString{aString}});
}
template <typename... Args>
static void EagerLogPrintf(const char* aSubjectTypeName,
const void* aSubjectPointer,
DDLogCategory aCategory, const char* aLabel,
const char* aFormat, Args&&... aArgs) {
Log(aSubjectTypeName, aSubjectPointer, aCategory, aLabel,
DDLogValue{
nsCString{nsPrintfCString(aFormat, std::forward<Args>(aArgs)...)}});
}
template <typename Subject>
static void EagerLogPrintf(const Subject* aSubject, DDLogCategory aCategory,
const char* aLabel, const char* aString) {
EagerLogPrintf(DDLoggedTypeTraits<Subject>::Name(), aSubject, aCategory,
aLabel, aString);
}
template <typename Subject, typename... Args>
static void EagerLogPrintf(const Subject* aSubject, DDLogCategory aCategory,
const char* aLabel, const char* aFormat,
Args&&... aArgs) {
EagerLogPrintf(DDLoggedTypeTraits<Subject>::Name(), aSubject, aCategory,
aLabel, aFormat, std::forward<Args>(aArgs)...);
}
static void MozLogPrintf(const char* aSubjectTypeName,
const void* aSubjectPointer,
const LogModule* aLogModule, LogLevel aLogLevel,
const char* aString) {
Log(aSubjectTypeName, aSubjectPointer, CategoryForMozLogLevel(aLogLevel),
aLogModule->Name(), // LogModule name as label.
DDLogValue{nsCString{aString}});
MOZ_LOG(aLogModule, aLogLevel,
("%s[%p] %s", aSubjectTypeName, aSubjectPointer, aString));
}
template <typename... Args>
static void MozLogPrintf(const char* aSubjectTypeName,
const void* aSubjectPointer,
const LogModule* aLogModule, LogLevel aLogLevel,
const char* aFormat, Args&&... aArgs) {
nsCString printed = nsPrintfCString(aFormat, std::forward<Args>(aArgs)...);
Log(aSubjectTypeName, aSubjectPointer, CategoryForMozLogLevel(aLogLevel),
aLogModule->Name(), // LogModule name as label.
DDLogValue{printed});
MOZ_LOG(aLogModule, aLogLevel,
("%s[%p] %s", aSubjectTypeName, aSubjectPointer, printed.get()));
}
template <typename Subject>
static void MozLogPrintf(const Subject* aSubject, const LogModule* aLogModule,
LogLevel aLogLevel, const char* aString) {
MozLogPrintf(DDLoggedTypeTraits<Subject>::Name(), aSubject, aLogModule,
aLogLevel, aString);
}
template <typename Subject, typename... Args>
static void MozLogPrintf(const Subject* aSubject, const LogModule* aLogModule,
LogLevel aLogLevel, const char* aFormat,
Args&&... aArgs) {
MozLogPrintf(DDLoggedTypeTraits<Subject>::Name(), aSubject, aLogModule,
aLogLevel, aFormat, std::forward<Args>(aArgs)...);
}
// Special logging functions. Consider using DecoderDoctorLifeLogger to
// automatically capture constructions & destructions.
static void LogConstruction(const char* aSubjectTypeName,
const void* aSubjectPointer) {
Log(aSubjectTypeName, aSubjectPointer, DDLogCategory::_Construction, "",
DDLogValue{DDNoValue{}});
}
static void LogConstructionAndBase(const char* aSubjectTypeName,
const void* aSubjectPointer,
const char* aBaseTypeName,
const void* aBasePointer) {
Log(aSubjectTypeName, aSubjectPointer, DDLogCategory::_DerivedConstruction,
"", DDLogValue{DDLogObject{aBaseTypeName, aBasePointer}});
}
template <typename B>
static void LogConstructionAndBase(const char* aSubjectTypeName,
const void* aSubjectPointer,
const B* aBase) {
Log(aSubjectTypeName, aSubjectPointer, DDLogCategory::_DerivedConstruction,
"", DDLogValue{DDLogObject{DDLoggedTypeTraits<B>::Name(), aBase}});
}
template <typename Subject>
static void LogConstruction(NonDereferenceable<const Subject> aSubject) {
using Traits = DDLoggedTypeTraits<Subject>;
if (!Traits::HasBase::value) {
Log(DDLoggedTypeTraits<Subject>::Name(),
reinterpret_cast<const void*>(aSubject.value()),
DDLogCategory::_Construction, "", DDLogValue{DDNoValue{}});
} else {
Log(DDLoggedTypeTraits<Subject>::Name(),
reinterpret_cast<const void*>(aSubject.value()),
DDLogCategory::_DerivedConstruction, "",
DDLogValue{DDLogObject{
DDLoggedTypeTraits<typename Traits::BaseType>::Name(),
reinterpret_cast<const void*>(
NonDereferenceable<const typename Traits::BaseType>(aSubject)
.value())}});
}
}
template <typename Subject>
static void LogConstruction(const Subject* aSubject) {
LogConstruction(NonDereferenceable<const Subject>(aSubject));
}
static void LogDestruction(const char* aSubjectTypeName,
const void* aSubjectPointer) {
Log(aSubjectTypeName, aSubjectPointer, DDLogCategory::_Destruction, "",
DDLogValue{DDNoValue{}});
}
template <typename Subject>
static void LogDestruction(NonDereferenceable<const Subject> aSubject) {
Log(DDLoggedTypeTraits<Subject>::Name(),
reinterpret_cast<const void*>(aSubject.value()),
DDLogCategory::_Destruction, "", DDLogValue{DDNoValue{}});
}
template <typename Subject>
static void LogDestruction(const Subject* aSubject) {
LogDestruction(NonDereferenceable<const Subject>(aSubject));
}
template <typename P, typename C>
static void LinkParentAndChild(const P* aParent, const char* aLinkName,
const C* aChild) {
if (aChild) {
Log(DDLoggedTypeTraits<P>::Name(), aParent, DDLogCategory::_Link,
aLinkName,
DDLogValue{DDLogObject{DDLoggedTypeTraits<C>::Name(), aChild}});
}
}
template <typename C>
static void LinkParentAndChild(const char* aParentTypeName,
const void* aParentPointer,
const char* aLinkName, const C* aChild) {
if (aChild) {
Log(aParentTypeName, aParentPointer, DDLogCategory::_Link, aLinkName,
DDLogValue{DDLogObject{DDLoggedTypeTraits<C>::Name(), aChild}});
}
}
template <typename P>
static void LinkParentAndChild(const P* aParent, const char* aLinkName,
const char* aChildTypeName,
const void* aChildPointer) {
if (aChildPointer) {
Log(DDLoggedTypeTraits<P>::Name(), aParent, DDLogCategory::_Link,
aLinkName, DDLogValue{DDLogObject{aChildTypeName, aChildPointer}});
}
}
template <typename C>
static void UnlinkParentAndChild(const char* aParentTypeName,
const void* aParentPointer,
const C* aChild) {
if (aChild) {
Log(aParentTypeName, aParentPointer, DDLogCategory::_Unlink, "",
DDLogValue{DDLogObject{DDLoggedTypeTraits<C>::Name(), aChild}});
}
}
template <typename P, typename C>
static void UnlinkParentAndChild(const P* aParent, const C* aChild) {
if (aChild) {
Log(DDLoggedTypeTraits<P>::Name(), aParent, DDLogCategory::_Unlink, "",
DDLogValue{DDLogObject{DDLoggedTypeTraits<C>::Name(), aChild}});
}
}
// Retrieval functions.
// Enable logging, if not done already. No effect otherwise.
static void EnableLogging();
using LogMessagesPromise =
MozPromise<nsCString, nsresult, /* IsExclusive = */ true>;
// Retrieve all messages related to a given HTMLMediaElement object.
// This call will trigger a processing run (to ensure the most recent data
// will be returned), and the returned promise will be resolved with all
// relevant log messages and object lifetimes in a JSON string.
// The first call will enable logging, until shutdown.
static RefPtr<LogMessagesPromise> RetrieveMessages(
const dom::HTMLMediaElement* aMediaElement);
private:
// If logging is not enabled yet, initiate it, return true.
// If logging has been shutdown, don't start it, return false.
// Otherwise return true.
static bool EnsureLogIsEnabled();
// Note that this call may block while the state is scEnabling;
// set aDontBlock to true to avoid blocking, most importantly when the
// caller is the one doing the enabling, this would cause an endless loop.
static void PanicInternal(const char* aReason, bool aDontBlock);
static void Log(const char* aSubjectTypeName, const void* aSubjectPointer,
DDLogCategory aCategory, const char* aLabel,
DDLogValue&& aValue);
static void Log(const char* aSubjectTypeName, const void* aSubjectPointer,
const LogModule* aLogModule, LogLevel aLogLevel,
DDLogValue&& aValue);
static DDLogCategory CategoryForMozLogLevel(LogLevel aLevel) {
switch (aLevel) {
default:
case LogLevel::Error:
return DDLogCategory::MozLogError;
case LogLevel::Warning:
return DDLogCategory::MozLogWarning;
case LogLevel::Info:
return DDLogCategory::MozLogInfo;
case LogLevel::Debug:
return DDLogCategory::MozLogDebug;
case LogLevel::Verbose:
return DDLogCategory::MozLogVerbose;
}
}
using LogState = int;
// Currently disabled, may be enabled on request.
static constexpr LogState scDisabled = 0;
// Currently enabled (logging happens), may be shutdown.
static constexpr LogState scEnabled = 1;
// Still disabled, but one thread is working on enabling it, nobody else
// should interfere during this time.
static constexpr LogState scEnabling = 2;
// Shutdown, cannot be re-enabled.
static constexpr LogState scShutdown = 3;
// Current state.
// "ReleaseAcquire" because when changing to scEnabled, the just-created
// sMediaLogs must be accessible to consumers that see scEnabled.
static Atomic<LogState, ReleaseAcquire> sLogState;
// If non-null, reason for an abnormal shutdown.
static const char* sShutdownReason;
};
// Base class to automatically record a class lifetime. Usage:
// class SomeClass : public DecoderDoctorLifeLogger<SomeClass>
// {
// ...
template <typename T>
class DecoderDoctorLifeLogger {
protected:
DecoderDoctorLifeLogger() {
DecoderDoctorLogger::LogConstruction(NonDereferenceable<const T>(this));
}
~DecoderDoctorLifeLogger() {
DecoderDoctorLogger::LogDestruction(NonDereferenceable<const T>(this));
}
};
// Macros to help lazily-evaluate arguments, only after we have checked that
// logging is enabled.
// Log a single value; see DDLogValue for allowed types.
#define DDLOG(_category, _label, _arg) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DecoderDoctorLogger::EagerLogValue(this, _category, _label, _arg); \
} \
} while (0)
// Log a single value, with an EXplicit `this`.
#define DDLOGEX(_this, _category, _label, _arg) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DecoderDoctorLogger::EagerLogValue(_this, _category, _label, _arg); \
} \
} while (0)
// Log a single value, with EXplicit type name and `this`.
#define DDLOGEX2(_typename, _this, _category, _label, _arg) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DecoderDoctorLogger::EagerLogValue(_typename, _this, _category, _label, \
_arg); \
} \
} while (0)
#ifdef DEBUG
// Do a printf format check in DEBUG, with the downside that side-effects (from
// evaluating the arguments) may happen twice! Who would do that anyway?
static void inline MOZ_FORMAT_PRINTF(1, 2) DDLOGPRCheck(const char*, ...) {}
# define DDLOGPR_CHECK(_fmt, ...) DDLOGPRCheck(_fmt, ##__VA_ARGS__)
#else
# define DDLOGPR_CHECK(_fmt, ...)
#endif
// Log a printf'd string. Discouraged, please try using DDLOG instead.
#define DDLOGPR(_category, _label, _format, ...) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DDLOGPR_CHECK(_format, ##__VA_ARGS__); \
DecoderDoctorLogger::EagerLogPrintf(this, _category, _label, _format, \
##__VA_ARGS__); \
} \
} while (0)
// Link a child object.
#define DDLINKCHILD(...) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DecoderDoctorLogger::LinkParentAndChild(this, __VA_ARGS__); \
} \
} while (0)
// Unlink a child object.
#define DDUNLINKCHILD(...) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DecoderDoctorLogger::UnlinkParentAndChild(this, __VA_ARGS__); \
} \
} while (0)
// Log a printf'd string to DDLogger and/or MOZ_LOG, with an EXplicit `this`.
// Don't even call MOZ_LOG on Android non-release/beta; See Logging.h.
#if !defined(ANDROID) || !defined(RELEASE_OR_BETA)
# define DDMOZ_LOGEX(_this, _logModule, _logLevel, _format, ...) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled() || \
MOZ_LOG_TEST(_logModule, _logLevel)) { \
DDLOGPR_CHECK(_format, ##__VA_ARGS__); \
DecoderDoctorLogger::MozLogPrintf(_this, _logModule, _logLevel, \
_format, ##__VA_ARGS__); \
} \
} while (0)
#else
# define DDMOZ_LOGEX(_this, _logModule, _logLevel, _format, ...) \
do { \
if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \
DDLOGPR_CHECK(_format, ##__VA_ARGS__); \
DecoderDoctorLogger::MozLogPrintf(_this, _logModule, _logLevel, \
_format, ##__VA_ARGS__); \
} \
} while (0)
#endif
// Log a printf'd string to DDLogger and/or MOZ_LOG.
#define DDMOZ_LOG(_logModule, _logLevel, _format, ...) \
DDMOZ_LOGEX(this, _logModule, _logLevel, _format, ##__VA_ARGS__)
} // namespace mozilla
#endif // DecoderDoctorLogger_h_