mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-09 03:15:11 +00:00
cab1c27b22
Backed out changeset f749ee384012 (bug 1254899) Backed out changeset 1d7eeee5a5c5 (bug 1254899) Backed out changeset b5ab83af342c (bug 1254899) Backed out changeset 993906e53329 (bug 1254899) Backed out changeset e8abac801a51 (bug 1254899) Backed out changeset e9c311c68e4a (bug 1254899) Backed out changeset f8f3ae8c5cef (bug 1254899) Backed out changeset d17f98a9918a (bug 1254899) Backed out changeset 21c8a7ea2b93 (bug 1254899) Backed out changeset 64e58f9625eb (bug 1254899) Backed out changeset 2de214d5d1e0 (bug 1254899) Backed out changeset f2056259d227 (bug 1254899) Backed out changeset b805df0c8296 (bug 1254899)
816 lines
27 KiB
C++
816 lines
27 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* 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/Logging.h"
|
|
#include "mozilla/gfx/Types.h"
|
|
#include "nsTArray.h"
|
|
#include "nsString.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsUnicodeScriptCodes.h"
|
|
|
|
#include "gfxTypes.h"
|
|
#include "gfxFontFamilyList.h"
|
|
#include "gfxBlur.h"
|
|
#include "nsRect.h"
|
|
|
|
#include "qcms.h"
|
|
|
|
#include "mozilla/RefPtr.h"
|
|
#include "GfxInfoCollector.h"
|
|
|
|
#include "mozilla/layers/CompositorTypes.h"
|
|
|
|
class gfxASurface;
|
|
class gfxFont;
|
|
class gfxFontGroup;
|
|
struct gfxFontStyle;
|
|
class gfxUserFontSet;
|
|
class gfxFontEntry;
|
|
class gfxPlatformFontList;
|
|
class gfxTextRun;
|
|
class nsIURI;
|
|
class nsIAtom;
|
|
class nsIObserver;
|
|
class SRGBOverrideObserver;
|
|
class gfxTextPerfMetrics;
|
|
|
|
namespace mozilla {
|
|
namespace gl {
|
|
class SkiaGLGlue;
|
|
} // namespace gl
|
|
namespace gfx {
|
|
class DrawTarget;
|
|
class SourceSurface;
|
|
class DataSourceSurface;
|
|
class ScaledFont;
|
|
class DrawEventRecorder;
|
|
class VsyncSource;
|
|
class DeviceInitData;
|
|
|
|
inline uint32_t
|
|
BackendTypeBit(BackendType b)
|
|
{
|
|
return 1 << uint8_t(b);
|
|
}
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|
|
|
|
#define MOZ_PERFORMANCE_WARNING(module, ...) \
|
|
do { \
|
|
if (gfxPlatform::PerfWarnings()) { \
|
|
printf_stderr("[" module "] " __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
extern cairo_user_data_key_t kDrawTarget;
|
|
|
|
enum eCMSMode {
|
|
eCMSMode_Off = 0, // No color management
|
|
eCMSMode_All = 1, // Color manage everything
|
|
eCMSMode_TaggedOnly = 2, // Color manage tagged Images Only
|
|
eCMSMode_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
|
|
};
|
|
|
|
// when searching through pref langs, max number of pref langs
|
|
const uint32_t kMaxLenPrefLangList = 32;
|
|
|
|
extern bool gANGLESupportsD3D11;
|
|
|
|
#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::COREGRAPHICS_ACCELERATED:
|
|
return "quartz accelerated";
|
|
case mozilla::gfx::BackendType::COREGRAPHICS:
|
|
return "quartz";
|
|
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::NONE:
|
|
return "none";
|
|
}
|
|
MOZ_CRASH("Incomplete switch");
|
|
}
|
|
|
|
enum class DeviceResetReason
|
|
{
|
|
OK = 0,
|
|
HUNG,
|
|
REMOVED,
|
|
RESET,
|
|
DRIVER_ERROR,
|
|
INVALID_CALL,
|
|
OUT_OF_MEMORY,
|
|
FORCED_RESET,
|
|
UNKNOWN
|
|
};
|
|
|
|
enum class ForcedDeviceResetReason
|
|
{
|
|
OPENSHAREDHANDLE = 0
|
|
};
|
|
|
|
class gfxPlatform {
|
|
friend class SRGBOverrideObserver;
|
|
|
|
public:
|
|
typedef mozilla::gfx::Color Color;
|
|
typedef mozilla::gfx::DataSourceSurface DataSourceSurface;
|
|
typedef mozilla::gfx::DrawTarget DrawTarget;
|
|
typedef mozilla::gfx::IntSize IntSize;
|
|
typedef mozilla::gfx::SourceSurface SourceSurface;
|
|
typedef mozilla::unicode::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();
|
|
|
|
static void InitLayersIPC();
|
|
static void ShutdownLayersIPC();
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
virtual 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
|
|
* PluginInstanceChild (where we can't call gfxPlatform::GetPlatform()
|
|
* because the prefs service can only be accessed from the main process).
|
|
*/
|
|
static already_AddRefed<SourceSurface>
|
|
GetSourceSurfaceForSurface(mozilla::gfx::DrawTarget *aTarget, gfxASurface *aSurface);
|
|
|
|
static void ClearSourceSurfaceForSurface(gfxASurface *aSurface);
|
|
|
|
static already_AddRefed<DataSourceSurface>
|
|
GetWrappedDataSourceSurface(gfxASurface *aSurface);
|
|
|
|
virtual already_AddRefed<mozilla::gfx::ScaledFont>
|
|
GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont);
|
|
|
|
already_AddRefed<DrawTarget>
|
|
CreateOffscreenContentDrawTarget(const mozilla::gfx::IntSize& aSize, mozilla::gfx::SurfaceFormat aFormat);
|
|
|
|
already_AddRefed<DrawTarget>
|
|
CreateOffscreenCanvasDrawTarget(const mozilla::gfx::IntSize& aSize, mozilla::gfx::SurfaceFormat aFormat);
|
|
|
|
virtual already_AddRefed<DrawTarget>
|
|
CreateDrawTargetForData(unsigned char* aData, const mozilla::gfx::IntSize& aSize,
|
|
int32_t aStride, mozilla::gfx::SurfaceFormat aFormat);
|
|
|
|
/**
|
|
* Returns true if rendering to data surfaces produces the same results as
|
|
* rendering to offscreen surfaces on this platform, making it safe to
|
|
* render content to data surfaces. This is generally false on platforms
|
|
* which use different backends for each type of DrawTarget.
|
|
*/
|
|
virtual bool CanRenderContentToDataSurface() const {
|
|
return 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;
|
|
}
|
|
|
|
/// This function also lets us know if the current preferences/platform
|
|
/// combination allows for both accelerated and not accelerated canvas
|
|
/// implementations. If it does, and other relevant preferences are
|
|
/// asking for it, we will examine the commands in the first few seconds
|
|
/// of the canvas usage, and potentially change to accelerated or
|
|
/// non-accelerated canvas.
|
|
virtual bool UseAcceleratedCanvas();
|
|
virtual void InitializeSkiaCacheLimits();
|
|
|
|
/// These should be used instead of directly accessing the preference,
|
|
/// as different platforms may override the behaviour.
|
|
virtual bool UseProgressivePaint();
|
|
|
|
static bool AsyncPanZoomEnabled();
|
|
|
|
virtual void GetAzureBackendInfo(mozilla::widget::InfoObject &aObj) {
|
|
aObj.DefineProperty("AzureCanvasBackend", GetBackendName(mPreferredCanvasBackend));
|
|
aObj.DefineProperty("AzureCanvasAccelerated", UseAcceleratedCanvas());
|
|
aObj.DefineProperty("AzureFallbackCanvasBackend", GetBackendName(mFallbackCanvasBackend));
|
|
aObj.DefineProperty("AzureContentBackend", GetBackendName(mContentBackend));
|
|
}
|
|
void GetApzSupportInfo(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() {
|
|
return mContentBackend;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
mozilla::gfx::BackendType GetPreferredCanvasBackend() {
|
|
return mPreferredCanvasBackend;
|
|
}
|
|
mozilla::gfx::BackendType GetFallbackCanvasBackend() {
|
|
return mFallbackCanvasBackend;
|
|
}
|
|
/*
|
|
* Font bits
|
|
*/
|
|
|
|
virtual void SetupClusterBoundaries(gfxTextRun *aTextRun, const char16_t *aString);
|
|
|
|
/**
|
|
* 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(nsIAtom *aLangGroup,
|
|
const nsACString& aGenericFamily,
|
|
nsTArray<nsString>& aListOfFonts);
|
|
|
|
int GetTileWidth();
|
|
int GetTileHeight();
|
|
void SetTileSize(int aWidth, int aHeight);
|
|
|
|
/**
|
|
* Rebuilds the any cached system font lists
|
|
*/
|
|
virtual nsresult UpdateFontList();
|
|
|
|
/**
|
|
* 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 gfxPlatformFontList *CreatePlatformFontList() {
|
|
NS_NOTREACHED("oops, this platform doesn't have a gfxPlatformFontList implementation");
|
|
return nullptr;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
virtual nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
|
|
|
|
/**
|
|
* Create the appropriate platform font group
|
|
*/
|
|
virtual gfxFontGroup*
|
|
CreateFontGroup(const mozilla::FontFamilyList& aFontFamilyList,
|
|
const gfxFontStyle *aStyle,
|
|
gfxTextPerfMetrics* aTextPerf,
|
|
gfxUserFontSet *aUserFontSet,
|
|
gfxFloat aDevToCssSize) = 0;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
virtual gfxFontEntry* LookupLocalFont(const nsAString& aFontName,
|
|
uint16_t aWeight,
|
|
int16_t aStretch,
|
|
uint8_t aStyle);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
virtual gfxFontEntry* MakePlatformFont(const nsAString& aFontName,
|
|
uint16_t aWeight,
|
|
int16_t aStretch,
|
|
uint8_t aStyle,
|
|
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; in particular,
|
|
* B2G always has FontHintingEnabled FALSE, but RequiresLinearZoom
|
|
* is only true for the browser process, not Gaia or other apps.
|
|
*
|
|
* 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 or not (if unclear, returns true)
|
|
virtual bool IsFontFormatSupported(nsIURI *aFontURI, uint32_t aFormatFlags) { return false; }
|
|
|
|
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*/, uint32_t /*aNextCh*/,
|
|
Script /*aRunScript*/,
|
|
nsTArray<const char*>& /*aFontList*/)
|
|
{
|
|
// platform-specific override, by default do nothing
|
|
}
|
|
|
|
// Are we in safe mode?
|
|
static bool InSafeMode();
|
|
|
|
static bool OffMainThreadCompositingEnabled();
|
|
|
|
static bool CanUseDirect3D9();
|
|
static bool CanUseDirect3D11();
|
|
virtual bool CanUseHardwareVideoDecoding();
|
|
static bool CanUseDirect3D11ANGLE();
|
|
|
|
// Returns whether or not layers acceleration should be used. This should
|
|
// only be called on the parent process.
|
|
bool ShouldUseLayersAcceleration();
|
|
|
|
// Returns a prioritized list of all available compositor backends.
|
|
void GetCompositorBackends(bool useAcceleration, nsTArray<mozilla::layers::LayersBackend>& aBackends);
|
|
|
|
/**
|
|
* Is it possible to use buffer rotation. Note that these
|
|
* check the preference, but also allow for the override to
|
|
* disable it using DisableBufferRotation.
|
|
*/
|
|
static bool BufferRotationEnabled();
|
|
static void DisableBufferRotation();
|
|
|
|
/**
|
|
* Are we going to try color management?
|
|
*/
|
|
static eCMSMode GetCMSMode();
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Sets 'out' to 'in' if transform is nullptr.
|
|
*/
|
|
static void TransformPixel(const Color& in, Color& out, qcms_transform *transform);
|
|
|
|
/**
|
|
* Return the output device ICC profile.
|
|
*/
|
|
static qcms_profile* GetCMSOutputProfile();
|
|
|
|
/**
|
|
* Return the sRGB ICC profile.
|
|
*/
|
|
static qcms_profile* GetCMSsRGBProfile();
|
|
|
|
/**
|
|
* Return sRGB -> output device transform.
|
|
*/
|
|
static qcms_transform* GetCMSRGBTransform();
|
|
|
|
/**
|
|
* Return output -> sRGB device transform.
|
|
*/
|
|
static qcms_transform* GetCMSInverseRGBTransform();
|
|
|
|
/**
|
|
* Return sRGBA -> output device transform.
|
|
*/
|
|
static qcms_transform* GetCMSRGBATransform();
|
|
|
|
virtual void FontsPrefsChanged(const char *aPref);
|
|
|
|
int32_t GetBidiNumeralOption();
|
|
|
|
static void
|
|
FlushFontAndWordCaches();
|
|
|
|
/**
|
|
* Returns a 1x1 surface that can be used to create graphics contexts
|
|
* for measuring text etc as if they will be rendered to the screen
|
|
*/
|
|
gfxASurface* ScreenReferenceSurface() { return mScreenReferenceSurface; }
|
|
mozilla::gfx::DrawTarget* ScreenReferenceDrawTarget() { return mScreenReferenceDrawTarget; }
|
|
|
|
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; }
|
|
|
|
/**
|
|
* Return the layer debugging options to use browser-wide.
|
|
*/
|
|
mozilla::layers::DiagnosticTypes GetLayerDiagnosticTypes();
|
|
|
|
static mozilla::gfx::IntRect FrameCounterBounds() {
|
|
int bits = 16;
|
|
int sizeOfBit = 3;
|
|
return mozilla::gfx::IntRect(0, 0, bits * sizeOfBit, sizeOfBit);
|
|
}
|
|
|
|
mozilla::gl::SkiaGLGlue* GetSkiaGLGlue();
|
|
void PurgeSkiaGPUCache();
|
|
static void PurgeSkiaFontCache();
|
|
|
|
virtual bool IsInGonkEmulator() const { return false; }
|
|
|
|
static bool UsesOffMainThreadCompositing();
|
|
|
|
bool HasEnoughTotalSystemMemoryForSkiaGL();
|
|
|
|
/**
|
|
* Get the hardware vsync source for each platform.
|
|
* Should only exist and be valid on the parent process
|
|
*/
|
|
virtual mozilla::gfx::VsyncSource* GetHardwareVsync() {
|
|
MOZ_ASSERT(mVsyncSource != nullptr);
|
|
MOZ_ASSERT(XRE_IsParentProcess());
|
|
return mVsyncSource;
|
|
}
|
|
|
|
/**
|
|
* 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 the software vsync rate to use.
|
|
*/
|
|
static int GetSoftwareVsyncRate();
|
|
|
|
/**
|
|
* Returns whether or not a custom vsync rate is set.
|
|
*/
|
|
static bool ForceSoftwareVsync();
|
|
|
|
/**
|
|
* Returns the default frame rate for the refresh driver / software vsync.
|
|
*/
|
|
static int GetDefaultFrameRate();
|
|
|
|
/**
|
|
* Used to test which input types are handled via APZ.
|
|
*/
|
|
virtual bool SupportsApzWheelInput() const {
|
|
return false;
|
|
}
|
|
virtual bool SupportsApzTouchInput() const {
|
|
return false;
|
|
}
|
|
bool SupportsApzDragInput() const;
|
|
|
|
virtual void FlushContentDrawing() {}
|
|
|
|
// If a device reset has occurred, schedule any necessary paints in the
|
|
// widget. This should only be used within nsRefreshDriver.
|
|
virtual void SchedulePaintIfDeviceReset() {}
|
|
|
|
// Immediately update all platform bits if a device reset has occurred.
|
|
// This should only be used at the top of the callstack (i.e. within
|
|
// a task, OS event, or IPDL message).
|
|
virtual void UpdateRenderModeIfDeviceReset() {}
|
|
|
|
/**
|
|
* 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 gfxPrefs::PerfWarnings().
|
|
* Extracted into a function to avoid including gfxPrefs.h from this file.
|
|
*/
|
|
static bool PerfWarnings();
|
|
|
|
void NotifyCompositorCreated(mozilla::layers::LayersBackend aBackend);
|
|
mozilla::layers::LayersBackend GetCompositorBackend() const {
|
|
return mCompositorBackend;
|
|
}
|
|
|
|
// Return information on how child processes should initialize graphics
|
|
// devices. Currently this is only used on Windows.
|
|
virtual void GetDeviceInitData(mozilla::gfx::DeviceInitData* aOut);
|
|
|
|
// 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;
|
|
}
|
|
|
|
uint64_t GetDeviceCounter() const {
|
|
return mDeviceCounter;
|
|
}
|
|
|
|
protected:
|
|
gfxPlatform();
|
|
virtual ~gfxPlatform();
|
|
|
|
/**
|
|
* Initialized hardware vsync based on each platform.
|
|
*/
|
|
virtual already_AddRefed<mozilla::gfx::VsyncSource> CreateHardwareVsyncSource();
|
|
|
|
// Returns whether or not layers should be accelerated by default on this platform.
|
|
virtual bool AccelerateLayersByDefault();
|
|
|
|
// Returns a prioritized list of available compositor backends for acceleration.
|
|
virtual void GetAcceleratedCompositorBackends(nsTArray<mozilla::layers::LayersBackend>& aBackends);
|
|
|
|
/**
|
|
* 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(uint32_t aCanvasBitmask, mozilla::gfx::BackendType aCanvasDefault,
|
|
uint32_t aContentBitmask, mozilla::gfx::BackendType aContentDefault);
|
|
|
|
/**
|
|
* If in a child process, triggers a refresh of device preferences.
|
|
*/
|
|
void UpdateDeviceInitData();
|
|
|
|
/**
|
|
* Increase the global device counter after a device has been removed/reset.
|
|
*/
|
|
void BumpDeviceCounter();
|
|
|
|
/**
|
|
* Called when new device preferences are available.
|
|
*/
|
|
virtual void SetDeviceInitData(mozilla::gfx::DeviceInitData& aData)
|
|
{}
|
|
|
|
/**
|
|
* 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);
|
|
|
|
static already_AddRefed<mozilla::gfx::ScaledFont>
|
|
GetScaledFontForFontWithCairoSkia(mozilla::gfx::DrawTarget* aTarget, gfxFont* aFont);
|
|
|
|
int8_t mAllowDownloadableFonts;
|
|
int8_t mGraphiteShapingEnabled;
|
|
int8_t mOpenTypeSVGEnabled;
|
|
|
|
int8_t mBidiNumeralOption;
|
|
|
|
// whether to always search font cmaps globally
|
|
// when doing system font fallback
|
|
int8_t mFallbackUsesCmaps;
|
|
|
|
// max character limit for words in word cache
|
|
int32_t mWordCacheCharLimit;
|
|
|
|
// max number of entries in word cache
|
|
int32_t mWordCacheMaxEntries;
|
|
|
|
uint32_t mTotalSystemMemory;
|
|
|
|
// Hardware vsync source. Only valid on parent process
|
|
RefPtr<mozilla::gfx::VsyncSource> mVsyncSource;
|
|
|
|
RefPtr<mozilla::gfx::DrawTarget> mScreenReferenceDrawTarget;
|
|
|
|
private:
|
|
/**
|
|
* Start up Thebes.
|
|
*/
|
|
static void Init();
|
|
|
|
static void CreateCMSOutputProfile();
|
|
|
|
static void GetCMSOutputProfileData(void *&mem, size_t &size);
|
|
|
|
friend void RecordingPrefChanged(const char *aPrefName, void *aClosure);
|
|
|
|
virtual void GetPlatformCMSOutputProfile(void *&mem, size_t &size);
|
|
|
|
/**
|
|
* Calling this function will compute and set the ideal tile size for the
|
|
* platform. This will only have an effect in the parent process; child processes
|
|
* should be updated via SetTileSize to match the value computed in the parent.
|
|
*/
|
|
void ComputeTileSize();
|
|
|
|
/**
|
|
* This uses nsIScreenManager to determine the screen size and color depth
|
|
*/
|
|
void PopulateScreenInfo();
|
|
|
|
RefPtr<gfxASurface> mScreenReferenceSurface;
|
|
nsCOMPtr<nsIObserver> mSRGBOverrideObserver;
|
|
nsCOMPtr<nsIObserver> mFontPrefsObserver;
|
|
nsCOMPtr<nsIObserver> 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;
|
|
// Bitmask of backend types we can use to render content
|
|
uint32_t mContentBackendBitmask;
|
|
|
|
int mTileWidth;
|
|
int mTileHeight;
|
|
|
|
mozilla::widget::GfxInfoCollector<gfxPlatform> mAzureCanvasBackendCollector;
|
|
mozilla::widget::GfxInfoCollector<gfxPlatform> mApzSupportCollector;
|
|
|
|
RefPtr<mozilla::gfx::DrawEventRecorder> mRecorder;
|
|
RefPtr<mozilla::gl::SkiaGLGlue> mSkiaGlue;
|
|
|
|
// 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;
|
|
|
|
// Generation number for devices that ClientLayerManagers might depend on.
|
|
uint64_t mDeviceCounter;
|
|
};
|
|
|
|
#endif /* GFX_PLATFORM_H */
|