Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1043 insertions, 0 deletions

diff --git a/gfx/thebes/gfxPlatform.h b/gfx/thebes/gfxPlatform.h
new file mode 100644
index 0000000000..5af6d77345
--- /dev/null
+++ b/gfx/thebes/gfxPlatform.h
@@ -0,0 +1,1043 @@
+/* -*- 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 void DisableRemoteCanvas();
+
+  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. Updates device preferences from the parent process,
+   * if we've received any.
+   */
+  void ImportCachedContentDeviceData();
+  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();
+
+  /**
+   * If inside a child process and have ever received a
+   * SetXPCOMProcessAttributes message, this contains the cmsOutputProfileData
+   * from that message.
+   */
+  mozilla::Maybe<nsTArray<uint8_t>>& GetCMSOutputProfileData();
+
+  /**
+   * 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 */