wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-09 09:18:42 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1053 - Remove mobile-specific graphics "optimizations" (=compromises)

Browse source
This commit is contained in:
Moonchild 2021-03-10 18:58:26 +00:00 • committed by roytam1
commit 1feafdc819
21 changed files with 0 additions and 193 deletions
Download patch file Download diff file Expand all files Collapse all files

1
build/moz.configure/old.configure
View file

@ -200,7 +200,6 @@ def old_configure_options(*options):
'--enable-logrefcnt',
'--enable-maintenance-service',
'--enable-memory-sanitizer',
'--enable-mobile-optimize',
'--enable-mozril-geoloc',
'--enable-necko-wifi',
'--enable-negotiateauth',

6
dom/canvas/WebGLContext.cpp
View file

@ -1078,14 +1078,8 @@ WebGLContext::ClearBackbufferIfNeeded()
void
WebGLContext::LoseOldestWebGLContextIfLimitExceeded()
{
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
// some mobile devices can't have more than 8 GL contexts overall
const size_t kMaxWebGLContextsPerPrincipal = 2;
const size_t kMaxWebGLContexts = 4;
#else
const size_t kMaxWebGLContextsPerPrincipal = 16;
const size_t kMaxWebGLContexts = 32;
#endif
MOZ_ASSERT(kMaxWebGLContextsPerPrincipal < kMaxWebGLContexts);
if (!NS_IsMainThread()) {

10
gfx/cairo/cairo/src/cairo-image-surface.c
View file

@ -4064,13 +4064,7 @@ _cairo_image_surface_glyphs (void *abstract_surface,
composite_glyphs_info_t glyph_info;
cairo_clip_t local_clip;
cairo_bool_t have_clip = FALSE;
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
// For performance reasons we don't want to use two passes for overlapping glyphs
// on mobile
cairo_bool_t overlap = FALSE;
#else
cairo_bool_t overlap;
#endif
cairo_status_t status;
cairo_rectangle_int_t rect;
@ -4084,11 +4078,7 @@ _cairo_image_surface_glyphs (void *abstract_surface,
scaled_font,
glyphs, num_glyphs,
clip,
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
NULL);
#else
&overlap);
#endif
if (unlikely (status))
return status;

6
gfx/cairo/cairo/src/cairoint.h
View file

@ -903,13 +903,7 @@ typedef struct _cairo_traps {
#endif
#define CAIRO_GSTATE_OPERATOR_DEFAULT CAIRO_OPERATOR_OVER
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
// Skia uses a tolerance of 0.5 we'll use something more
// tolerant for now
#define CAIRO_GSTATE_TOLERANCE_DEFAULT 0.3
#else
#define CAIRO_GSTATE_TOLERANCE_DEFAULT 0.1
#endif
#define CAIRO_GSTATE_FILL_RULE_DEFAULT CAIRO_FILL_RULE_WINDING
#define CAIRO_GSTATE_LINE_WIDTH_DEFAULT 2.0
#define CAIRO_GSTATE_LINE_CAP_DEFAULT CAIRO_LINE_CAP_BUTT

6
gfx/cairo/libpixman/src/pixman-private.h
View file

@ -9,13 +9,7 @@
#ifndef MOZILLA_VERSION
#error "Need mozilla headers"
#endif
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
#define LOW_QUALITY_INTERPOLATION
#define LOWER_QUALITY_INTERPOLATION
#define BILINEAR_INTERPOLATION_BITS 4
#else
#define BILINEAR_INTERPOLATION_BITS 7
#endif
#define BILINEAR_INTERPOLATION_RANGE (1 << BILINEAR_INTERPOLATION_BITS)
/*

4
gfx/layers/Layers.cpp
View file

@ -1399,11 +1399,7 @@ ContainerLayer::DefaultComputeEffectiveTransforms(const Matrix4x4& aTransformToS
checkClipRect = true;
checkMaskLayers = true;
} else {
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
if (!contTransform.PreservesAxisAlignedRectangles()) {
#else
if (gfx::ThebesMatrix(contTransform).HasNonIntegerTranslation()) {
#endif
checkClipRect = true;
}
/* In 2D case, only translation and/or positive scaling can be done w/o using IntermediateSurface.

12
gfx/layers/RotatedBuffer.cpp
View file

@ -139,21 +139,13 @@ RotatedBuffer::DrawBufferQuadrant(gfx::DrawTarget* aTarget,
transform *= oldTransform;
transform *= inverseMask;
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
SurfacePattern source(snapshot, ExtendMode::CLAMP, transform, SamplingFilter::POINT);
#else
SurfacePattern source(snapshot, ExtendMode::CLAMP, transform);
#endif
aTarget->SetTransform(*aMaskTransform);
aTarget->MaskSurface(source, aMask, Point(0, 0), DrawOptions(aOpacity, aOperator));
aTarget->SetTransform(oldTransform);
} else {
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
DrawSurfaceOptions options(SamplingFilter::POINT);
#else
DrawSurfaceOptions options;
#endif
aTarget->DrawSurface(snapshot, IntRectToRect(fillRect),
GetSourceRectangle(aXSide, aYSide),
options,
@ -466,9 +458,6 @@ RotatedContentBuffer::BeginPaint(PaintedLayer* aLayer,
}
if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
#if defined(MOZ_GFX_OPTIMIZE_MOBILE)
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
#else
if (!aLayer->GetParent() ||
!aLayer->GetParent()->SupportsComponentAlphaChildren() ||
!aLayer->AsShadowableLayer() ||
@ -477,7 +466,6 @@ RotatedContentBuffer::BeginPaint(PaintedLayer* aLayer,
} else {
result.mContentType = gfxContentType::COLOR;
}
#endif
}
if ((aFlags & PAINT_WILL_RESAMPLE) &&

2
gfx/layers/client/ClientPaintedLayer.cpp
View file

@ -39,7 +39,6 @@ ClientPaintedLayer::PaintThebes()
"Can only draw in drawing phase");
uint32_t flags = RotatedContentBuffer::PAINT_CAN_DRAW_ROTATED;
#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE
if (ClientManager()->CompositorMightResample()) {
flags |= RotatedContentBuffer::PAINT_WILL_RESAMPLE;
}
@ -48,7 +47,6 @@ ClientPaintedLayer::PaintThebes()
flags |= RotatedContentBuffer::PAINT_WILL_RESAMPLE;
}
}
#endif
PaintState state =
mContentClient->BeginPaintBuffer(this, flags);
mValidRegion.Sub(mValidRegion, state.mRegionToInvalidate);

2
gfx/layers/client/ClientTiledPaintedLayer.cpp
View file

@ -462,7 +462,6 @@ ClientTiledPaintedLayer::RenderLayer()
TILING_LOG("TILING %p: Initial low-precision valid region %s\n", this, Stringify(mLowPrecisionValidRegion).c_str());
nsIntRegion neededRegion = mVisibleRegion.ToUnknownRegion();
#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE
// This is handled by PadDrawTargetOutFromRegion in TiledContentClient for mobile
if (MayResample()) {
// If we're resampling then bilinear filtering can read up to 1 pixel
@ -477,7 +476,6 @@ ClientTiledPaintedLayer::RenderLayer()
padded.IntersectRect(padded, wholeTiles);
neededRegion = padded;
}
#endif
nsIntRegion invalidRegion;
invalidRegion.Sub(neededRegion, mValidRegion);

13
gfx/layers/client/TiledContentClient.cpp
View file

@ -308,30 +308,17 @@ ClientTiledLayerBuffer::GetContentType(SurfaceMode* aMode) const
SurfaceMode mode = mPaintedLayer.GetSurfaceMode();
if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
#if defined(MOZ_GFX_OPTIMIZE_MOBILE)
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
#else
if (!mPaintedLayer.GetParent() ||
!mPaintedLayer.GetParent()->SupportsComponentAlphaChildren()) {
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
} else {
content = gfxContentType::COLOR;
}
#endif
} else if (mode == SurfaceMode::SURFACE_OPAQUE) {
#if defined(MOZ_GFX_OPTIMIZE_MOBILE)
if (IsLowPrecision()) {
// If we're in low-res mode, drawing can sample from outside the visible
// region. Make sure that we only sample transparency if that happens.
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
content = gfxContentType::COLOR_ALPHA;
}
#else
if (mPaintedLayer.MayResample()) {
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
content = gfxContentType::COLOR_ALPHA;
}
#endif
}
if (aMode) {

4
gfx/layers/composite/ContentHost.cpp
View file

@ -71,7 +71,6 @@ ContentHostTexture::Composite(LayerComposite* aLayer,
nsIntRegion tmpRegion;
const nsIntRegion* renderRegion;
#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE
if (PaintWillResample()) {
// If we're resampling, then the texture image will contain exactly the
// entire visible region's bounds, and we should draw it all in one quad
@ -81,9 +80,6 @@ ContentHostTexture::Composite(LayerComposite* aLayer,
} else {
renderRegion = aVisibleRegion;
}
#else
renderRegion = aVisibleRegion;
#endif
nsIntRegion region(*renderRegion);
nsIntPoint origin = GetOriginOffset();

2
gfx/layers/composite/TiledContentHost.cpp
View file

@ -425,7 +425,6 @@ TiledContentHost::Composite(LayerComposite* aLayer,
nsIntRegion tmpRegion;
const nsIntRegion* renderRegion = aVisibleRegion;
#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE
if (PaintWillResample()) {
// If we're resampling, then the texture image will contain exactly the
// entire visible region's bounds, and we should draw it all in one quad
@ -433,7 +432,6 @@ TiledContentHost::Composite(LayerComposite* aLayer,
tmpRegion = aVisibleRegion->GetBounds();
renderRegion = &tmpRegion;
}
#endif
// Render the low and high precision buffers.
RenderLayerBuffer(mLowPrecisionTiledBuffer,

8
gfx/thebes/gfxFontMissingGlyphs.cpp
View file

@ -155,7 +155,6 @@ static const Float BOX_BORDER_OPACITY = 0.5;
* Quartz cairo backend which doesn't generally support masking with surfaces.
* So for now we just paint a bunch of rectangles...
*/
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
static void
DrawHexChar(uint32_t aDigit, const Point& aPt, DrawTarget& aDrawTarget,
const Pattern &aPattern)
@ -182,7 +181,6 @@ DrawHexChar(uint32_t aDigit, const Point& aPt, DrawTarget& aDrawTarget,
RefPtr<Path> path = builder->Finish();
aDrawTarget.Fill(path, aPattern);
}
#endif // MOZ_GFX_OPTIMIZE_MOBILE
void
gfxFontMissingGlyphs::DrawMissingGlyph(uint32_t aChar,
@ -209,15 +207,10 @@ gfxFontMissingGlyphs::DrawMissingGlyph(uint32_t aChar,
if (!borderStrokeRect.IsEmpty()) {
ColorPattern adjustedColor = color;
color.mColor.a *= BOX_BORDER_OPACITY;
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
aDrawTarget.FillRect(borderStrokeRect, adjustedColor);
#else
StrokeOptions strokeOptions(BOX_BORDER_WIDTH);
aDrawTarget.StrokeRect(borderStrokeRect, adjustedColor, strokeOptions);
#endif
}
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
Point center = aRect.Center();
Float halfGap = HEX_CHAR_GAP / 2.f;
Float top = -(MINIFONT_HEIGHT + halfGap);
@ -266,7 +259,6 @@ gfxFontMissingGlyphs::DrawMissingGlyph(uint32_t aChar,
Point(third, halfGap), aDrawTarget, color);
}
}
#endif
}
Float

8
gfx/thebes/gfxPrefs.h
View file

@ -460,15 +460,7 @@ private:
DECL_GFX_PREF(Live, "layers.bench.enabled", LayersBenchEnabled, bool, false);
DECL_GFX_PREF(Once, "layers.bufferrotation.enabled", BufferRotationEnabled, bool, true);
DECL_GFX_PREF(Live, "layers.child-process-shutdown", ChildProcessShutdown, bool, true);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
// If MOZ_GFX_OPTIMIZE_MOBILE is defined, we force component alpha off
// and ignore the preference.
DECL_GFX_PREF(Skip, "layers.componentalpha.enabled", ComponentAlphaEnabled, bool, false);
#else
// If MOZ_GFX_OPTIMIZE_MOBILE is not defined, we actually take the
// preference value, defaulting to true.
DECL_GFX_PREF(Once, "layers.componentalpha.enabled", ComponentAlphaEnabled, bool, true);
#endif
DECL_GFX_PREF(Live, "layers.composer2d.enabled", Composer2DCompositionEnabled, bool, false);
DECL_GFX_PREF(Once, "layers.d3d11.force-warp", LayersD3D11ForceWARP, bool, false);
DECL_GFX_PREF(Live, "layers.deaa.enabled", LayersDEAAEnabled, bool, false);

66
gfx/thebes/gfxUtils.cpp
View file

@ -378,7 +378,6 @@ gfxUtils::ConvertBGRAtoRGBA(uint8_t* aData, uint32_t aLength)
libyuv::ABGRToARGB(aData, aLength, aData, aLength, aLength / 4, 1);
}
#if !defined(MOZ_GFX_OPTIMIZE_MOBILE)
/**
* This returns the fastest operator to use for solid surfaces which have no
* alpha channel or their alpha channel is uniformly opaque.
@ -448,66 +447,7 @@ CreateSamplingRestrictedDrawable(gfxDrawable* aDrawable,
RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable(surface, size, gfxMatrix::Translation(-needed.TopLeft()));
return drawable.forget();
}
#endif // !MOZ_GFX_OPTIMIZE_MOBILE
/* These heuristics are based on Source/WebCore/platform/graphics/skia/ImageSkia.cpp:computeResamplingMode() */
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
static SamplingFilter ReduceResamplingFilter(SamplingFilter aSamplingFilter,
int aImgWidth, int aImgHeight,
float aSourceWidth, float aSourceHeight)
{
// Images smaller than this in either direction are considered "small" and
// are not resampled ever (see below).
const int kSmallImageSizeThreshold = 8;
// The amount an image can be stretched in a single direction before we
// say that it is being stretched so much that it must be a line or
// background that doesn't need resampling.
const float kLargeStretch = 3.0f;
if (aImgWidth <= kSmallImageSizeThreshold
|| aImgHeight <= kSmallImageSizeThreshold) {
// Never resample small images. These are often used for borders and
// rules (think 1x1 images used to make lines).
return SamplingFilter::POINT;
}
if (aImgHeight * kLargeStretch <= aSourceHeight || aImgWidth * kLargeStretch <= aSourceWidth) {
// Large image tiling detected.
// Don't resample if it is being tiled a lot in only one direction.
// This is trying to catch cases where somebody has created a border
// (which might be large) and then is stretching it to fill some part
// of the page.
if (fabs(aSourceWidth - aImgWidth)/aImgWidth < 0.5 || fabs(aSourceHeight - aImgHeight)/aImgHeight < 0.5)
return SamplingFilter::POINT;
// The image is growing a lot and in more than one direction. Resampling
// is slow and doesn't give us very much when growing a lot.
return aSamplingFilter;
}
/* Some notes on other heuristics:
The Skia backend also uses nearest for backgrounds that are stretched by
a large amount. I'm not sure this is common enough for us to worry about
now. It also uses nearest for backgrounds/avoids high quality for images
that are very slightly scaled. I'm also not sure that very slightly
scaled backgrounds are common enough us to worry about.
We don't currently have much support for doing high quality interpolation.
The only place this currently happens is on Quartz and we don't have as
much control over it as would be needed. Webkit avoids using high quality
resampling during load. It also avoids high quality if the transformation
is not just a scale and translation
WebKit bug #40045 added code to avoid resampling different parts
of an image with different methods by using a resampling hint size.
It currently looks unused in WebKit but it's something to watch out for.
*/
return aSamplingFilter;
}
#else
static SamplingFilter ReduceResamplingFilter(SamplingFilter aSamplingFilter,
int aImgWidth, int aImgHeight,
int aSourceWidth, int aSourceHeight)
@ -515,7 +455,6 @@ static SamplingFilter ReduceResamplingFilter(SamplingFilter aSamplingFilter,
// Just pass the filter through unchanged
return aSamplingFilter;
}
#endif
#ifdef MOZ_WIDGET_COCOA
// Only prescale a temporary surface if we're going to repeat it often.
@ -667,10 +606,6 @@ gfxUtils::DrawPixelSnapped(gfxContext* aContext,
}
#endif
// On Mobile, we don't ever want to do this; it has the potential for
// allocating very large temporary surfaces, especially since we'll
// do full-page snapshots often (see bug 749426).
#if !defined(MOZ_GFX_OPTIMIZE_MOBILE)
RefPtr<gfxDrawable> restrictedDrawable =
CreateSamplingRestrictedDrawable(aDrawable, aContext,
aRegion, aFormat);
@ -682,7 +617,6 @@ gfxUtils::DrawPixelSnapped(gfxContext* aContext,
// drawn without tiling.
extendMode = ExtendMode::CLAMP;
}
#endif
}
}

6
layout/base/FrameLayerBuilder.cpp
View file

@ -6275,14 +6275,8 @@ ContainerState::CreateMaskLayer(Layer *aLayer,
uint32_t maxSize = mManager->GetMaxTextureSize();
NS_ASSERTION(maxSize > 0, "Invalid max texture size");
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
// Make mask image width aligned to 4. See Bug 1245552.
gfx::Size surfaceSize(std::min<gfx::Float>(GetAlignedStride<4>(NSToIntCeil(boundingRect.Width()), 1), maxSize),
std::min<gfx::Float>(boundingRect.Height(), maxSize));
#else
gfx::Size surfaceSize(std::min<gfx::Float>(boundingRect.Width(), maxSize),
std::min<gfx::Float>(boundingRect.Height(), maxSize));
#endif
// maskTransform is applied to the clip when it is painted into the mask (as a
// component of imageTransform), and its inverse used when the mask is used for

4
layout/base/nsDisplayList.cpp
View file

@ -1488,11 +1488,7 @@ nsDisplayListBuilder::IsInWillChangeBudget(nsIFrame* aFrame,
return onBudget;
}
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
const float gAGRBudgetAreaMultiplier = 0.3;
#else
const float gAGRBudgetAreaMultiplier = 3.0;
#endif
bool
nsDisplayListBuilder::AddToAGRBudget(nsIFrame* aFrame)

4
layout/base/nsPresShell.cpp
View file

@ -4592,11 +4592,7 @@ PresShell::RenderDocument(const nsRect& aRect, uint32_t aFlags,
nsPresContext::AppUnitsToFloatCSSPixels(aRect.width),
nsPresContext::AppUnitsToFloatCSSPixels(aRect.height));
aThebesContext->NewPath();
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
aThebesContext->Rectangle(r, true);
#else
aThebesContext->Rectangle(r);
#endif
nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
if (!rootFrame) {

4
layout/generic/nsCanvasFrame.cpp
View file

@ -271,7 +271,6 @@ nsDisplayCanvasBackgroundColor::WriteDebugInfo(std::stringstream& aStream)
}
#endif
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
static void BlitSurface(DrawTarget* aDest, const gfxRect& aRect, DrawTarget* aSource)
{
RefPtr<SourceSurface> source = aSource->Snapshot();
@ -279,7 +278,6 @@ static void BlitSurface(DrawTarget* aDest, const gfxRect& aRect, DrawTarget* aSo
Rect(aRect.x, aRect.y, aRect.width, aRect.height),
Rect(0, 0, aRect.width, aRect.height));
}
#endif
void
nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
@ -289,7 +287,6 @@ nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
RefPtr<gfxContext> dest = aCtx->ThebesContext();
gfxRect destRect;
if (IsSingleFixedPositionImage(aBuilder, bgClipRect, &destRect) &&
@ -322,7 +319,6 @@ nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
return;
}
}
#endif
PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
}

6
layout/generic/nsPluginFrame.cpp
View file

@ -1429,12 +1429,6 @@ nsPluginFrame::BuildLayer(nsDisplayListBuilder* aBuilder,
imglayer->SetScaleToSize(size, ScaleMode::STRETCH);
imglayer->SetContainer(container);
SamplingFilter samplingFilter = nsLayoutUtils::GetSamplingFilterForFrame(this);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
if (!aManager->IsCompositingCheap()) {
// Pixman just horrible with bilinear filter scaling
samplingFilter = SamplingFilter::POINT;
}
#endif
imglayer->SetSamplingFilter(samplingFilter);
layer->SetContentFlags(IsOpaque() ? Layer::CONTENT_OPAQUE : 0);

19
old-configure.in
View file

@ -3789,25 +3789,6 @@ dnl =
dnl ========================================================
MOZ_ARG_HEADER(Runtime debugging and Optimizations)
dnl ========================================================
dnl enable mobile optimizations
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(mobile-optimize,
[ --enable-mobile-optimize
Enable mobile optimizations],
MOZ_GFX_OPTIMIZE_MOBILE=1)
AC_SUBST(MOZ_GFX_OPTIMIZE_MOBILE)
if test "$MOZ_GFX_OPTIMIZE_MOBILE"; then
# We ignore paint will resample on mobile for performance.
# We may want to revisit this later.
MOZ_IGNORE_PAINT_WILL_RESAMPLE=1
AC_DEFINE(MOZ_GFX_OPTIMIZE_MOBILE)
AC_DEFINE(MOZ_IGNORE_PAINT_WILL_RESAMPLE)
fi
dnl ========================================================
dnl = Enable code optimization. ON by default.
dnl ========================================================