summaryrefslogtreecommitdiffstats
path: root/gfx/thebes/gfxPlatform.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/thebes/gfxPlatform.h')
-rw-r--r--gfx/thebes/gfxPlatform.h1034
1 files changed, 1034 insertions, 0 deletions
diff --git a/gfx/thebes/gfxPlatform.h b/gfx/thebes/gfxPlatform.h
new file mode 100644
index 0000000000..db9b8fd436
--- /dev/null
+++ b/gfx/thebes/gfxPlatform.h
@@ -0,0 +1,1034 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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 GFX_PLATFORM_H
+#define GFX_PLATFORM_H
+
+#include "mozilla/FontPropertyTypes.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/intl/UnicodeScriptCodes.h"
+#include "nsTArray.h"
+#include "nsString.h"
+#include "nsCOMPtr.h"
+
+#include "gfxTelemetry.h"
+#include "gfxTypes.h"
+#include "gfxSkipChars.h"
+
+#include "qcms.h"
+
+#include "mozilla/RefPtr.h"
+#include "GfxInfoCollector.h"
+
+#include "mozilla/Maybe.h"
+#include "mozilla/layers/CompositorTypes.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/layers/MemoryPressureObserver.h"
+#include "mozilla/layers/OverlayInfo.h"
+
+class gfxASurface;
+class gfxFont;
+class gfxFontGroup;
+struct gfxFontStyle;
+class gfxUserFontSet;
+class gfxFontEntry;
+class gfxPlatformFontList;
+class gfxTextRun;
+class nsIURI;
+class nsAtom;
+class nsIObserver;
+class nsPresContext;
+class SRGBOverrideObserver;
+class gfxTextPerfMetrics;
+typedef struct FT_LibraryRec_* FT_Library;
+
+namespace mozilla {
+struct StyleFontFamilyList;
+class LogModule;
+class VsyncDispatcher;
+namespace layers {
+class FrameStats;
+}
+namespace gfx {
+class DrawTarget;
+class SourceSurface;
+class DataSourceSurface;
+class ScaledFont;
+class VsyncSource;
+class SoftwareVsyncSource;
+class ContentDeviceData;
+class GPUDeviceData;
+class FeatureState;
+
+inline uint32_t BackendTypeBit(BackendType b) { return 1 << uint8_t(b); }
+
+} // namespace gfx
+namespace dom {
+class SystemFontListEntry;
+class SystemFontList;
+} // namespace dom
+} // namespace mozilla
+
+#define MOZ_PERFORMANCE_WARNING(module, ...) \
+ do { \
+ if (gfxPlatform::PerfWarnings()) { \
+ printf_stderr("[" module "] " __VA_ARGS__); \
+ } \
+ } while (0)
+
+enum class CMSMode : int32_t {
+ Off = 0, // No color management
+ All = 1, // Color manage everything
+ TaggedOnly = 2, // Color manage tagged Images Only
+ AllCount = 3
+};
+
+enum eGfxLog {
+ // all font enumerations, localized names, fullname/psnames, cmap loads
+ eGfxLog_fontlist = 0,
+ // timing info on font initialization
+ eGfxLog_fontinit = 1,
+ // dump text runs, font matching, system fallback for content
+ eGfxLog_textrun = 2,
+ // dump text runs, font matching, system fallback for chrome
+ eGfxLog_textrunui = 3,
+ // dump cmap coverage data as they are loaded
+ eGfxLog_cmapdata = 4,
+ // text perf data
+ eGfxLog_textperf = 5
+};
+
+// Used during font matching to express a preference, if any, for whether
+// to use a font that will present a color or monochrome glyph.
+enum class eFontPresentation : uint8_t {
+ // Character does not have the emoji property, so no special heuristics
+ // apply during font selection.
+ Any = 0,
+ // Character is potentially emoji, but Text-style presentation has been
+ // explicitly requested using VS15.
+ Text = 1,
+ // Character has Emoji-style presentation by default (but an author-
+ // provided webfont will be used even if it is not color).
+ EmojiDefault = 2,
+ // Character explicitly requires Emoji-style presentation due to VS16 or
+ // skin-tone codepoint.
+ EmojiExplicit = 3
+};
+
+inline bool PrefersColor(eFontPresentation aPresentation) {
+ return aPresentation >= eFontPresentation::EmojiDefault;
+}
+
+// when searching through pref langs, max number of pref langs
+const uint32_t kMaxLenPrefLangList = 32;
+
+#define UNINITIALIZED_VALUE (-1)
+
+inline const char* GetBackendName(mozilla::gfx::BackendType aBackend) {
+ switch (aBackend) {
+ case mozilla::gfx::BackendType::DIRECT2D:
+ return "direct2d";
+ case mozilla::gfx::BackendType::CAIRO:
+ return "cairo";
+ case mozilla::gfx::BackendType::SKIA:
+ return "skia";
+ case mozilla::gfx::BackendType::RECORDING:
+ return "recording";
+ case mozilla::gfx::BackendType::DIRECT2D1_1:
+ return "direct2d 1.1";
+ case mozilla::gfx::BackendType::WEBRENDER_TEXT:
+ return "webrender text";
+ case mozilla::gfx::BackendType::NONE:
+ return "none";
+ case mozilla::gfx::BackendType::WEBGL:
+ return "webgl";
+ case mozilla::gfx::BackendType::BACKEND_LAST:
+ return "invalid";
+ }
+ MOZ_CRASH("Incomplete switch");
+}
+
+enum class DeviceResetReason {
+ OK = 0, // No reset.
+ HUNG, // Windows specific, guilty device reset.
+ REMOVED, // Windows specific, device removed or driver upgraded.
+ RESET, // Guilty device reset.
+ DRIVER_ERROR, // Innocent device reset.
+ INVALID_CALL, // Windows specific, guilty device reset.
+ OUT_OF_MEMORY,
+ FORCED_RESET, // Simulated device reset.
+ OTHER, // Unrecognized reason for device reset.
+ D3D9_RESET, // Windows specific, not used.
+ NVIDIA_VIDEO, // Linux specific, NVIDIA video memory was reset.
+ UNKNOWN, // GL specific, unknown if guilty or innocent.
+};
+
+enum class ForcedDeviceResetReason {
+ OPENSHAREDHANDLE = 0,
+ COMPOSITOR_UPDATED,
+};
+
+struct BackendPrefsData {
+ uint32_t mCanvasBitmask = 0;
+ mozilla::gfx::BackendType mCanvasDefault = mozilla::gfx::BackendType::NONE;
+ uint32_t mContentBitmask = 0;
+ mozilla::gfx::BackendType mContentDefault = mozilla::gfx::BackendType::NONE;
+};
+
+class gfxPlatform : public mozilla::layers::MemoryPressureListener {
+ friend class SRGBOverrideObserver;
+
+ public:
+ typedef mozilla::StretchRange StretchRange;
+ typedef mozilla::SlantStyleRange SlantStyleRange;
+ typedef mozilla::WeightRange WeightRange;
+ typedef mozilla::gfx::sRGBColor sRGBColor;
+ typedef mozilla::gfx::DeviceColor DeviceColor;
+ typedef mozilla::gfx::DataSourceSurface DataSourceSurface;
+ typedef mozilla::gfx::DrawTarget DrawTarget;
+ typedef mozilla::gfx::IntSize IntSize;
+ typedef mozilla::gfx::SourceSurface SourceSurface;
+ typedef mozilla::intl::Script Script;
+
+ /**
+ * Return a pointer to the current active platform.
+ * This is a singleton; it contains mostly convenience
+ * functions to obtain platform-specific objects.
+ */
+ static gfxPlatform* GetPlatform();
+
+ /**
+ * Returns whether or not graphics has been initialized yet. This is
+ * intended for Telemetry where we don't necessarily want to initialize
+ * graphics just to observe its state.
+ */
+ static bool Initialized();
+
+ /**
+ * Shut down Thebes.
+ * Init() arranges for this to be called at an appropriate time.
+ */
+ static void Shutdown();
+
+ /**
+ * Initialize gfxPlatform (if not already done) in a child process, with
+ * the provided ContentDeviceData.
+ */
+ static void InitChild(const mozilla::gfx::ContentDeviceData& aData);
+
+ static void InitLayersIPC();
+ static void ShutdownLayersIPC();
+
+ /**
+ * Initialize ScrollMetadata statics. Does not depend on gfxPlatform.
+ */
+ static void InitNullMetadata();
+
+ static int32_t MaxTextureSize();
+ static int32_t MaxAllocSize();
+ static void InitMoz2DLogging();
+
+ static bool IsHeadless();
+
+ static bool UseRemoteCanvas();
+
+ static bool IsBackendAccelerated(
+ const mozilla::gfx::BackendType aBackendType);
+
+ static bool CanMigrateMacGPUs();
+
+ /**
+ * Create an offscreen surface of the given dimensions
+ * and image format.
+ */
+ virtual already_AddRefed<gfxASurface> CreateOffscreenSurface(
+ const IntSize& aSize, gfxImageFormat aFormat) = 0;
+
+ /**
+ * Beware that this method may return DrawTargets which are not fully
+ * supported on the current platform and might fail silently in subtle ways.
+ * This is a massive potential footgun. You should only use these methods for
+ * canvas drawing really. Use extreme caution if you use them for content
+ * where you are not 100% sure we support the DrawTarget we get back. See
+ * SupportsAzureContentForDrawTarget.
+ */
+ static already_AddRefed<DrawTarget> CreateDrawTargetForSurface(
+ gfxASurface* aSurface, const mozilla::gfx::IntSize& aSize);
+
+ /*
+ * Creates a SourceSurface for a gfxASurface. This function does no caching,
+ * so the caller should cache the gfxASurface if it will be used frequently.
+ * The returned surface keeps a reference to aTarget, so it is OK to keep the
+ * surface, even if aTarget changes.
+ * aTarget should not keep a reference to the returned surface because that
+ * will cause a cycle.
+ *
+ * This function is static so that it can be accessed from outside the main
+ * process.
+ *
+ * aIsPlugin is used to tell the backend that they can optimize this surface
+ * specifically because it's used for a plugin. This is mostly for Skia.
+ */
+ static already_AddRefed<SourceSurface> GetSourceSurfaceForSurface(
+ RefPtr<mozilla::gfx::DrawTarget> aTarget, gfxASurface* aSurface,
+ bool aIsPlugin = false);
+
+ static void ClearSourceSurfaceForSurface(gfxASurface* aSurface);
+
+ static already_AddRefed<DataSourceSurface> GetWrappedDataSourceSurface(
+ gfxASurface* aSurface);
+
+ already_AddRefed<DrawTarget> CreateOffscreenContentDrawTarget(
+ const mozilla::gfx::IntSize& aSize, mozilla::gfx::SurfaceFormat aFormat,
+ bool aFallback = false);
+
+ already_AddRefed<DrawTarget> CreateOffscreenCanvasDrawTarget(
+ const mozilla::gfx::IntSize& aSize, mozilla::gfx::SurfaceFormat aFormat);
+
+ already_AddRefed<DrawTarget> CreateSimilarSoftwareDrawTarget(
+ DrawTarget* aDT, const IntSize& aSize,
+ mozilla::gfx::SurfaceFormat aFormat);
+
+ static already_AddRefed<DrawTarget> CreateDrawTargetForData(
+ unsigned char* aData, const mozilla::gfx::IntSize& aSize, int32_t aStride,
+ mozilla::gfx::SurfaceFormat aFormat, bool aUninitialized = false);
+
+ /**
+ * Returns true if we should use Azure to render content with aTarget. For
+ * example, it is possible that we are using Direct2D for rendering and thus
+ * using Azure. But we want to render to a CairoDrawTarget, in which case
+ * SupportsAzureContent will return true but SupportsAzureContentForDrawTarget
+ * will return false.
+ */
+ bool SupportsAzureContentForDrawTarget(mozilla::gfx::DrawTarget* aTarget);
+
+ bool SupportsAzureContentForType(mozilla::gfx::BackendType aType) {
+ return BackendTypeBit(aType) & mContentBackendBitmask;
+ }
+
+ static bool AsyncPanZoomEnabled();
+
+ const char* GetAzureCanvasBackend() const;
+ const char* GetAzureContentBackend() const;
+
+ void GetAzureBackendInfo(mozilla::widget::InfoObject& aObj);
+ void GetApzSupportInfo(mozilla::widget::InfoObject& aObj);
+ void GetFrameStats(mozilla::widget::InfoObject& aObj);
+ void GetCMSSupportInfo(mozilla::widget::InfoObject& aObj);
+ void GetDisplayInfo(mozilla::widget::InfoObject& aObj);
+ void GetOverlayInfo(mozilla::widget::InfoObject& aObj);
+ void GetSwapChainInfo(mozilla::widget::InfoObject& aObj);
+
+ // Get the default content backend that will be used with the default
+ // compositor. If the compositor is known when calling this function,
+ // GetContentBackendFor() should be called instead.
+ mozilla::gfx::BackendType GetDefaultContentBackend() const {
+ return mContentBackend;
+ }
+
+ /// Return the software backend to use by default.
+ mozilla::gfx::BackendType GetSoftwareBackend() { return mSoftwareBackend; }
+
+ // Return the best content backend available that is compatible with the
+ // given layers backend.
+ virtual mozilla::gfx::BackendType GetContentBackendFor(
+ mozilla::layers::LayersBackend aLayers) {
+ return mContentBackend;
+ }
+
+ virtual mozilla::gfx::BackendType GetPreferredCanvasBackend() {
+ return mPreferredCanvasBackend;
+ }
+ mozilla::gfx::BackendType GetFallbackCanvasBackend() {
+ return mFallbackCanvasBackend;
+ }
+
+ /*
+ * Font bits
+ */
+
+ /**
+ * Fill aListOfFonts with the results of querying the list of font names
+ * that correspond to the given language group or generic font family
+ * (or both, or neither).
+ */
+ virtual nsresult GetFontList(nsAtom* aLangGroup,
+ const nsACString& aGenericFamily,
+ nsTArray<nsString>& aListOfFonts);
+
+ /**
+ * Fill aFontList with a list of SystemFontListEntry records for the
+ * available fonts on the platform; used to pass the list from chrome to
+ * content process. Currently implemented only on MacOSX and Linux.
+ */
+ virtual void ReadSystemFontList(mozilla::dom::SystemFontList*){};
+
+ /**
+ * Rebuilds the system font lists (if aFullRebuild is true), or just notifies
+ * content that the list has changed but existing memory mappings are still
+ * valid (aFullRebuild is false).
+ */
+ nsresult UpdateFontList(bool aFullRebuild = true);
+
+ /**
+ * Create the platform font-list object (gfxPlatformFontList concrete
+ * subclass). This function is responsible to create the appropriate subclass
+ * of gfxPlatformFontList *and* to call its InitFontList() method.
+ */
+ virtual bool CreatePlatformFontList() = 0;
+
+ /**
+ * Resolving a font name to family name. The result MUST be in the result of
+ * GetFontList(). If the name doesn't in the system, aFamilyName will be empty
+ * string, but not failed.
+ */
+ void GetStandardFamilyName(const nsCString& aFontName,
+ nsACString& aFamilyName);
+
+ /**
+ * Returns default font name (localized family name) for aLangGroup and
+ * aGenericFamily. The result is typically the first font in
+ * font.name-list.<aGenericFamily>.<aLangGroup>. However, if it's not
+ * available in the system, this may return second or later font in the
+ * pref. If there are no available fonts in the pref, returns empty string.
+ */
+ nsAutoCString GetDefaultFontName(const nsACString& aLangGroup,
+ const nsACString& aGenericFamily);
+
+ /**
+ * Look up a local platform font using the full font face name.
+ * (Needed to support @font-face src local().)
+ * Ownership of the returned gfxFontEntry is passed to the caller,
+ * who must either AddRef() or delete.
+ */
+ gfxFontEntry* LookupLocalFont(nsPresContext* aPresContext,
+ const nsACString& aFontName,
+ WeightRange aWeightForEntry,
+ StretchRange aStretchForEntry,
+ SlantStyleRange aStyleForEntry);
+
+ /**
+ * Activate a platform font. (Needed to support @font-face src url().)
+ * aFontData is a NS_Malloc'ed block that must be freed by this function
+ * (or responsibility passed on) when it is no longer needed; the caller
+ * will NOT free it.
+ * Ownership of the returned gfxFontEntry is passed to the caller,
+ * who must either AddRef() or delete.
+ */
+ gfxFontEntry* MakePlatformFont(const nsACString& aFontName,
+ WeightRange aWeightForEntry,
+ StretchRange aStretchForEntry,
+ SlantStyleRange aStyleForEntry,
+ const uint8_t* aFontData, uint32_t aLength);
+
+ /**
+ * Whether to allow downloadable fonts via @font-face rules
+ */
+ bool DownloadableFontsEnabled();
+
+ /**
+ * True when hinting should be enabled. This setting shouldn't
+ * change per gecko process, while the process is live. If so the
+ * results are not defined.
+ *
+ * NB: this bit is only honored by the FT2 backend, currently.
+ */
+ virtual bool FontHintingEnabled() { return true; }
+
+ /**
+ * True when zooming should not require reflow, so glyph metrics and
+ * positioning should not be adjusted for device pixels.
+ * If this is TRUE, then FontHintingEnabled() should be FALSE,
+ * but the converse is not necessarily required;
+ *
+ * Like FontHintingEnabled (above), this setting shouldn't
+ * change per gecko process, while the process is live. If so the
+ * results are not defined.
+ *
+ * NB: this bit is only honored by the FT2 backend, currently.
+ */
+ virtual bool RequiresLinearZoom() { return false; }
+
+ /**
+ * Whether the frame->StyleFont().mFont.smoothing field is respected by
+ * text rendering on this platform.
+ */
+ virtual bool RespectsFontStyleSmoothing() const { return false; }
+
+ /**
+ * Whether to check all font cmaps during system font fallback
+ */
+ bool UseCmapsDuringSystemFallback();
+
+ /**
+ * Whether to render SVG glyphs within an OpenType font wrapper
+ */
+ bool OpenTypeSVGEnabled();
+
+ /**
+ * Max character length of words in the word cache
+ */
+ uint32_t WordCacheCharLimit();
+
+ /**
+ * Max number of entries in word cache
+ */
+ uint32_t WordCacheMaxEntries();
+
+ /**
+ * Whether to use the SIL Graphite rendering engine
+ * (for fonts that include Graphite tables)
+ */
+ bool UseGraphiteShaping();
+
+ // Check whether format is supported on a platform (if unclear, returns true).
+ // Default implementation checks for "common" formats that we support across
+ // all platforms, but individual platform implementations may override.
+ virtual bool IsFontFormatSupported(
+ mozilla::StyleFontFaceSourceFormatKeyword aFormatHint,
+ mozilla::StyleFontFaceSourceTechFlags aTechFlags);
+
+ bool IsKnownIconFontFamily(const nsAtom* aFamilyName) const;
+
+ virtual bool DidRenderingDeviceReset(
+ DeviceResetReason* aResetReason = nullptr) {
+ return false;
+ }
+
+ // returns a list of commonly used fonts for a given character
+ // these are *possible* matches, no cmap-checking is done at this level
+ virtual void GetCommonFallbackFonts(uint32_t /*aCh*/, Script /*aRunScript*/,
+ eFontPresentation /*aPresentation*/,
+ nsTArray<const char*>& /*aFontList*/) {
+ // platform-specific override, by default do nothing
+ }
+
+ // Are we in safe mode?
+ static bool InSafeMode();
+
+ static bool OffMainThreadCompositingEnabled();
+
+ void UpdateCanUseHardwareVideoDecoding();
+
+ /**
+ * Are we going to try color management?
+ */
+ static CMSMode GetCMSMode() {
+ EnsureCMSInitialized();
+ return gCMSMode;
+ }
+
+ /**
+ * Used only for testing. Override the pref setting.
+ */
+ static void SetCMSModeOverride(CMSMode aMode);
+
+ /**
+ * Determines the rendering intent for color management.
+ *
+ * If the value in the pref gfx.color_management.rendering_intent is a
+ * valid rendering intent as defined in gfx/qcms/qcms.h, that
+ * value is returned. Otherwise, -1 is returned and the embedded intent
+ * should be used.
+ *
+ * See bug 444014 for details.
+ */
+ static int GetRenderingIntent();
+
+ /**
+ * Convert a pixel using a cms transform in an endian-aware manner.
+ */
+ static DeviceColor TransformPixel(const sRGBColor& in,
+ qcms_transform* transform);
+
+ /**
+ * Return the output device ICC profile.
+ */
+ static qcms_profile* GetCMSOutputProfile() {
+ EnsureCMSInitialized();
+ return gCMSOutputProfile;
+ }
+
+ /**
+ * Return the sRGB ICC profile.
+ */
+ static qcms_profile* GetCMSsRGBProfile() {
+ EnsureCMSInitialized();
+ return gCMSsRGBProfile;
+ }
+
+ /**
+ * Return sRGB -> output device transform.
+ */
+ static qcms_transform* GetCMSRGBTransform() {
+ EnsureCMSInitialized();
+ return gCMSRGBTransform;
+ }
+
+ /**
+ * Return output -> sRGB device transform.
+ */
+ static qcms_transform* GetCMSInverseRGBTransform() {
+ MOZ_ASSERT(gCMSInitialized);
+ return gCMSInverseRGBTransform;
+ }
+
+ /**
+ * Return sRGBA -> output device transform.
+ */
+ static qcms_transform* GetCMSRGBATransform() {
+ MOZ_ASSERT(gCMSInitialized);
+ return gCMSRGBATransform;
+ }
+
+ /**
+ * Return sBGRA -> output device transform.
+ */
+ static qcms_transform* GetCMSBGRATransform() {
+ MOZ_ASSERT(gCMSInitialized);
+ return gCMSBGRATransform;
+ }
+
+ /**
+ * Return OS RGBA -> output device transform.
+ */
+ static qcms_transform* GetCMSOSRGBATransform();
+
+ /**
+ * Return OS RGBA QCMS type.
+ */
+ static qcms_data_type GetCMSOSRGBAType();
+
+ virtual void FontsPrefsChanged(const char* aPref);
+
+ uint32_t GetBidiNumeralOption();
+
+ /**
+ * Force all presContexts to reflow (and reframe if needed).
+ *
+ * This is used when something about platform settings changes that might have
+ * an effect on layout, such as font rendering settings that influence
+ * metrics, or installed fonts.
+ *
+ * By default it also broadcast it to child processes, but some callers might
+ * not need it if they implement their own notification.
+ */
+ enum class NeedsReframe : bool { No, Yes };
+ enum class BroadcastToChildren : bool { No, Yes };
+ static void ForceGlobalReflow(NeedsReframe,
+ BroadcastToChildren = BroadcastToChildren::Yes);
+
+ static void FlushFontAndWordCaches();
+
+ /**
+ * Returns a 1x1 DrawTarget that can be used for measuring text etc. as
+ * it would measure if rendered on-screen. Guaranteed to return a
+ * non-null and valid DrawTarget.
+ */
+ RefPtr<mozilla::gfx::DrawTarget> ScreenReferenceDrawTarget();
+
+ static RefPtr<mozilla::gfx::DrawTarget>
+ ThreadLocalScreenReferenceDrawTarget();
+
+ virtual mozilla::gfx::SurfaceFormat Optimal2DFormatForContent(
+ gfxContentType aContent);
+
+ virtual gfxImageFormat OptimalFormatForContent(gfxContentType aContent);
+
+ virtual gfxImageFormat GetOffscreenFormat() {
+ return mozilla::gfx::SurfaceFormat::X8R8G8B8_UINT32;
+ }
+
+ /**
+ * Returns a logger if one is available and logging is enabled
+ */
+ static mozilla::LogModule* GetLog(eGfxLog aWhichLog);
+
+ int GetScreenDepth() const { return mScreenDepth; }
+ mozilla::gfx::IntSize GetScreenSize() const { return mScreenSize; }
+
+ static void PurgeSkiaFontCache();
+
+ static bool UsesOffMainThreadCompositing();
+
+ /**
+ * Returns the global vsync dispatcher. There is only one global vsync
+ * dispatcher and it stays around for the entire lifetime of the process.
+ * Must only be called in the parent process.
+ */
+ RefPtr<mozilla::VsyncDispatcher> GetGlobalVsyncDispatcher();
+
+ /**
+ * True if layout rendering should use ASAP mode, which means
+ * the refresh driver and compositor should render ASAP.
+ * Used for talos testing purposes
+ */
+ static bool IsInLayoutAsapMode();
+
+ /**
+ * Returns whether or not a custom vsync rate is set.
+ */
+ static bool ForceSoftwareVsync();
+
+ /**
+ * Returns the software vsync rate to use.
+ */
+ static int GetSoftwareVsyncRate();
+
+ /**
+ * Returns the default frame rate for the refresh driver / software vsync.
+ */
+ static int GetDefaultFrameRate();
+
+ /**
+ * Update the frame rate (called e.g. after pref changes).
+ */
+ static void ReInitFrameRate(const char* aPrefIgnored, void* aDataIgnored);
+
+ /**
+ * Update force subpixel AA quality setting (called after pref
+ * changes).
+ */
+ void UpdateForceSubpixelAAWherePossible();
+
+ /**
+ * Used to test which input types are handled via APZ.
+ */
+ virtual bool SupportsApzWheelInput() const { return false; }
+ bool SupportsApzTouchInput() const;
+ bool SupportsApzDragInput() const;
+ bool SupportsApzKeyboardInput() const;
+ bool SupportsApzAutoscrolling() const;
+ bool SupportsApzZooming() const;
+
+ // If a device reset has occurred, schedule any necessary paints in the
+ // widget. This should only be used within nsRefreshDriver.
+ virtual void SchedulePaintIfDeviceReset() {}
+
+ /**
+ * Helper method, creates a draw target for a specific Azure backend.
+ * Used by CreateOffscreenDrawTarget.
+ */
+ already_AddRefed<DrawTarget> CreateDrawTargetForBackend(
+ mozilla::gfx::BackendType aBackend, const mozilla::gfx::IntSize& aSize,
+ mozilla::gfx::SurfaceFormat aFormat);
+
+ /**
+ * Wrapper around StaticPrefs::gfx_perf_warnings_enabled().
+ * Extracted into a function to avoid including StaticPrefs_gfx.h from this
+ * file.
+ */
+ static bool PerfWarnings();
+
+ static void DisableGPUProcess();
+
+ void NotifyCompositorCreated(mozilla::layers::LayersBackend aBackend);
+ mozilla::layers::LayersBackend GetCompositorBackend() const {
+ return mCompositorBackend;
+ }
+
+ virtual void CompositorUpdated() {}
+
+ // Plugin async drawing support.
+ virtual bool SupportsPluginDirectBitmapDrawing() { return false; }
+
+ // Some platforms don't support CompositorOGL in an unaccelerated OpenGL
+ // context. These platforms should return true here.
+ virtual bool RequiresAcceleratedGLContextForCompositorOGL() const {
+ return false;
+ }
+
+ /**
+ * Check the blocklist for a feature. Returns false if the feature is blocked
+ * with an appropriate message and failure ID.
+ * */
+ static bool IsGfxInfoStatusOkay(int32_t aFeature, nsCString* aOutMessage,
+ nsCString& aFailureId);
+
+ const gfxSkipChars& EmptySkipChars() const { return kEmptySkipChars; }
+
+ /**
+ * Returns a buffer containing the CMS output profile data. The way this
+ * is obtained is platform-specific.
+ */
+ virtual nsTArray<uint8_t> GetPlatformCMSOutputProfileData() {
+ return GetPrefCMSOutputProfileData();
+ }
+
+ /**
+ * Return information on how child processes should initialize graphics
+ * devices.
+ */
+ virtual void BuildContentDeviceData(mozilla::gfx::ContentDeviceData* aOut);
+
+ /**
+ * Imports settings from the GPU process. This should only be called through
+ * GPUProcessManager, in the UI process.
+ */
+ virtual void ImportGPUDeviceData(const mozilla::gfx::GPUDeviceData& aData);
+
+ void SetOverlayInfo(const mozilla::layers::OverlayInfo& aInfo) {
+ mOverlayInfo = mozilla::Some(aInfo);
+ }
+
+ void SetSwapChainInfo(const mozilla::layers::SwapChainInfo& aInfo) {
+ mSwapChainInfo = mozilla::Some(aInfo);
+ }
+
+ static bool HasVariationFontSupport();
+
+ // you probably want to use gfxVars::UseWebRender() instead of this
+ static bool WebRenderPrefEnabled();
+ // you probably want to use gfxVars::UseWebRender() instead of this
+ static bool WebRenderEnvvarEnabled();
+
+ static const char* WebRenderResourcePathOverride();
+
+ // Returns true if we would like to keep the GPU process if possible.
+ // If aCrashAfterFinalFallback is true then crash if we have already
+ // exhausted all of our fallback options. Otherwise we remain on the final
+ // fallback configuration.
+ static bool FallbackFromAcceleration(mozilla::gfx::FeatureStatus aStatus,
+ const char* aMessage,
+ const nsACString& aFailureId,
+ bool aCrashAfterFinalFallback = false);
+
+ void NotifyFrameStats(nsTArray<mozilla::layers::FrameStats>&& aFrameStats);
+
+ virtual void OnMemoryPressure(
+ mozilla::layers::MemoryPressureReason aWhy) override;
+
+ virtual void EnsureDevicesInitialized(){};
+ virtual bool DevicesInitialized() { return true; };
+
+ virtual bool IsWaylandDisplay() { return false; }
+
+ static uint32_t TargetFrameRate();
+
+ static bool UseDesktopZoomingScrollbars();
+
+ virtual bool SupportsHDR() { return false; }
+
+ protected:
+ gfxPlatform();
+ virtual ~gfxPlatform();
+
+ virtual void InitAcceleration();
+ virtual void InitWebRenderConfig();
+ void InitHardwareVideoConfig();
+ virtual void InitWebGLConfig();
+ virtual void InitWebGPUConfig();
+ virtual void InitWindowOcclusionConfig();
+ void InitBackdropFilterConfig();
+ void InitAcceleratedCanvas2DConfig();
+
+ virtual void GetPlatformDisplayInfo(mozilla::widget::InfoObject& aObj) {}
+
+ /**
+ * Called immediately before deleting the gfxPlatform object.
+ */
+ virtual void WillShutdown();
+
+ // Return a hardware vsync source for this platform.
+ already_AddRefed<mozilla::gfx::VsyncSource> GetGlobalHardwareVsyncSource();
+
+ // Return a software vsync source (which uses a timer internally).
+ // Can be used as a fallback for platforms without hardware vsync,
+ // and when the layout.frame_rate pref is set to a non-negative value.
+ already_AddRefed<mozilla::gfx::VsyncSource> GetSoftwareVsyncSource();
+
+ // Create the platform-specific global vsync source. Can fall back to
+ // GetSoftwareVsyncSource().
+ virtual already_AddRefed<mozilla::gfx::VsyncSource>
+ CreateGlobalHardwareVsyncSource() = 0;
+
+ // Returns whether or not layers should be accelerated by default on this
+ // platform.
+ virtual bool AccelerateLayersByDefault();
+
+ // Returns preferences of canvas and content backends.
+ virtual BackendPrefsData GetBackendPrefs() const;
+
+ /**
+ * Initialise the preferred and fallback canvas backends
+ * aBackendBitmask specifies the backends which are acceptable to the caller.
+ * The backend used is determined by aBackendBitmask and the order specified
+ * by the gfx.canvas.azure.backends pref.
+ */
+ void InitBackendPrefs(BackendPrefsData&& aPrefsData);
+
+ /**
+ * Content-process only. Requests device preferences from the parent process
+ * and updates any cached settings.
+ */
+ void FetchAndImportContentDeviceData();
+ virtual void ImportContentDeviceData(
+ const mozilla::gfx::ContentDeviceData& aData);
+
+ public:
+ /**
+ * Returns the contents of the file pointed to by the
+ * gfx.color_management.display_profile pref, if set.
+ * Returns an empty array if not set, or if an error occurs
+ */
+ static nsTArray<uint8_t> GetPrefCMSOutputProfileData();
+
+ protected:
+ /**
+ * If inside a child process and currently being initialized by the
+ * SetXPCOMProcessAttributes message, this can be used by subclasses to
+ * retrieve the ContentDeviceData passed by the message
+ *
+ * If not currently being initialized, will return nullptr. In this case,
+ * child should send a sync message to ask parent for color profile
+ */
+ const mozilla::gfx::ContentDeviceData* GetInitContentDeviceData();
+
+ /**
+ * Increase the global device counter after a device has been removed/reset.
+ */
+ void BumpDeviceCounter();
+
+ /**
+ * returns the first backend named in the pref gfx.canvas.azure.backends
+ * which is a component of aBackendBitmask, a bitmask of backend types
+ */
+ static mozilla::gfx::BackendType GetCanvasBackendPref(
+ uint32_t aBackendBitmask);
+
+ /**
+ * returns the first backend named in the pref gfx.content.azure.backend
+ * which is a component of aBackendBitmask, a bitmask of backend types
+ */
+ static mozilla::gfx::BackendType GetContentBackendPref(
+ uint32_t& aBackendBitmask);
+
+ /**
+ * Will return the first backend named in aBackendPrefName
+ * allowed by aBackendBitmask, a bitmask of backend types.
+ * It also modifies aBackendBitmask to only include backends that are
+ * allowed given the prefs.
+ */
+ static mozilla::gfx::BackendType GetBackendPref(const char* aBackendPrefName,
+ uint32_t& aBackendBitmask);
+ /**
+ * Decode the backend enumberation from a string.
+ */
+ static mozilla::gfx::BackendType BackendTypeForName(const nsCString& aName);
+
+ virtual bool CanUseHardwareVideoDecoding();
+
+ int8_t mAllowDownloadableFonts;
+
+ // Whether the platform supports rendering OpenType font variations
+ static std::atomic<int8_t> sHasVariationFontSupport;
+
+ // The global vsync dispatcher. Only non-null in the parent process.
+ // Its underlying VsyncSource is either mGlobalHardwareVsyncSource
+ // or mSoftwareVsyncSource.
+ RefPtr<mozilla::VsyncDispatcher> mVsyncDispatcher;
+
+ // Cached software vsync source. Only non-null in the parent process,
+ // and only after the first time GetHardwareVsyncSource has been called.
+ RefPtr<mozilla::gfx::VsyncSource> mGlobalHardwareVsyncSource;
+
+ // Cached software vsync source. Only non-null in the parent process,
+ // and only after the first time GetSoftwareVsyncSource has been called.
+ // Used as a fallback source if hardware vsync is not available,
+ // or when the layout.frame_rate pref is set.
+ RefPtr<mozilla::gfx::SoftwareVsyncSource> mSoftwareVsyncSource;
+
+ RefPtr<mozilla::gfx::DrawTarget> mScreenReferenceDrawTarget;
+
+ private:
+ /**
+ * Start up Thebes.
+ */
+ static void Init();
+
+ static void InitOpenGLConfig();
+
+ static mozilla::Atomic<bool, mozilla::MemoryOrdering::ReleaseAcquire>
+ gCMSInitialized;
+ static CMSMode gCMSMode;
+
+ // These two may point to the same profile
+ static qcms_profile* gCMSOutputProfile;
+ static qcms_profile* gCMSsRGBProfile;
+
+ static qcms_transform* gCMSRGBTransform;
+ static qcms_transform* gCMSInverseRGBTransform;
+ static qcms_transform* gCMSRGBATransform;
+ static qcms_transform* gCMSBGRATransform;
+
+ inline static void EnsureCMSInitialized() {
+ if (MOZ_UNLIKELY(!gCMSInitialized)) {
+ InitializeCMS();
+ }
+ }
+
+ static void InitializeCMS();
+ static void ShutdownCMS();
+
+ /**
+ * This uses nsIScreenManager to determine the screen size and color depth
+ */
+ void PopulateScreenInfo();
+
+ void InitCompositorAccelerationPrefs();
+ void InitGPUProcessPrefs();
+ virtual void InitPlatformGPUProcessPrefs() {}
+
+ // Gather telemetry data about the Gfx Platform and send it
+ static void ReportTelemetry();
+
+ static bool IsDXInterop2Blocked();
+ static bool IsDXNV12Blocked();
+ static bool IsDXP010Blocked();
+ static bool IsDXP016Blocked();
+
+ RefPtr<gfxASurface> mScreenReferenceSurface;
+ RefPtr<mozilla::layers::MemoryPressureObserver> mMemoryPressureObserver;
+
+ // The preferred draw target backend to use for canvas
+ mozilla::gfx::BackendType mPreferredCanvasBackend;
+ // The fallback draw target backend to use for canvas, if the preferred
+ // backend fails
+ mozilla::gfx::BackendType mFallbackCanvasBackend;
+ // The backend to use for content
+ mozilla::gfx::BackendType mContentBackend;
+ // The backend to use when we need it not to be accelerated.
+ mozilla::gfx::BackendType mSoftwareBackend;
+ // Bitmask of backend types we can use to render content
+ uint32_t mContentBackendBitmask;
+
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mAzureCanvasBackendCollector;
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mApzSupportCollector;
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mFrameStatsCollector;
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mCMSInfoCollector;
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mDisplayInfoCollector;
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mOverlayInfoCollector;
+ mozilla::widget::GfxInfoCollector<gfxPlatform> mSwapChainInfoCollector;
+
+ nsTArray<mozilla::layers::FrameStats> mFrameStats;
+
+ // Backend that we are compositing with. NONE, if no compositor has been
+ // created yet.
+ mozilla::layers::LayersBackend mCompositorBackend;
+
+ int32_t mScreenDepth;
+ mozilla::gfx::IntSize mScreenSize;
+
+ mozilla::Maybe<mozilla::layers::OverlayInfo> mOverlayInfo;
+ mozilla::Maybe<mozilla::layers::SwapChainInfo> mSwapChainInfo;
+
+ // An instance of gfxSkipChars which is empty. It is used as the
+ // basis for error-case iterators.
+ const gfxSkipChars kEmptySkipChars;
+};
+
+CMSMode GfxColorManagementMode();
+
+#endif /* GFX_PLATFORM_H */