summaryrefslogtreecommitdiffstats
path: root/gfx/2d/Logging.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/2d/Logging.h')
-rw-r--r--gfx/2d/Logging.h965
1 files changed, 965 insertions, 0 deletions
diff --git a/gfx/2d/Logging.h b/gfx/2d/Logging.h
new file mode 100644
index 0000000000..5aa0a954dc
--- /dev/null
+++ b/gfx/2d/Logging.h
@@ -0,0 +1,965 @@
+/* -*- 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_GFX_LOGGING_H_
+#define MOZILLA_GFX_LOGGING_H_
+
+#include <string>
+#include <sstream>
+#include <stdio.h>
+#include <vector>
+
+#ifdef MOZ_LOGGING
+# include "mozilla/Logging.h"
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID)
+# include "nsDebug.h"
+#endif
+#include "2D.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "Point.h"
+#include "BaseRect.h"
+#include "Matrix.h"
+#include "LoggingConstants.h"
+
+#if defined(MOZ_LOGGING)
+extern GFX2D_API mozilla::LogModule* GetGFX2DLog();
+#endif
+
+namespace mozilla {
+namespace gfx {
+
+#if defined(MOZ_LOGGING)
+inline mozilla::LogLevel PRLogLevelForLevel(int aLevel) {
+ switch (aLevel) {
+ case LOG_CRITICAL:
+ return LogLevel::Error;
+ case LOG_WARNING:
+ return LogLevel::Warning;
+ case LOG_DEBUG:
+ return LogLevel::Debug;
+ case LOG_DEBUG_PRLOG:
+ return LogLevel::Debug;
+ case LOG_EVERYTHING:
+ return LogLevel::Error;
+ }
+ return LogLevel::Debug;
+}
+#endif
+
+/// Graphics logging is available in both debug and release builds and is
+/// controlled with a gfx.logging.level preference. If not set, the default
+/// for the preference is 5 in the debug builds, 1 in the release builds.
+///
+/// gfxDebug only works in the debug builds, and is used for information
+/// level messages, helping with debugging. In addition to only working
+/// in the debug builds, the value of the above preference of 3 or higher
+/// is required.
+///
+/// gfxWarning messages are available in both debug and release builds,
+/// on by default in the debug builds, and off by default in the release builds.
+/// Setting the preference gfx.logging.level to a value of 2 or higher will
+/// show the warnings.
+///
+/// gfxCriticalError is available in debug and release builds by default.
+/// It is only unavailable if gfx.logging.level is set to 0 (or less.)
+/// It outputs the message to stderr or equivalent, like gfxWarning.
+/// In the event of a crash, the crash report is annotated with first and
+/// the last few of these errors, under the key GraphicsCriticalError.
+/// The total number of errors stored in the crash report is controlled
+/// by preference gfx.logging.crash.length.
+///
+/// On platforms that support MOZ_LOGGING, the story is slightly more involved.
+/// In that case, unless gfx.logging.level is set to 4 or higher, the output
+/// is further controlled by the "gfx2d" logging module. However, in the case
+/// where such module would disable the output, in all but gfxDebug cases,
+/// we will still send a printf.
+
+// The range is due to the values set in Histograms.json
+enum class LogReason : int {
+ MustBeMoreThanThis = -1,
+ // Start. Do not insert, always add at end. If you remove items,
+ // make sure the other items retain their values.
+ D3D11InvalidCallDeviceRemoved = 0,
+ D3D11InvalidCall,
+ D3DLockTimeout,
+ D3D10FinalizeFrame,
+ D3D11FinalizeFrame,
+ D3D10SyncLock,
+ D3D11SyncLock,
+ D2D1NoWriteMap,
+ JobStatusError,
+ FilterInputError,
+ FilterInputData, // 10
+ FilterInputRect,
+ FilterInputSet,
+ FilterInputFormat,
+ FilterNodeD2D1Target,
+ FilterNodeD2D1Backend,
+ SourceSurfaceIncompatible,
+ GlyphAllocFailedCairo,
+ GlyphAllocFailedCG,
+ InvalidRect,
+ CannotDraw3D, // 20
+ IncompatibleBasicTexturedEffect,
+ InvalidFont,
+ PAllocTextureBackendMismatch,
+ GetFontFileDataFailed,
+ MessageChannelCloseFailure,
+ MessageChannelInvalidHandle,
+ TextureAliveAfterShutdown,
+ InvalidContext,
+ InvalidCommandList,
+ AsyncTransactionTimeout, // 30
+ TextureCreation,
+ InvalidCacheSurface,
+ AlphaWithBasicClient,
+ UnbalancedClipStack,
+ ProcessingError,
+ InvalidDrawTarget,
+ NativeFontResourceNotFound,
+ UnscaledFontNotFound,
+ ScaledFontNotFound,
+ InvalidLayerType, // 40
+ // End
+ MustBeLessThanThis = 101,
+};
+
+struct BasicLogger {
+ // For efficiency, this method exists and copies the logic of the
+ // OutputMessage below. If making any changes here, also make it
+ // in the appropriate places in that method.
+ static bool ShouldOutputMessage(int aLevel) {
+ if (StaticPrefs::gfx_logging_level() >= aLevel) {
+#if defined(MOZ_WIDGET_ANDROID)
+ return true;
+#else
+# if defined(MOZ_LOGGING)
+ if (MOZ_LOG_TEST(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) {
+ return true;
+ } else
+# endif
+ if ((StaticPrefs::gfx_logging_level() >= LOG_DEBUG_PRLOG) ||
+ (aLevel < LOG_DEBUG)) {
+ return true;
+ }
+#endif
+ }
+ return false;
+ }
+
+ // Only for really critical errors.
+ static void CrashAction(LogReason aReason) {}
+
+ static void OutputMessage(const std::string& aString, int aLevel,
+ bool aNoNewline) {
+ // This behavior (the higher the preference, the more we log)
+ // is consistent with what prlog does in general. Note that if prlog
+ // is in the build, but disabled, we will printf if the preferences
+ // requires us to log something.
+ //
+ // If making any logic changes to this method, you should probably
+ // make the corresponding change in the ShouldOutputMessage method
+ // above.
+ if (StaticPrefs::gfx_logging_level() >= aLevel) {
+#if defined(MOZ_WIDGET_ANDROID)
+ printf_stderr("%s%s", aString.c_str(), aNoNewline ? "" : "\n");
+#else
+# if defined(MOZ_LOGGING)
+ if (MOZ_LOG_TEST(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) {
+ MOZ_LOG(GetGFX2DLog(), PRLogLevelForLevel(aLevel),
+ ("%s%s", aString.c_str(), aNoNewline ? "" : "\n"));
+ } else
+# endif
+ if ((StaticPrefs::gfx_logging_level() >= LOG_DEBUG_PRLOG) ||
+ (aLevel < LOG_DEBUG)) {
+ printf("%s%s", aString.c_str(), aNoNewline ? "" : "\n");
+ }
+#endif
+ }
+ }
+};
+
+struct CriticalLogger {
+ static void OutputMessage(const std::string& aString, int aLevel,
+ bool aNoNewline);
+ static void CrashAction(LogReason aReason);
+};
+
+// The int is the index of the Log call; if the number of logs exceeds some
+// preset capacity we may not get all of them, so the indices help figure out
+// which ones we did save. The double is expected to be the "TimeDuration",
+// time in seconds since the process creation.
+typedef std::tuple<int32_t, std::string, double> LoggingRecordEntry;
+
+// Implement this interface and init the Factory with an instance to
+// forward critical logs.
+typedef std::vector<LoggingRecordEntry> LoggingRecord;
+class LogForwarder {
+ public:
+ virtual ~LogForwarder() = default;
+ virtual void Log(const std::string& aString) = 0;
+ virtual void CrashAction(LogReason aReason) = 0;
+ virtual bool UpdateStringsVector(const std::string& aString) = 0;
+
+ // Provide a copy of the logs to the caller.
+ virtual LoggingRecord LoggingRecordCopy() = 0;
+};
+
+class NoLog {
+ public:
+ NoLog() = default;
+ ~NoLog() = default;
+
+ // No-op
+ MOZ_IMPLICIT NoLog(const NoLog&) = default;
+
+ template <typename T>
+ NoLog& operator<<(const T& aLogText) {
+ return *this;
+ }
+};
+
+enum class LogOptions : int {
+ NoNewline = 0x01,
+ AutoPrefix = 0x02,
+ AssertOnCall = 0x04,
+ CrashAction = 0x08,
+};
+
+template <typename T>
+struct Hexa {
+ explicit Hexa(T aVal) : mVal(aVal) {}
+ T mVal;
+};
+template <typename T>
+Hexa<T> hexa(T val) {
+ return Hexa<T>(val);
+}
+
+#ifdef WIN32
+void LogWStr(const wchar_t* aStr, std::stringstream& aOut);
+#endif
+
+template <int L, typename Logger = BasicLogger>
+class Log final {
+ public:
+ // The default is to have the prefix, have the new line, and for critical
+ // logs assert on each call.
+ static int DefaultOptions(bool aWithAssert = true) {
+ return (int(LogOptions::AutoPrefix) |
+ (aWithAssert ? int(LogOptions::AssertOnCall) : 0));
+ }
+
+ // Note that we're calling BasicLogger::ShouldOutputMessage, rather than
+ // Logger::ShouldOutputMessage. Since we currently don't have a different
+ // version of that method for different loggers, this is OK. Once we do,
+ // change BasicLogger::ShouldOutputMessage to Logger::ShouldOutputMessage.
+ explicit Log(int aOptions = Log::DefaultOptions(L == LOG_CRITICAL),
+ LogReason aReason = LogReason::MustBeMoreThanThis)
+ : mOptions(0), mLogIt(false) {
+ Init(aOptions, BasicLogger::ShouldOutputMessage(L), aReason);
+ }
+
+ ~Log() { Flush(); }
+
+ void Flush() {
+ if (MOZ_LIKELY(!LogIt())) return;
+
+ std::string str = mMessage.str();
+ if (!str.empty()) {
+ WriteLog(str);
+ }
+ mMessage.str("");
+ }
+
+ Log& operator<<(char aChar) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aChar;
+ }
+ return *this;
+ }
+ Log& operator<<(const std::string& aLogText) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aLogText;
+ }
+ return *this;
+ }
+ Log& operator<<(const char aStr[]) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << static_cast<const char*>(aStr);
+ }
+ return *this;
+ }
+#ifdef WIN32
+ Log& operator<<(const wchar_t aWStr[]) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ LogWStr(aWStr, mMessage);
+ }
+ return *this;
+ }
+#endif
+ Log& operator<<(bool aBool) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << (aBool ? "true" : "false");
+ }
+ return *this;
+ }
+ Log& operator<<(int aInt) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aInt;
+ }
+ return *this;
+ }
+ Log& operator<<(unsigned int aInt) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aInt;
+ }
+ return *this;
+ }
+ Log& operator<<(long aLong) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aLong;
+ }
+ return *this;
+ }
+ Log& operator<<(unsigned long aLong) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aLong;
+ }
+ return *this;
+ }
+ Log& operator<<(long long aLong) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aLong;
+ }
+ return *this;
+ }
+ Log& operator<<(unsigned long long aLong) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aLong;
+ }
+ return *this;
+ }
+ Log& operator<<(Float aFloat) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aFloat;
+ }
+ return *this;
+ }
+ Log& operator<<(double aDouble) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << aDouble;
+ }
+ return *this;
+ }
+ Log& operator<<(const sRGBColor& aColor) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "sRGBColor(" << aColor.r << ", " << aColor.g << ", "
+ << aColor.b << ", " << aColor.a << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const DeviceColor& aColor) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "DeviceColor(" << aColor.r << ", " << aColor.g << ", "
+ << aColor.b << ", " << aColor.a << ")";
+ }
+ return *this;
+ }
+ template <typename T, typename Sub, typename Coord>
+ Log& operator<<(const BasePoint<T, Sub, Coord>& aPoint) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "Point" << aPoint;
+ }
+ return *this;
+ }
+ template <typename T, typename Sub>
+ Log& operator<<(const BaseSize<T, Sub>& aSize) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "Size(" << aSize.width << "," << aSize.height << ")";
+ }
+ return *this;
+ }
+ template <typename T, typename Sub, typename Point, typename SizeT,
+ typename Margin>
+ Log& operator<<(const BaseRect<T, Sub, Point, SizeT, Margin>& aRect) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "Rect" << aRect;
+ }
+ return *this;
+ }
+ Log& operator<<(const Matrix& aMatrix) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "Matrix(" << aMatrix._11 << " " << aMatrix._12 << " ; "
+ << aMatrix._21 << " " << aMatrix._22 << " ; " << aMatrix._31
+ << " " << aMatrix._32 << ")";
+ }
+ return *this;
+ }
+ template <typename T>
+ Log& operator<<(Hexa<T> aHex) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << std::showbase << std::hex << aHex.mVal << std::noshowbase
+ << std::dec;
+ }
+ return *this;
+ }
+
+ Log& operator<<(const SourceSurface* aSurface) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "SourceSurface(" << (void*)(aSurface) << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const Path* aPath) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "Path(" << (void*)(aPath) << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const Pattern* aPattern) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "Pattern(" << (void*)(aPattern) << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const ScaledFont* aFont) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "ScaledFont(" << (void*)(aFont) << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const FilterNode* aFilter) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "FilterNode(" << (void*)(aFilter) << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const DrawOptions& aOptions) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "DrawOptions(" << aOptions.mAlpha << ", ";
+ (*this) << aOptions.mCompositionOp;
+ mMessage << ", ";
+ (*this) << aOptions.mAntialiasMode;
+ mMessage << ")";
+ }
+ return *this;
+ }
+ Log& operator<<(const DrawSurfaceOptions& aOptions) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ mMessage << "DrawSurfaceOptions(";
+ (*this) << aOptions.mSamplingFilter;
+ mMessage << ", ";
+ (*this) << aOptions.mSamplingBounds;
+ mMessage << ")";
+ }
+ return *this;
+ }
+
+ Log& operator<<(SamplingBounds aBounds) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ switch (aBounds) {
+ case SamplingBounds::UNBOUNDED:
+ mMessage << "SamplingBounds::UNBOUNDED";
+ break;
+ case SamplingBounds::BOUNDED:
+ mMessage << "SamplingBounds::BOUNDED";
+ break;
+ default:
+ mMessage << "Invalid SamplingBounds (" << (int)aBounds << ")";
+ break;
+ }
+ }
+ return *this;
+ }
+ Log& operator<<(SamplingFilter aFilter) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ switch (aFilter) {
+ case SamplingFilter::GOOD:
+ mMessage << "SamplingFilter::GOOD";
+ break;
+ case SamplingFilter::LINEAR:
+ mMessage << "SamplingFilter::LINEAR";
+ break;
+ case SamplingFilter::POINT:
+ mMessage << "SamplingFilter::POINT";
+ break;
+ default:
+ mMessage << "Invalid SamplingFilter (" << (int)aFilter << ")";
+ break;
+ }
+ }
+ return *this;
+ }
+ Log& operator<<(AntialiasMode aMode) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ switch (aMode) {
+ case AntialiasMode::NONE:
+ mMessage << "AntialiasMode::NONE";
+ break;
+ case AntialiasMode::GRAY:
+ mMessage << "AntialiasMode::GRAY";
+ break;
+ case AntialiasMode::SUBPIXEL:
+ mMessage << "AntialiasMode::SUBPIXEL";
+ break;
+ case AntialiasMode::DEFAULT:
+ mMessage << "AntialiasMode::DEFAULT";
+ break;
+ default:
+ mMessage << "Invalid AntialiasMode (" << (int)aMode << ")";
+ break;
+ }
+ }
+ return *this;
+ }
+ Log& operator<<(CompositionOp aOp) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ switch (aOp) {
+ case CompositionOp::OP_CLEAR:
+ mMessage << "CompositionOp::OP_CLEAR";
+ break;
+ case CompositionOp::OP_OVER:
+ mMessage << "CompositionOp::OP_OVER";
+ break;
+ case CompositionOp::OP_ADD:
+ mMessage << "CompositionOp::OP_ADD";
+ break;
+ case CompositionOp::OP_ATOP:
+ mMessage << "CompositionOp::OP_ATOP";
+ break;
+ case CompositionOp::OP_OUT:
+ mMessage << "CompositionOp::OP_OUT";
+ break;
+ case CompositionOp::OP_IN:
+ mMessage << "CompositionOp::OP_IN";
+ break;
+ case CompositionOp::OP_SOURCE:
+ mMessage << "CompositionOp::OP_SOURCE";
+ break;
+ case CompositionOp::OP_DEST_IN:
+ mMessage << "CompositionOp::OP_DEST_IN";
+ break;
+ case CompositionOp::OP_DEST_OUT:
+ mMessage << "CompositionOp::OP_DEST_OUT";
+ break;
+ case CompositionOp::OP_DEST_OVER:
+ mMessage << "CompositionOp::OP_DEST_OVER";
+ break;
+ case CompositionOp::OP_DEST_ATOP:
+ mMessage << "CompositionOp::OP_DEST_ATOP";
+ break;
+ case CompositionOp::OP_XOR:
+ mMessage << "CompositionOp::OP_XOR";
+ break;
+ case CompositionOp::OP_MULTIPLY:
+ mMessage << "CompositionOp::OP_MULTIPLY";
+ break;
+ case CompositionOp::OP_SCREEN:
+ mMessage << "CompositionOp::OP_SCREEN";
+ break;
+ case CompositionOp::OP_OVERLAY:
+ mMessage << "CompositionOp::OP_OVERLAY";
+ break;
+ case CompositionOp::OP_DARKEN:
+ mMessage << "CompositionOp::OP_DARKEN";
+ break;
+ case CompositionOp::OP_LIGHTEN:
+ mMessage << "CompositionOp::OP_LIGHTEN";
+ break;
+ case CompositionOp::OP_COLOR_DODGE:
+ mMessage << "CompositionOp::OP_COLOR_DODGE";
+ break;
+ case CompositionOp::OP_COLOR_BURN:
+ mMessage << "CompositionOp::OP_COLOR_BURN";
+ break;
+ case CompositionOp::OP_HARD_LIGHT:
+ mMessage << "CompositionOp::OP_HARD_LIGHT";
+ break;
+ case CompositionOp::OP_SOFT_LIGHT:
+ mMessage << "CompositionOp::OP_SOFT_LIGHT";
+ break;
+ case CompositionOp::OP_DIFFERENCE:
+ mMessage << "CompositionOp::OP_DIFFERENCE";
+ break;
+ case CompositionOp::OP_EXCLUSION:
+ mMessage << "CompositionOp::OP_EXCLUSION";
+ break;
+ case CompositionOp::OP_HUE:
+ mMessage << "CompositionOp::OP_HUE";
+ break;
+ case CompositionOp::OP_SATURATION:
+ mMessage << "CompositionOp::OP_SATURATION";
+ break;
+ case CompositionOp::OP_COLOR:
+ mMessage << "CompositionOp::OP_COLOR";
+ break;
+ case CompositionOp::OP_LUMINOSITY:
+ mMessage << "CompositionOp::OP_LUMINOSITY";
+ break;
+ case CompositionOp::OP_COUNT:
+ mMessage << "CompositionOp::OP_COUNT";
+ break;
+ default:
+ mMessage << "Invalid CompositionOp (" << (int)aOp << ")";
+ break;
+ }
+ }
+ return *this;
+ }
+ Log& operator<<(SurfaceFormat aFormat) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ switch (aFormat) {
+ case SurfaceFormat::B8G8R8A8:
+ mMessage << "SurfaceFormat::B8G8R8A8";
+ break;
+ case SurfaceFormat::B8G8R8X8:
+ mMessage << "SurfaceFormat::B8G8R8X8";
+ break;
+ case SurfaceFormat::R8G8B8A8:
+ mMessage << "SurfaceFormat::R8G8B8A8";
+ break;
+ case SurfaceFormat::R8G8B8X8:
+ mMessage << "SurfaceFormat::R8G8B8X8";
+ break;
+ case SurfaceFormat::R5G6B5_UINT16:
+ mMessage << "SurfaceFormat::R5G6B5_UINT16";
+ break;
+ case SurfaceFormat::A8:
+ mMessage << "SurfaceFormat::A8";
+ break;
+ case SurfaceFormat::YUV:
+ mMessage << "SurfaceFormat::YUV";
+ break;
+ case SurfaceFormat::UNKNOWN:
+ mMessage << "SurfaceFormat::UNKNOWN";
+ break;
+ default:
+ mMessage << "Invalid SurfaceFormat (" << (int)aFormat << ")";
+ break;
+ }
+ }
+ return *this;
+ }
+
+ Log& operator<<(SurfaceType aType) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ switch (aType) {
+ case SurfaceType::DATA:
+ mMessage << "SurfaceType::DATA";
+ break;
+ case SurfaceType::D2D1_BITMAP:
+ mMessage << "SurfaceType::D2D1_BITMAP";
+ break;
+ case SurfaceType::D2D1_DRAWTARGET:
+ mMessage << "SurfaceType::D2D1_DRAWTARGET";
+ break;
+ case SurfaceType::CAIRO:
+ mMessage << "SurfaceType::CAIRO";
+ break;
+ case SurfaceType::CAIRO_IMAGE:
+ mMessage << "SurfaceType::CAIRO_IMAGE";
+ break;
+ case SurfaceType::COREGRAPHICS_IMAGE:
+ mMessage << "SurfaceType::COREGRAPHICS_IMAGE";
+ break;
+ case SurfaceType::COREGRAPHICS_CGCONTEXT:
+ mMessage << "SurfaceType::COREGRAPHICS_CGCONTEXT";
+ break;
+ case SurfaceType::SKIA:
+ mMessage << "SurfaceType::SKIA";
+ break;
+ case SurfaceType::D2D1_1_IMAGE:
+ mMessage << "SurfaceType::D2D1_1_IMAGE";
+ break;
+ case SurfaceType::RECORDING:
+ mMessage << "SurfaceType::RECORDING";
+ break;
+ case SurfaceType::DATA_SHARED:
+ mMessage << "SurfaceType::DATA_SHARED";
+ break;
+ case SurfaceType::DATA_RECYCLING_SHARED:
+ mMessage << "SurfaceType::DATA_RECYCLING_SHARED";
+ break;
+ case SurfaceType::DATA_ALIGNED:
+ mMessage << "SurfaceType::DATA_ALIGNED";
+ break;
+ case SurfaceType::DATA_SHARED_WRAPPER:
+ mMessage << "SurfaceType::DATA_SHARED_WRAPPER";
+ break;
+ case SurfaceType::DATA_MAPPED:
+ mMessage << "SurfaceType::DATA_MAPPED";
+ break;
+ case SurfaceType::WEBGL:
+ mMessage << "SurfaceType::WEBGL";
+ break;
+ default:
+ mMessage << "Invalid SurfaceType (" << (int)aType << ")";
+ break;
+ }
+ }
+ return *this;
+ }
+
+ inline bool LogIt() const { return mLogIt; }
+ inline bool NoNewline() const {
+ return mOptions & int(LogOptions::NoNewline);
+ }
+ inline bool AutoPrefix() const {
+ return mOptions & int(LogOptions::AutoPrefix);
+ }
+ inline bool ValidReason() const {
+ return (int)mReason > (int)LogReason::MustBeMoreThanThis &&
+ (int)mReason < (int)LogReason::MustBeLessThanThis;
+ }
+
+ // We do not want this version to do any work, and stringstream can't be
+ // copied anyway. It does come in handy for the "Once" macro defined below.
+ MOZ_IMPLICIT Log(const Log& log) { Init(log.mOptions, false, log.mReason); }
+
+ private:
+ // Initialization common to two constructors
+ void Init(int aOptions, bool aLogIt, LogReason aReason) {
+ mOptions = aOptions;
+ mReason = aReason;
+ mLogIt = aLogIt;
+ if (mLogIt) {
+ if (AutoPrefix()) {
+ if (mOptions & int(LogOptions::AssertOnCall)) {
+ mMessage << "[GFX" << L;
+ } else {
+ mMessage << "[GFX" << L << "-";
+ }
+ }
+ if ((mOptions & int(LogOptions::CrashAction)) && ValidReason()) {
+ mMessage << " " << (int)mReason;
+ }
+ if (AutoPrefix()) {
+ mMessage << "]: ";
+ }
+ }
+ }
+
+ void WriteLog(const std::string& aString) {
+ if (MOZ_UNLIKELY(LogIt())) {
+ Logger::OutputMessage(aString, L, NoNewline());
+ // Assert if required. We don't have a three parameter MOZ_ASSERT
+ // so use the underlying functions instead (see bug 1281702):
+#ifdef DEBUG
+ if (mOptions & int(LogOptions::AssertOnCall)) {
+ MOZ_ReportAssertionFailure(aString.c_str(), __FILE__, __LINE__);
+ MOZ_CRASH("GFX: An assert from the graphics logger");
+ }
+#endif
+ if ((mOptions & int(LogOptions::CrashAction)) && ValidReason()) {
+ Logger::CrashAction(mReason);
+ }
+ }
+ }
+
+ std::stringstream mMessage;
+ int mOptions;
+ LogReason mReason;
+ bool mLogIt;
+};
+
+typedef Log<LOG_DEBUG> DebugLog;
+typedef Log<LOG_WARNING> WarningLog;
+typedef Log<LOG_CRITICAL, CriticalLogger> CriticalLog;
+
+// Macro to glue names to get us less chance of name clashing.
+#if defined GFX_LOGGING_GLUE1 || defined GFX_LOGGING_GLUE
+# error "Clash of the macro GFX_LOGGING_GLUE1 or GFX_LOGGING_GLUE"
+#endif
+#define GFX_LOGGING_GLUE1(x, y) x##y
+#define GFX_LOGGING_GLUE(x, y) GFX_LOGGING_GLUE1(x, y)
+
+// This log goes into crash reports, use with care.
+#define gfxCriticalError mozilla::gfx::CriticalLog
+#define gfxCriticalErrorOnce \
+ static gfxCriticalError GFX_LOGGING_GLUE(sOnceAtLine, __LINE__) = \
+ gfxCriticalError
+
+// This is a shortcut for errors we want logged in crash reports/about support
+// but we do not want asserting. These are available in all builds, so it is
+// not worth trying to do magic to avoid matching the syntax of
+// gfxCriticalError.
+// So, this one is used as
+// gfxCriticalNote << "Something to report and not assert";
+// while the critical error is
+// gfxCriticalError() << "Something to report and assert";
+#define gfxCriticalNote \
+ gfxCriticalError(gfxCriticalError::DefaultOptions(false))
+#define gfxCriticalNoteOnce \
+ static gfxCriticalError GFX_LOGGING_GLUE(sOnceAtLine, __LINE__) = \
+ gfxCriticalNote
+
+// The "once" versions will only trigger the first time through. You can do
+// this: gfxCriticalErrorOnce() << "This message only shows up once; instead of
+// the usual: static bool firstTime = true; if (firstTime) {
+// firstTime = false;
+// gfxCriticalError() << "This message only shows up once;
+// }
+#if defined(DEBUG)
+# define gfxDebug mozilla::gfx::DebugLog
+# define gfxDebugOnce \
+ static gfxDebug GFX_LOGGING_GLUE(sOnceAtLine, __LINE__) = gfxDebug
+#else
+# define gfxDebug \
+ if (1) \
+ ; \
+ else \
+ mozilla::gfx::NoLog
+# define gfxDebugOnce \
+ if (1) \
+ ; \
+ else \
+ mozilla::gfx::NoLog
+#endif
+
+// Have gfxWarning available (behind a runtime preference)
+#define gfxWarning mozilla::gfx::WarningLog
+#define gfxWarningOnce \
+ static gfxWarning GFX_LOGGING_GLUE(sOnceAtLine, __LINE__) = gfxWarning
+
+// In the debug build, this is equivalent to the default gfxCriticalError.
+// In the non-debug build, on nightly and dev edition, it will MOZ_CRASH.
+// On beta and release versions, it will telemetry count, but proceed.
+//
+// You should create a (new) enum in the LogReason and use it for the reason
+// parameter to ensure uniqueness.
+#define gfxDevCrash(reason) \
+ gfxCriticalError(int(gfx::LogOptions::AutoPrefix) | \
+ int(gfx::LogOptions::AssertOnCall) | \
+ int(gfx::LogOptions::CrashAction), \
+ (reason))
+
+// See nsDebug.h and the NS_WARN_IF macro
+
+#ifdef __cplusplus
+// For now, have MOZ2D_ERROR_IF available in debug and non-debug builds
+inline bool MOZ2D_error_if_impl(bool aCondition, const char* aExpr,
+ const char* aFile, int32_t aLine) {
+ if (MOZ_UNLIKELY(aCondition)) {
+ gfxCriticalError() << aExpr << " at " << aFile << ":" << aLine;
+ }
+ return aCondition;
+}
+# define MOZ2D_ERROR_IF(condition) \
+ MOZ2D_error_if_impl(condition, #condition, __FILE__, __LINE__)
+
+# ifdef DEBUG
+inline bool MOZ2D_warn_if_impl(bool aCondition, const char* aExpr,
+ const char* aFile, int32_t aLine) {
+ if (MOZ_UNLIKELY(aCondition)) {
+ gfxWarning() << aExpr << " at " << aFile << ":" << aLine;
+ }
+ return aCondition;
+}
+# define MOZ2D_WARN_IF(condition) \
+ MOZ2D_warn_if_impl(condition, #condition, __FILE__, __LINE__)
+# else
+# define MOZ2D_WARN_IF(condition) (bool)(condition)
+# endif
+#endif
+
+const int INDENT_PER_LEVEL = 2;
+
+template <int Level = LOG_DEBUG>
+class TreeLog {
+ public:
+ explicit TreeLog(const std::string& aPrefix = "")
+ : mLog(int(LogOptions::NoNewline)),
+ mPrefix(aPrefix),
+ mDepth(0),
+ mStartOfLine(true),
+ mConditionedOnPref(false),
+ mPrefFunction(nullptr) {}
+
+ template <typename T>
+ TreeLog& operator<<(const T& aObject) {
+ if (mConditionedOnPref && !mPrefFunction()) {
+ return *this;
+ }
+ if (mStartOfLine) {
+ if (!mPrefix.empty()) {
+ mLog << '[' << mPrefix << "] ";
+ }
+ mLog << std::string(mDepth * INDENT_PER_LEVEL, ' ');
+ mStartOfLine = false;
+ }
+ mLog << aObject;
+ if (EndsInNewline(aObject)) {
+ // Don't indent right here as the user may change the indent
+ // between now and the first output to the next line.
+ mLog.Flush();
+ mStartOfLine = true;
+ }
+ return *this;
+ }
+
+ void IncreaseIndent() { ++mDepth; }
+ void DecreaseIndent() {
+ MOZ_ASSERT(mDepth > 0);
+ --mDepth;
+ }
+
+ void ConditionOnPrefFunction(bool (*aPrefFunction)()) {
+ mConditionedOnPref = true;
+ mPrefFunction = aPrefFunction;
+ }
+
+ private:
+ Log<Level> mLog;
+ std::string mPrefix;
+ uint32_t mDepth;
+ bool mStartOfLine;
+ bool mConditionedOnPref;
+ bool (*mPrefFunction)();
+
+ template <typename T>
+ static bool EndsInNewline(const T& aObject) {
+ return false;
+ }
+
+ static bool EndsInNewline(const std::string& aString) {
+ return !aString.empty() && aString[aString.length() - 1] == '\n';
+ }
+
+ static bool EndsInNewline(char aChar) { return aChar == '\n'; }
+
+ static bool EndsInNewline(const char* aString) {
+ return EndsInNewline(std::string(aString));
+ }
+};
+
+template <int Level = LOG_DEBUG>
+class TreeAutoIndent final {
+ public:
+ explicit TreeAutoIndent(TreeLog<Level>& aTreeLog) : mTreeLog(aTreeLog) {
+ mTreeLog.IncreaseIndent();
+ }
+
+ TreeAutoIndent(const TreeAutoIndent& aTreeAutoIndent)
+ : mTreeLog(aTreeAutoIndent.mTreeLog) {
+ mTreeLog.IncreaseIndent();
+ }
+
+ TreeAutoIndent& operator=(const TreeAutoIndent& aTreeAutoIndent) = delete;
+
+ ~TreeAutoIndent() { mTreeLog.DecreaseIndent(); }
+
+ private:
+ TreeLog<Level>& mTreeLog;
+};
+
+} // namespace gfx
+} // namespace mozilla
+
+#endif /* MOZILLA_GFX_LOGGING_H_ */